diff --git a/Cargo.lock b/Cargo.lock
index 64e9815..aabf7f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -56,14 +56,10 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "ecolor"
 version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f99fe3cac305af9d6d92971af60d0f7ea4d783201ef1673571567b6699964d9"
 
 [[package]]
 name = "egui"
 version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6412a21e0bde7c0918f7fb44bbbb86b5e1f88e63c026a4e747cc7af02f76dfbe"
 dependencies = [
  "ahash",
  "epaint",
@@ -89,14 +85,10 @@ dependencies = [
 [[package]]
 name = "emath"
 version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8ecd80612937e0267909d5351770fe150004e24dab93954f69ca62eecd3f77e"
 
 [[package]]
 name = "epaint"
 version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12e78b5c58a1f7f621f9d546add2adce20636422c9b251e29f749e8a2f713c95"
 dependencies = [
  "ab_glyph",
  "ahash",
diff --git a/Cargo.toml b/Cargo.toml
index c25b2e6..c49bf11 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,13 +6,10 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-egui = "0.21.0"
+egui = { path = "./egui/crates/egui" }
 
 [dependencies.egui-inspect]
 path = "./egui_inspect"
 
 #[profile.dev]
 #incremental = false # Buggy on latest rustc nightly, keeps ICEing
-
-[profile.dev.package."*"]
-opt-level = 2
diff --git a/egui/.cargo/config.toml b/egui/.cargo/config.toml
new file mode 100644
index 0000000..be614b0
--- /dev/null
+++ b/egui/.cargo/config.toml
@@ -0,0 +1,6 @@
+# clipboard api is still unstable, so web-sys requires the below flag to be passed for copy (ctrl + c) to work
+# https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html
+# check status at https://developer.mozilla.org/en-US/docs/Web/API/Clipboard#browser_compatibility
+# we don't use `[build]` because of rust analyzer's build cache invalidation https://github.com/emilk/eframe_template/issues/93
+[target.wasm32-unknown-unknown]
+rustflags = ["--cfg=web_sys_unstable_apis"]
diff --git a/egui/.github/ISSUE_TEMPLATE/bug_report.md b/egui/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..66c1786
--- /dev/null
+++ b/egui/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,50 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+<!--
+First look if there is already a similar bug report. If there is, upvote the issue with 👍
+
+Please also check if the bug is still present in latest master! Do so by adding the following lines to your Cargo.toml:
+
+
+[patch.crates-io]
+egui = { git = "https://github.com/emilk/egui", branch = "master" }
+# if you're using eframe:
+eframe = { git = "https://github.com/emilk/egui", branch = "master" }
+-->
+
+**Describe the bug**
+<!-- A clear and concise description of what the bug is. An image is good, a gif or movie is better! -->
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. <!-- Go to '…' -->
+2. <!-- Click on '…' -->
+3. <!-- Scroll down to '…' -->
+4. <!-- See error -->
+
+**Expected behavior**
+<!-- A clear and concise description of what you expected to happen. -->
+
+**Screenshots**
+<!-- If applicable, add screenshots to help explain your problem. -->
+
+**Desktop (please complete the following information):**
+ - OS: <!-- e.g. iOS -->
+ - Browser <!-- e.g. chrome, safari -->
+ - Version <!-- e.g. 22 -->
+
+**Smartphone (please complete the following information):**
+ - Device: <!-- e.g. iPhone6 -->
+ - OS: <!-- e.g. iOS8.1 -->
+ - Browser <!-- e.g. stock browser, safari -->
+ - Version <!-- e.g. 22 -->
+
+**Additional context**
+<!-- Add any other context about the problem here. -->
diff --git a/egui/.github/ISSUE_TEMPLATE/feature_request.md b/egui/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..b1c0901
--- /dev/null
+++ b/egui/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,25 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature-request
+assignees: ''
+
+---
+
+<!--
+First look if there is already a similar feature request. If there is, upvote the issue with 👍
+-->
+
+
+**Is your feature request related to a problem? Please describe.**
+<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when […] -->
+
+**Describe the solution you'd like**
+<!-- A clear and concise description of what you want to happen. -->
+
+**Describe alternatives you've considered**
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+**Additional context**
+<!-- Add any other context or screenshots about the feature request here. -->
diff --git a/egui/.github/ISSUE_TEMPLATE/other.md b/egui/.github/ISSUE_TEMPLATE/other.md
new file mode 100644
index 0000000..db031d1
--- /dev/null
+++ b/egui/.github/ISSUE_TEMPLATE/other.md
@@ -0,0 +1,10 @@
+---
+name: Other
+about: For issues that are neither bugs or feature requests
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+If you are asking a question, use [the egui discussions forum](https://github.com/emilk/egui/discussions/categories/q-a) instead!
diff --git a/egui/.github/pull_request_template.md b/egui/.github/pull_request_template.md
new file mode 100644
index 0000000..c442e13
--- /dev/null
+++ b/egui/.github/pull_request_template.md
@@ -0,0 +1,15 @@
+<!--
+Please read the "Making a PR" section of [`CONTRIBUTING.md`](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md) before opening a Pull Request!
+
+* Keep your PR:s small and focused.
+* If applicable, add a screenshot or gif.
+* Unless this is a trivial change, add a line to the relevant `CHANGELOG.md` under "Unreleased".
+* If it is a non-trivial addition, consider adding a demo for it to `egui_demo_lib`.
+* Remember to run `cargo fmt` and `cargo clippy`.
+* Open the PR as a draft until you have self-reviewed it and run `./scripts/check.sh`.
+* When you have addressed a PR comment, mark it as resolved.
+
+Please be patient! I will review you PR, but my time is limited!
+-->
+
+Closes <https://github.com/emilk/egui/issues/THE_RELEVANT_ISSUE>.
diff --git a/egui/.github/workflows/rust.yml b/egui/.github/workflows/rust.yml
new file mode 100644
index 0000000..3ca1d3e
--- /dev/null
+++ b/egui/.github/workflows/rust.yml
@@ -0,0 +1,237 @@
+on: [push, pull_request]
+
+name: CI
+
+env:
+  # web_sys_unstable_apis is required to enable the web_sys clipboard API which eframe web uses,
+  # as well as by the wasm32-backend of the wgpu crate.
+  # https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Clipboard.html
+  # https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html
+  RUSTFLAGS: --cfg=web_sys_unstable_apis -D warnings
+  RUSTDOCFLAGS: -D warnings
+
+jobs:
+  fmt-crank-check-test:
+    name: Format + check + test
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: default
+          toolchain: 1.65.0
+          override: true
+
+      - name: Install packages (Linux)
+        if: runner.os == 'Linux'
+        #uses: awalsh128/cache-apt-pkgs-action@v1.2.2
+        #TODO(emilk) use upstream when https://github.com/awalsh128/cache-apt-pkgs-action/pull/90 is merged
+        uses: rerun-io/cache-apt-pkgs-action@59534850182063abf1b2c11bb3686722a12a8397
+        with:
+          packages: libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev libgtk-3-dev # libgtk-3-dev is used by rfd
+          version: 1.0
+          execute_install_scripts: true
+
+      - name: Set up cargo cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - name: Install cargo-cranky
+        uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-cranky
+
+      - name: check --all-features
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --locked --all-features --all-targets
+
+      - name: check default features
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --locked --all-targets
+
+      - name: check --no-default-features
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --locked --no-default-features --lib --all-targets
+
+      - name: check epaint --no-default-features
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --locked --no-default-features --lib --all-targets -p epaint
+
+      - name: check eframe --no-default-features
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --locked --no-default-features --lib --all-targets -p eframe
+
+      - name: Test doc-tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --doc --all-features
+
+      - name: cargo doc --lib
+        uses: actions-rs/cargo@v1
+        with:
+          command: doc
+          args: --lib --no-deps --all-features
+
+      - name: cargo doc --document-private-items
+        uses: actions-rs/cargo@v1
+        with:
+          command: doc
+          args: --document-private-items --no-deps --all-features
+
+      - name: Test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features
+
+      - name: Cranky
+        uses: actions-rs/cargo@v1
+        with:
+          command: cranky
+          args: --all-targets --all-features -- -D warnings
+
+  # ---------------------------------------------------------------------------
+
+  check_wasm:
+    name: Check wasm32 + wasm-bindgen
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.65.0
+          target: wasm32-unknown-unknown
+          override: true
+
+      - run: sudo apt-get update && sudo apt-get install libgtk-3-dev
+
+      - name: Set up cargo cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install cargo-cranky
+        uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-cranky
+
+      - name: Check wasm32 egui_demo_app
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: -p egui_demo_app --lib --target wasm32-unknown-unknown
+
+      - name: Check wasm32 egui_demo_app --all-features
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: -p egui_demo_app --lib --target wasm32-unknown-unknown --all-features
+
+      - name: Check wasm32 eframe
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: -p eframe --lib --no-default-features --features glow,persistence --target wasm32-unknown-unknown
+
+      - name: wasm-bindgen
+        uses: jetli/wasm-bindgen-action@v0.1.0
+        with:
+          version: "0.2.84"
+
+      - run: ./scripts/wasm_bindgen_check.sh --skip-setup
+
+      - name: Cranky wasm32
+        uses: actions-rs/cargo@v1
+        with:
+          command: cranky
+          args: --target wasm32-unknown-unknown --all-features -p egui_demo_app --lib -- -D warnings
+
+  # ---------------------------------------------------------------------------
+
+  cargo-deny:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: aarch64-apple-darwin
+          - target: aarch64-linux-android
+          - target: i686-pc-windows-gnu
+          - target: i686-pc-windows-msvc
+          - target: i686-unknown-linux-gnu
+          - target: wasm32-unknown-unknown
+          - target: x86_64-apple-darwin
+          - target: x86_64-pc-windows-gnu
+          - target: x86_64-pc-windows-msvc
+          - target: x86_64-unknown-linux-gnu
+          - target: x86_64-unknown-linux-musl
+          - target: x86_64-unknown-redox
+
+    name: cargo-deny ${{ matrix.target }}
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: EmbarkStudios/cargo-deny-action@v1
+        with:
+          rust-version: "1.65.0"
+          log-level: error
+          command: check
+          arguments: ${{ matrix.flags }} --target  ${{ matrix.target }}
+
+  # ---------------------------------------------------------------------------
+
+  android:
+    name: android
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.65.0
+          target: aarch64-linux-android
+          override: true
+
+      - name: Set up cargo cache
+        uses: Swatinem/rust-cache@v2
+
+      - run: cargo check --features wgpu,android-native-activity --target aarch64-linux-android
+        working-directory: crates/eframe
+
+  # ---------------------------------------------------------------------------
+
+  windows:
+    name: Check Windows
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.65.0
+          override: true
+
+      - name: Set up cargo cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Check
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all-targets --all-features
diff --git a/egui/.github/workflows/typos.yml b/egui/.github/workflows/typos.yml
new file mode 100644
index 0000000..c3bc841
--- /dev/null
+++ b/egui/.github/workflows/typos.yml
@@ -0,0 +1,17 @@
+# https://github.com/crate-ci/typos
+# Add exceptions to _typos.toml
+# install and run locally: cargo install typos-cli && typos
+
+name: Spell Check
+on: [pull_request]
+
+jobs:
+  run:
+    name: Spell Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@v2
+
+      - name: Check spelling of entire workspace
+        uses: crate-ci/typos@master
diff --git a/egui/.gitignore b/egui/.gitignore
new file mode 100644
index 0000000..c43b955
--- /dev/null
+++ b/egui/.gitignore
@@ -0,0 +1,7 @@
+.DS_Store
+**/target
+**/target_ra
+**/target_wasm
+/.*.json
+/.vscode
+/media/*
diff --git a/egui/ARCHITECTURE.md b/egui/ARCHITECTURE.md
new file mode 100644
index 0000000..00386a9
--- /dev/null
+++ b/egui/ARCHITECTURE.md
@@ -0,0 +1,53 @@
+# Architecture
+This document describes how the crates that make up egui are all connected.
+
+Also see [`CONTRIBUTING.md`](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md) for what to do before opening a PR.
+
+
+## Crate overview
+The crates in this repository are: `egui, emath, epaint, egui_extras, egui-winit, egui_glium, egui_glow, egui_demo_lib, egui_demo_app`.
+
+### `egui`: The main GUI library.
+Example code: `if ui.button("Click me").clicked() { … }`
+This is the crate where the bulk of the code is at. `egui` depends only on `emath` and `epaint`.
+
+### `emath`: minimal 2D math library
+Examples: `Vec2, Pos2, Rect, lerp, remap`
+
+### `epaint`
+2d shapes and text that can be turned into textured triangles.
+
+Example: `Shape::Circle { center, radius, fill, stroke }`
+
+Depends on `emath`.
+
+### `egui_extras`
+This adds additional features on top of `egui`.
+
+### `egui-winit`
+This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [winit](https://crates.io/crates/winit).
+
+The library translates winit events to egui, handled copy/paste, updates the cursor, open links clicked in egui, etc.
+
+### `egui_glium`
+Puts an egui app inside a native window on your laptop. Paints the triangles that egui outputs using [glium](https://github.com/glium/glium).
+
+### `egui_glow`
+Puts an egui app inside a native window on your laptop. Paints the triangles that egui outputs using [glow](https://github.com/grovesNL/glow).
+
+### `eframe`
+`eframe` is the official `egui` framework, built so you can compile the same app for either web or native.
+
+The demo that you can see at <https://www.egui.rs> is using `eframe` to host the `egui`. The demo code is found in:
+
+### `egui_demo_lib`
+Depends on `egui`.
+This contains a bunch of uses of `egui` and looks like the ui code you would write for an `egui` app.
+
+### `egui_demo_app`
+Thin wrapper around `egui_demo_lib` so we can compile it to a web site or a native app executable.
+Depends on `egui_demo_lib` + `eframe`.
+
+### Other integrations
+
+There are also many great integrations for game engines such as `bevy` and `miniquad` which you can find at <https://github.com/emilk/egui#integrations>.
diff --git a/egui/CHANGELOG.md b/egui/CHANGELOG.md
new file mode 100644
index 0000000..41b0bf9
--- /dev/null
+++ b/egui/CHANGELOG.md
@@ -0,0 +1,850 @@
+# egui changelog
+All notable changes to the `egui` crate will be documented in this file.
+
+NOTE: [`epaint`](crates/epaint/CHANGELOG.md), [`eframe`](crates/eframe/CHANGELOG.md), [`egui-winit`](crates/egui-winit/CHANGELOG.md), [`egui_glium`](crates/egui_glium/CHANGELOG.md), [`egui_glow`](crates/egui_glow/CHANGELOG.md) and [`egui-wgpu`](crates/egui-wgpu/CHANGELOG.md) have their own changelogs!
+
+
+## Unreleased
+* Add `char_limit` to `TextEdit` singleline mode to limit the amount of characters
+* ⚠️ BREAKING: `Plot::link_axis` and `Plot::link_cursor` now take the name of the group ([#2410](https://github.com/emilk/egui/pull/2410)).
+
+
+## 0.21.0 - 2023-02-08 - Deadlock fix and style customizability
+* ⚠️ BREAKING: `egui::Context` now use closures for locking ([#2625](https://github.com/emilk/egui/pull/2625)):
+  * `ctx.input().key_pressed(Key::A)` -> `ctx.input(|i| i.key_pressed(Key::A))`
+  * `ui.memory().toggle_popup(popup_id)` -> `ui.memory_mut(|mem| mem.toggle_popup(popup_id))`
+
+### Added ⭐
+* Add `Response::drag_started_by` and `Response::drag_released_by` for convenience, similar to `dragged` and `dragged_by` ([#2507](https://github.com/emilk/egui/pull/2507)).
+* Add `PointerState::*_pressed` to check if the given button was pressed in this frame ([#2507](https://github.com/emilk/egui/pull/2507)).
+* `Event::Key` now has a `repeat` field that is set to `true` if the event was the result of a key-repeat ([#2435](https://github.com/emilk/egui/pull/2435)).
+* Add `Slider::drag_value_speed`, which lets you ask for finer precision when dragging the slider value rather than the actual slider.
+* Add `Memory::any_popup_open`, which returns true if any popup is currently open ([#2464](https://github.com/emilk/egui/pull/2464)).
+* Add `Plot::clamp_grid` to only show grid where there is data ([#2480](https://github.com/emilk/egui/pull/2480)).
+* Add `ScrollArea::drag_to_scroll` if you want to turn off that feature.
+* Add `Response::on_hover_and_drag_cursor`.
+* Add `Window::default_open` ([#2539](https://github.com/emilk/egui/pull/2539)).
+* Add `ProgressBar::fill` if you want to set the fill color manually. ([#2618](https://github.com/emilk/egui/pull/2618)).
+* Add `Button::rounding` to enable round buttons ([#2616](https://github.com/emilk/egui/pull/2616)).
+* Add `WidgetVisuals::optional_bg_color` - set it to `Color32::TRANSPARENT` to hide button backgrounds ([#2621](https://github.com/emilk/egui/pull/2621)).
+* Add `Context::screen_rect` and `Context::set_cursor_icon` ([#2625](https://github.com/emilk/egui/pull/2625)).
+* You can turn off the vertical line left of indented regions with `Visuals::indent_has_left_vline` ([#2636](https://github.com/emilk/egui/pull/2636)).
+* Add `Response.highlight` to highlight a widget ([#2632](https://github.com/emilk/egui/pull/2632)).
+* Add `Separator::grow` and `Separator::shrink` ([#2665](https://github.com/emilk/egui/pull/2665)).
+* Add `Slider::trailing_fill` for trailing color behind the circle like a `ProgressBar` ([#2660](https://github.com/emilk/egui/pull/2660)).
+
+### Changed 🔧
+* Improved plot grid appearance ([#2412](https://github.com/emilk/egui/pull/2412)).
+* Improved the algorithm for picking the number of decimals to show when hovering values in the `Plot`.
+* Default `ComboBox` is now controlled with `Spacing::combo_width` ([#2621](https://github.com/emilk/egui/pull/2621)).
+* `DragValue` and `Slider` now use the proportional font ([#2638](https://github.com/emilk/egui/pull/2638)).
+* `ScrollArea` is less aggressive about clipping its contents ([#2665](https://github.com/emilk/egui/pull/2665)).
+* Updated to be compatible with a major breaking change in AccessKit that drastically reduces memory usage when accessibility is enabled ([#2678](https://github.com/emilk/egui/pull/2678)).
+* Improve `DragValue` behavior ([#2649](https://github.com/emilk/egui/pull/2649), [#2650](https://github.com/emilk/egui/pull/2650), [#2688](https://github.com/emilk/egui/pull/2688), [#2638](https://github.com/emilk/egui/pull/2638)).
+
+### Fixed 🐛
+* Trigger `PointerEvent::Released` for drags ([#2507](https://github.com/emilk/egui/pull/2507)).
+* Expose `TextEdit`'s multiline flag to AccessKit ([#2448](https://github.com/emilk/egui/pull/2448)).
+* Don't render `\r` (Carriage Return) ([#2452](https://github.com/emilk/egui/pull/2452)).
+* The `button_padding` style option works closer as expected with image+text buttons now ([#2510](https://github.com/emilk/egui/pull/2510)).
+* Menus are now moved to fit on the screen.
+* Fix `Window::pivot` causing windows to move around ([#2694](https://github.com/emilk/egui/pull/2694)).
+
+
+## 0.20.1 - 2022-12-11 - Fix key-repeat
+### Changed 🔧
+* `InputState`: all press functions again include key repeats (like in egui 0.19) ([#2429](https://github.com/emilk/egui/pull/2429)).
+* Improve the look of thin white lines ([#2437](https://github.com/emilk/egui/pull/2437)).
+
+### Fixed 🐛
+* Fix key-repeats for `TextEdit`, `Slider`s, etc ([#2429](https://github.com/emilk/egui/pull/2429)).
+
+
+## 0.20.0 - 2022-12-08 - AccessKit, prettier text, overlapping widgets
+* MSRV (Minimum Supported Rust Version) is now `1.65.0` ([#2314](https://github.com/emilk/egui/pull/2314)).
+* ⚠️ BREAKING: egui now expects integrations to do all color blending in gamma space ([#2071](https://github.com/emilk/egui/pull/2071)).
+* ⚠️ BREAKING: if you have overlapping interactive widgets, only the top widget (last added) will be interactive ([#2244](https://github.com/emilk/egui/pull/2244)).
+
+### Added ⭐
+* Added helper functions for animating panels that collapse/expand ([#2190](https://github.com/emilk/egui/pull/2190)).
+* Added `Context::os/Context::set_os` to query/set what operating system egui believes it is running on ([#2202](https://github.com/emilk/egui/pull/2202)).
+* Added `Button::shortcut_text` for showing keyboard shortcuts in menu buttons ([#2202](https://github.com/emilk/egui/pull/2202)).
+* Added `egui::KeyboardShortcut` for showing keyboard shortcuts in menu buttons ([#2202](https://github.com/emilk/egui/pull/2202)).
+* Texture loading now takes a `TexureOptions` with minification and magnification filters ([#2224](https://github.com/emilk/egui/pull/2224)).
+* Added `Key::Minus` and `Key::Equals` ([#2239](https://github.com/emilk/egui/pull/2239)).
+* Added `egui::gui_zoom` module with helpers for scaling the whole GUI of an app ([#2239](https://github.com/emilk/egui/pull/2239)).
+* You can now put one interactive widget on top of another, and only one will get interaction at a time ([#2244](https://github.com/emilk/egui/pull/2244)).
+* Added `spacing.menu_margin` for customizing menu spacing ([#2036](https://github.com/emilk/egui/pull/2036))
+* Added possibility to enable text wrap for the selected text of `egui::ComboBox` ([#2272](https://github.com/emilk/egui/pull/2272))
+* Added `Area::constrain` and `Window::constrain` which constrains area to the screen bounds ([#2270](https://github.com/emilk/egui/pull/2270)).
+* Added `Area::pivot` and `Window::pivot` which controls what part of the window to position ([#2303](https://github.com/emilk/egui/pull/2303)).
+* Added support for [thin space](https://en.wikipedia.org/wiki/Thin_space).
+* Added optional integration with [AccessKit](https://accesskit.dev/) for implementing platform accessibility APIs ([#2294](https://github.com/emilk/egui/pull/2294)).
+* Added `panel_fill`, `window_fill` and `window_stroke` to `Visuals` for your theming pleasure ([#2406](https://github.com/emilk/egui/pull/2406)).
+* Plots:
+  * Allow linking plot cursors ([#1722](https://github.com/emilk/egui/pull/1722)).
+  * Added `Plot::auto_bounds_x/y` and `Plot::reset` ([#2029](https://github.com/emilk/egui/pull/2029)).
+  * Added `PlotUi::translate_bounds` ([#2145](https://github.com/emilk/egui/pull/2145)).
+  * Added `PlotUi::set_plot_bounds` ([#2320](https://github.com/emilk/egui/pull/2320)).
+  * Added `PlotUi::plot_secondary_clicked` ([#2318](https://github.com/emilk/egui/pull/2318)).
+
+### Changed 🔧
+* Panels always have a separator line, but no stroke on other sides. Their spacing has also changed slightly ([#2261](https://github.com/emilk/egui/pull/2261)).
+* Tooltips are only shown when mouse pointer is still ([#2263](https://github.com/emilk/egui/pull/2263)).
+* Make it slightly easier to click buttons ([#2304](https://github.com/emilk/egui/pull/2304)).
+* `egui::color` has been renamed `egui::ecolor` ([#2399](https://github.com/emilk/egui/pull/2399)).
+
+### Fixed 🐛
+* ⚠️ BREAKING: Fix text being too small ([#2069](https://github.com/emilk/egui/pull/2069)).
+* Improve mixed CJK/Latin line-breaking ([#1986](https://github.com/emilk/egui/pull/1986)).
+* Improved text rendering ([#2071](https://github.com/emilk/egui/pull/2071)).
+* Constrain menu popups to the screen ([#2191](https://github.com/emilk/egui/pull/2191)).
+* Less jitter when calling `Context::set_pixels_per_point` ([#2239](https://github.com/emilk/egui/pull/2239)).
+* Fixed popups and color edit going outside the screen.
+* Fixed keyboard support in `DragValue` ([#2342](https://github.com/emilk/egui/pull/2342)).
+* If you nest `ScrollAreas` inside each other, the inner area will now move its scroll bar so it is always visible ([#2371](https://github.com/emilk/egui/pull/2371)).
+* Ignore key-repeats for `input.key_pressed` ([#2334](https://github.com/emilk/egui/pull/2334), [#2389](https://github.com/emilk/egui/pull/2389)).
+* Fixed issue with calling `set_pixels_per_point` each frame ([#2352](https://github.com/emilk/egui/pull/2352)).
+* Fix bug in `ScrollArea::show_rows` ([#2258](https://github.com/emilk/egui/pull/2258)).
+* Fix bug in `plot::Line::fill` ([#2275](https://github.com/emilk/egui/pull/2275)).
+* Only emit `changed` events in `radio_value` and `selectable_value` if the value actually changed ([#2343](https://github.com/emilk/egui/pull/2343)).
+* Fixed sizing bug in `Grid` ([#2384](https://github.com/emilk/egui/pull/2384)).
+* `ComboBox::width` now correctly sets the outer width ([#2406](https://github.com/emilk/egui/pull/2406)).
+
+
+## 0.19.0 - 2022-08-20
+### Added ⭐
+* Added `*_released` & `*_clicked` methods for `PointerState` ([#1582](https://github.com/emilk/egui/pull/1582)).
+* Added `PointerButton::Extra1` and `PointerButton::Extra2` ([#1592](https://github.com/emilk/egui/pull/1592)).
+* Added `egui::hex_color!` to create `Color32`'s from hex strings under the `color-hex` feature ([#1596](https://github.com/emilk/egui/pull/1596)).
+* Optimized painting of filled circles (e.g. for scatter plots) by 10x or more ([#1616](https://github.com/emilk/egui/pull/1616)).
+* Added opt-in feature `deadlock_detection` to detect double-lock of mutexes on the same thread ([#1619](https://github.com/emilk/egui/pull/1619)).
+* Added `InputState::stable_dt`: a more stable estimate for the delta-time in reactive mode ([#1625](https://github.com/emilk/egui/pull/1625)).
+* You can now specify a texture filter for your textures ([#1636](https://github.com/emilk/egui/pull/1636)).
+* Added functions keys in `egui::Key` ([#1665](https://github.com/emilk/egui/pull/1665)).
+* Added support for using `PaintCallback` shapes with the WGPU backend ([#1684](https://github.com/emilk/egui/pull/1684)).
+* Added `Context::request_repaint_after` ([#1694](https://github.com/emilk/egui/pull/1694)).
+* `ctrl-h` now acts like backspace in `TextEdit` ([#1812](https://github.com/emilk/egui/pull/1812)).
+* Added `custom_formatter` method for `Slider` and `DragValue` ([#1851](https://github.com/emilk/egui/issues/1851)).
+* Added `RawInput::has_focus` which backends can set to indicate whether the UI as a whole has the keyboard focus ([#1859](https://github.com/emilk/egui/pull/1859)).
+* Added `PointerState::button_double_clicked()` and `PointerState::button_triple_clicked()` ([#1906](https://github.com/emilk/egui/issues/1906)).
+* Added `custom_formatter`, `binary`, `octal`, and `hexadecimal` to `DragValue` and `Slider` ([#1953](https://github.com/emilk/egui/issues/1953))
+
+### Changed 🔧
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* `PaintCallback` shapes now require the whole callback to be put in an `Arc<dyn Any>` with the value being a backend-specific callback type ([#1684](https://github.com/emilk/egui/pull/1684)).
+* Replaced `needs_repaint` in `FullOutput` with `repaint_after`. Used to force repaint after the set duration in reactive mode ([#1694](https://github.com/emilk/egui/pull/1694)).
+* `Layout::left_to_right` and `Layout::right_to_left` now takes the vertical align as an argument. Previous default was `Align::Center`.
+* Improved ergonomics of adding plot items. All plot items that take a series of 2D coordinates can now be created directly from `Vec<[f64; 2]>`. The `Value` and `Values` types were removed in favor of `PlotPoint` and `PlotPoints` respectively ([#1816](https://github.com/emilk/egui/pull/1816)).
+* `TextBuffer` no longer needs to implement `AsRef<str>` ([#1824](https://github.com/emilk/egui/pull/1824)).
+
+### Fixed 🐛
+* Fixed `Response::changed` for `ui.toggle_value` ([#1573](https://github.com/emilk/egui/pull/1573)).
+* Fixed `ImageButton`'s changing background padding on hover ([#1595](https://github.com/emilk/egui/pull/1595)).
+* Fixed `Plot` auto-bounds bug ([#1599](https://github.com/emilk/egui/pull/1599)).
+* Fixed dead-lock when alt-tabbing while also showing a tooltip ([#1618](https://github.com/emilk/egui/pull/1618)).
+* Fixed `ScrollArea` scrolling when editing an unrelated `TextEdit` ([#1779](https://github.com/emilk/egui/pull/1779)).
+* Fixed `Slider` not always generating events on change ([#1854](https://github.com/emilk/egui/pull/1854)).
+* Fixed jitter of anchored windows for the first frame ([#1856](https://github.com/emilk/egui/pull/1856)).
+* Fixed focus behavior when pressing Tab in a UI with no focused widget ([#1861](https://github.com/emilk/egui/pull/1861)).
+* Fixed automatic plot bounds ([#1865](https://github.com/emilk/egui/pull/1865)).
+
+
+## 0.18.1 - 2022-05-01
+* Change `Shape::Callback` from `&dyn Any` to `&mut dyn Any` to support more backends.
+
+
+## 0.18.0 - 2022-04-30
+
+### Added ⭐
+* Added `Shape::Callback` for backend-specific painting, [with an example](https://github.com/emilk/egui/tree/master/examples/custom_3d_glow) ([#1351](https://github.com/emilk/egui/pull/1351)).
+* Added `Frame::canvas` ([#1362](https://github.com/emilk/egui/pull/1362)).
+* `Context::request_repaint` will now wake up UI thread, if integrations has called `Context::set_request_repaint_callback` ([#1366](https://github.com/emilk/egui/pull/1366)).
+* Added `Plot::allow_scroll`, `Plot::allow_zoom` no longer affects scrolling ([#1382](https://github.com/emilk/egui/pull/1382)).
+* Added `Ui::push_id` to resolve id clashes ([#1374](https://github.com/emilk/egui/pull/1374)).
+* Added `ComboBox::icon` ([#1405](https://github.com/emilk/egui/pull/1405)).
+* Added `Ui::scroll_with_delta`.
+* Added `Frame::outer_margin`.
+* Added `Painter::hline` and `Painter::vline`.
+* Added `Link` and `ui.link` ([#1506](https://github.com/emilk/egui/pull/1506)).
+* Added triple-click support; triple-clicking a TextEdit field will select the whole paragraph ([#1512](https://github.com/emilk/egui/pull/1512)).
+* Added `Plot::x_grid_spacer` and `Plot::y_grid_spacer` for custom grid spacing ([#1180](https://github.com/emilk/egui/pull/1180)).
+* Added `Ui::spinner()` shortcut method ([#1494](https://github.com/emilk/egui/pull/1494)).
+* Added `CursorIcon`s for resizing columns, rows, and the eight cardinal directions.
+* Added `Ui::toggle_value`.
+* Added ability to add any widgets to the header of a collapsing region ([#1538](https://github.com/emilk/egui/pull/1538)).
+
+### Changed 🔧
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* `ClippedMesh` has been replaced with `ClippedPrimitive` ([#1351](https://github.com/emilk/egui/pull/1351)).
+* Renamed `Frame::margin` to `Frame::inner_margin`.
+* Renamed `AlphaImage` to `FontImage` to discourage any other use for it ([#1412](https://github.com/emilk/egui/pull/1412)).
+* Warnings will be painted on screen when there is an `Id` clash for `Grid`, `Plot` or `ScrollArea` ([#1452](https://github.com/emilk/egui/pull/1452)).
+* `Checkbox` and `RadioButton` with an empty label (`""`) will now take up much less space ([#1456](https://github.com/emilk/egui/pull/1456)).
+* Replaced `Memory::top_most_layer` with more flexible `Memory::layer_ids`.
+* Renamed the feature `convert_bytemuck` to `bytemuck` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Renamed the feature `serialize` to `serde` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Renamed `Painter::sub_region` to `Painter::with_clip_rect`.
+
+### Fixed 🐛
+* Fixed `ComboBox`es always being rendered left-aligned ([#1304](https://github.com/emilk/egui/pull/1304)).
+* Fixed ui code that could lead to a deadlock ([#1380](https://github.com/emilk/egui/pull/1380)).
+* Text is darker and more readable in bright mode ([#1412](https://github.com/emilk/egui/pull/1412)).
+* Fixed a lot of broken/missing doclinks  ([#1419](https://github.com/emilk/egui/pull/1419)).
+* Fixed `Ui::add_visible` sometimes leaving the `Ui` in a disabled state ([#1436](https://github.com/emilk/egui/issues/1436)).
+* Added line breaking rules for Japanese text ([#1498](https://github.com/emilk/egui/pull/1498)).
+
+### Deprecated ☢️
+* Deprecated `CollapsingHeader::selectable` ([#1538](https://github.com/emilk/egui/pull/1538)).
+
+### Removed 🔥
+* Removed the `single_threaded/multi_threaded` flags - egui is now always thread-safe ([#1390](https://github.com/emilk/egui/pull/1390)).
+
+### Contributors 🙏
+* [4JX](https://github.com/4JX)
+* [AlexxxRu](https://github.com/AlexxxRu)
+* [ascclemens](https://github.com/ascclemens)
+* [awaken1ng](https://github.com/awaken1ng)
+* [bigfarts](https://github.com/bigfarts)
+* [bobyclaws](https://github.com/bobyclaws)
+* [Bromeon](https://github.com/Bromeon)
+* [cloudhead](https://github.com/cloudhead)
+* [collin-kemper](https://github.com/collin-kemper)
+* [cpterry](https://github.com/cpterry)
+* [dbuch](https://github.com/dbuch)
+* [DusterTheFirst](https://github.com/DusterTheFirst)
+* [Edgeworth ](https://github.com/Edgeworth )
+* [elwerene](https://github.com/elwerene)
+* [follower](https://github.com/follower)
+* [Friz64](https://github.com/Friz64)
+* [Hunter522 ](https://github.com/Hunter522 )
+* [Jake-Shadle](https://github.com/Jake-Shadle)
+* [jean-airoldie ](https://github.com/jean-airoldie )
+* [JelNiSlaw](https://github.com/JelNiSlaw)
+* [juancampa](https://github.com/juancampa)
+* [LU15W1R7H](https://github.com/LU15W1R7H)
+* [mbillingr](https://github.com/mbillingr)
+* [nicklasmoeller](https://github.com/nicklasmoeller)
+* [rukai](https://github.com/rukai)
+* [tami5](https://github.com/tami5)
+* [Titaniumtown](https://github.com/Titaniumtown)
+* [trevyn](https://github.com/trevyn)
+* [waynr](https://github.com/waynr)
+* [zam-5 ](https://github.com/zam-5 )
+
+
+## 0.17.0 - 2022-02-22 - Improved font selection and image handling
+
+### Added ⭐
+* Much improved font selection ([#1154](https://github.com/emilk/egui/pull/1154)):
+  * You can now select any font size and family using `RichText::size` amd `RichText::family` and the new `FontId`.
+  * Easily change text styles with `Style::text_styles`.
+  * Added `Ui::text_style_height`.
+  * Added `TextStyle::resolve`.
+  * Made the v-align and scale of user fonts tweakable ([#1241](https://github.com/emilk/egui/pull/1027)).
+* Plot:
+  * Added `Plot::x_axis_formatter` and `Plot::y_axis_formatter` for custom axis labels ([#1130](https://github.com/emilk/egui/pull/1130)).
+  * Added `Plot::allow_boxed_zoom()`, `Plot::boxed_zoom_pointer()` for boxed zooming on plots ([#1188](https://github.com/emilk/egui/pull/1188)).
+  * Added plot pointer coordinates with `Plot::coordinates_formatter` ([#1235](https://github.com/emilk/egui/pull/1235)).
+  * Added linked axis support for plots via `plot::LinkedAxisGroup` ([#1184](https://github.com/emilk/egui/pull/1184)).
+* `Context::load_texture` to convert an image into a texture which can be displayed using e.g. `ui.image(texture, size)` ([#1110](https://github.com/emilk/egui/pull/1110)).
+* `Ui::input_mut` to modify how subsequent widgets see the `InputState` and a convenience method `InputState::consume_key` for shortcuts or hotkeys ([#1212](https://github.com/emilk/egui/pull/1212)).
+* Added `Ui::add_visible` and `Ui::add_visible_ui`.
+* Added `CollapsingHeader::icon` to override the default open/close icon using a custom function. ([1147](https://github.com/emilk/egui/pull/1147)).
+* Added `ui.data()`, `ctx.data()`, `ctx.options()` and `ctx.tessellation_options()` ([#1175](https://github.com/emilk/egui/pull/1175)).
+* Added `Response::on_hover_text_at_pointer` as a convenience akin to `Response::on_hover_text` ([1179](https://github.com/emilk/egui/pull/1179)).
+* Opt-in dependency on `tracing` crate for logging warnings ([#1192](https://github.com/emilk/egui/pull/1192)).
+* Added `ui.weak(text)`.
+* Added `Slider::step_by` ([1225](https://github.com/emilk/egui/pull/1225)).
+* Added `Context::move_to_top` and `Context::top_most_layer` for managing the layer on the top ([#1242](https://github.com/emilk/egui/pull/1242)).
+* Support a subset of macOS' emacs input field keybindings in `TextEdit` ([#1243](https://github.com/emilk/egui/pull/1243)).
+* Added ability to scroll an UI into view without specifying an alignment ([1247](https://github.com/emilk/egui/pull/1247)).
+* Added `Ui::scroll_to_rect` ([1252](https://github.com/emilk/egui/pull/1252)).
+
+### Changed 🔧
+* ⚠️ `Context::input` and `Ui::input` now locks a mutex. This can lead to a dead-lock is used in an `if let` binding!
+  * `if let Some(pos) = ui.input().pointer.latest_pos()` and similar must now be rewritten on two lines.
+  * Search for this problem in your code using the regex `if let .*input`.
+* Better contrast in the default light mode style ([#1238](https://github.com/emilk/egui/pull/1238)).
+* Renamed `CtxRef` to `Context` ([#1050](https://github.com/emilk/egui/pull/1050)).
+* `Context` can now be cloned and stored between frames ([#1050](https://github.com/emilk/egui/pull/1050)).
+* Renamed `Ui::visible` to `Ui::is_visible`.
+* Split `Event::Text` into `Event::Text` and `Event::Paste` ([#1058](https://github.com/emilk/egui/pull/1058)).
+* Replaced `Style::body_text_style` with more generic `Style::text_styles` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* `TextStyle` is no longer `Copy` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* Replaced `TextEdit::text_style` with `TextEdit::font` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* `Plot::highlight` now takes a `bool` argument ([#1159](https://github.com/emilk/egui/pull/1159)).
+* `ScrollArea::show` now returns a `ScrollAreaOutput`, so you might need to add `.inner` after the call to it ([#1166](https://github.com/emilk/egui/pull/1166)).
+* Replaced `corner_radius: f32` with `rounding: Rounding`, allowing per-corner rounding settings ([#1206](https://github.com/emilk/egui/pull/1206)).
+* Replaced Frame's `margin: Vec2` with `margin: Margin`, allowing for different margins on opposing sides ([#1219](https://github.com/emilk/egui/pull/1219)).
+* Renamed `Plot::custom_label_func` to `Plot::label_formatter` ([#1235](https://github.com/emilk/egui/pull/1235)).
+* `Areas::layer_id_at` ignores non-interatable layers (i.e. Tooltips) ([#1240](https://github.com/emilk/egui/pull/1240)).
+* `ScrollArea`s will not shrink below a certain minimum size, set by `min_scrolled_width/min_scrolled_height` ([1255](https://github.com/emilk/egui/pull/1255)).
+* For integrations:
+  * `Output` has now been renamed `PlatformOutput` and `Context::run` now returns the new `FullOutput` ([#1292](https://github.com/emilk/egui/pull/1292)).
+  * `FontImage` has been replaced by `TexturesDelta` (found in `FullOutput`), describing what textures were loaded and freed each frame ([#1110](https://github.com/emilk/egui/pull/1110)).
+  * The painter must support partial texture updates ([#1149](https://github.com/emilk/egui/pull/1149)).
+  * Added `RawInput::max_texture_side` which should be filled in with e.g. `GL_MAX_TEXTURE_SIZE` ([#1154](https://github.com/emilk/egui/pull/1154)).
+
+### Fixed 🐛
+* Plot `Orientation` was not public, although fields using this type were ([#1130](https://github.com/emilk/egui/pull/1130)).
+* Context menus now respects the theme ([#1043](https://github.com/emilk/egui/pull/1043)).
+* Calling `Context::set_pixels_per_point` before the first frame will now work.
+* Tooltips that don't fit the window don't flicker anymore ([#1240](https://github.com/emilk/egui/pull/1240)).
+* Scroll areas now follow text cursor ([#1252](https://github.com/emilk/egui/pull/1252)).
+* Slider: correctly respond with drag and focus events when interacting with the value directly ([1270](https://github.com/emilk/egui/pull/1270)).
+
+### Contributors 🙏
+* [4JX](https://github.com/4JX)
+* [55nknown](https://github.com/55nknown)
+* [AlanRace](https://github.com/AlanRace)
+* [AlexxxRu](https://github.com/AlexxxRu)
+* [awaken1ng](https://github.com/awaken1ng)
+* [BctfN0HUK7Yg](https://github.com/BctfN0HUK7Yg)
+* [Bromeon](https://github.com/Bromeon)
+* [cat-state](https://github.com/cat)
+* [danielkeller](https://github.com/danielkeller)
+* [dvec](https://github.com/dvec)
+* [Friz64](https://github.com/Friz64)
+* [Gordon01](https://github.com/Gordon01)
+* [HackerFoo](https://github.com/HackerFoo)
+* [juancampa](https://github.com/juancampa)
+* [justinj](https://github.com/justinj)
+* [lampsitter](https://github.com/lampsitter)
+* [LordMZTE](https://github.com/LordMZTE)
+* [manuel-i](https://github.com/manuel)
+* [Mingun](https://github.com/Mingun)
+* [niklaskorz](https://github.com/niklaskorz)
+* [nongiach](https://github.com/nongiach)
+* [parasyte](https://github.com/parasyte)
+* [psiphi75](https://github.com/psiphi75)
+* [s-nie](https://github.com/s)
+* [t18b219k](https://github.com/t18b219k)
+* [terhechte](https://github.com/terhechte)
+* [xudesheng](https://github.com/xudesheng)
+* [yusdacra](https://github.com/yusdacra)
+
+
+## 0.16.1 - 2021-12-31 - Add back `CtxRef::begin_frame,end_frame`
+
+### Added ⭐
+* Added back `CtxRef::begin_frame,end_frame` as an alternative to `CtxRef::run`.
+
+
+## 0.16.0 - 2021-12-29 - Context menus and rich text
+
+### Added ⭐
+* Added context menus: See `Ui::menu_button` and `Response::context_menu` ([#543](https://github.com/emilk/egui/pull/543)).
+* Most widgets containing text (`Label`, `Button` etc) now supports rich text ([#855](https://github.com/emilk/egui/pull/855)).
+* Plots:
+  * Added bar charts and box plots ([#863](https://github.com/emilk/egui/pull/863)).
+  * You can now query information about the plot (e.g. get the mouse position in plot coordinates, or the plot
+    bounds) while adding items. `Plot` ([#766](https://github.com/emilk/egui/pull/766) and
+    [#892](https://github.com/emilk/egui/pull/892)).
+* You can now read and write the cursor of a `TextEdit` ([#848](https://github.com/emilk/egui/pull/848)).
+* When using a custom font you can now specify a font index ([#873](https://github.com/emilk/egui/pull/873)).
+* Added vertical sliders with `Slider::new(…).vertical()` ([#875](https://github.com/emilk/egui/pull/875)).
+* Added `Button::image_and_text` ([#832](https://github.com/emilk/egui/pull/832)).
+* Added `CollapsingHeader::open` to control if it is open or collapsed ([#1006](https://github.com/emilk/egui/pull/1006)).
+* Added `egui::widgets::color_picker::color_picker_color32` to show the color picker.
+
+### Changed 🔧
+* MSRV (Minimum Supported Rust Version) is now `1.56.0`.
+* `ui.add(Button::new("…").text_color(…))` is now `ui.button(RichText::new("…").color(…))` (same for `Label` )([#855](https://github.com/emilk/egui/pull/855)).
+* Plots now provide a `show` method that has to be used to add items to and show the plot ([#766](https://github.com/emilk/egui/pull/766)).
+* `menu::menu(ui, ...)` is now `ui.menu_button(...)` ([#543](https://github.com/emilk/egui/pull/543))
+* Replaced `CtxRef::begin_frame` and `end_frame` with `CtxRef::run` ([#872](https://github.com/emilk/egui/pull/872)).
+* Replaced `scroll_delta` and `zoom_delta` in `RawInput` with `Event::Scroll` and `Event::Zoom`.
+* Unified the four `Memory` data buckets (`data`, `data_temp`, `id_data` and `id_data_temp`) into a single `Memory::data`, with a new interface ([#836](https://github.com/emilk/egui/pull/836)).
+* Replaced `Ui::__test` with `egui::__run_test_ui` ([#872](https://github.com/emilk/egui/pull/872)).
+
+### Fixed 🐛
+* Fixed `ComboBox` and other popups getting clipped to parent window ([#885](https://github.com/emilk/egui/pull/885)).
+* The color picker is now better at keeping the same hue even when saturation goes to zero ([#886](https://github.com/emilk/egui/pull/886)).
+
+### Removed 🔥
+* Removed `egui::math` (use `egui::emath` instead).
+* Removed `egui::paint` (use `egui::epaint` instead).
+
+### Contributors 🙏
+* [5225225](https://github.com/5225225): [#849](https://github.com/emilk/egui/pull/849).
+* [aevyrie](https://github.com/aevyrie): [#966](https://github.com/emilk/egui/pull/966).
+* [B-Reif](https://github.com/B-Reif): [#875](https://github.com/emilk/egui/pull/875).
+* [Bromeon](https://github.com/Bromeon): [#863](https://github.com/emilk/egui/pull/863), [#918](https://github.com/emilk/egui/pull/918).
+* [d10sfan](https://github.com/d10sfan): [#832](https://github.com/emilk/egui/pull/832).
+* [EmbersArc](https://github.com/EmbersArc): [#766](https://github.com/emilk/egui/pull/766), [#892](https://github.com/emilk/egui/pull/892).
+* [Hperigo](https://github.com/Hperigo): [#905](https://github.com/emilk/egui/pull/905).
+* [isegal](https://github.com/isegal): [#934](https://github.com/emilk/egui/pull/934).
+* [mankinskin](https://github.com/mankinskin): [#543](https://github.com/emilk/egui/pull/543).
+* [niladic](https://github.com/niladic): [#499](https://github.com/emilk/egui/pull/499), [#863](https://github.com/emilk/egui/pull/863).
+* [singalen](https://github.com/singalen): [#973](https://github.com/emilk/egui/pull/973).
+* [sumibi-yakitori](https://github.com/sumibi-yakitori): [#830](https://github.com/emilk/egui/pull/830), [#870](https://github.com/emilk/egui/pull/870).
+* [t18b219k](https://github.com/t18b219k): [#868](https://github.com/emilk/egui/pull/868), [#888](https://github.com/emilk/egui/pull/888).
+
+
+## 0.15.0 - 2021-10-24 - Syntax highlighting and hscroll
+
+<img src="media/egui-0.15-code-editor.gif">
+
+### Added ⭐
+* Added horizontal scrolling support to `ScrollArea` and `Window` (opt-in).
+* `TextEdit::layouter`: Add custom text layout for e.g. syntax highlighting or WYSIWYG.
+* `Fonts::layout_job`: New text layout engine allowing mixing fonts, colors and styles, with underlining and strikethrough.
+* Added `ui.add_enabled(bool, widget)` to easily add a possibly disabled widget.
+* Added `ui.add_enabled_ui(bool, |ui| …)` to create a possibly disabled UI section.
+* Added feature `"serialize"` separately from `"persistence"`.
+* Added `egui::widgets::global_dark_light_mode_buttons` to easily add buttons for switching the egui theme.
+* `TextEdit` can now be used to show text which can be selected and copied, but not edited.
+* Added `Memory::caches` for caching things from one frame to the next.
+
+### Changed 🔧
+* Change the default monospace font to [Hack](https://github.com/source-foundry/Hack).
+* Label text will now be centered, right-aligned and/or justified based on the layout of the `Ui` it is in.
+* `Hyperlink` will now word-wrap just like a `Label`.
+* All `Ui`s must now have a finite `max_rect`.
+  * Deprecated: `max_rect_finite`, `available_size_before_wrap_finite` and `available_rect_before_wrap_finite`.
+* `Painter`/`Fonts`: text layout now expect a color when creating a `Galley`. You may override that color with `Painter::galley_with_color`.
+* MSRV (Minimum Supported Rust Version) is now `1.54.0`.
+* By default, `DragValue`s no longer show a tooltip when hovered. Change with `Style::explanation_tooltips`.
+* Smaller and nicer color picker.
+* `ScrollArea` will auto-shrink to content size unless told otherwise using `ScrollArea::auto_shrink`.
+* By default, `Slider`'s `clamp_to_range` is set to true.
+* Renamed `TextEdit::enabled` to `TextEdit::interactive`.
+* `ui.label` (and friends) now take `impl ToString` as argument instead of `impl Into<Label>`.
+
+### Fixed 🐛
+* Fixed wrongly sized multiline `TextEdit` in justified layouts.
+* Fixed clip rectangle of windows that don't fit the central area.
+* Show tooltips above widgets on touch screens.
+* Fixed popups sometimes getting clipped by panels.
+
+### Removed 🔥
+* Replace `Button::enabled` with `ui.add_enabled`.
+
+### Contributors 🙏
+* [AlexApps99](https://github.com/AlexApps99)
+* [baysmith](https://github.com/baysmith)
+* [bpostlethwaite](https://github.com/bpostlethwaite)
+* [cwfitzgerald](https://github.com/cwfitzgerald)
+* [DrOptix](https://github.com/DrOptix)
+* [JerzySpendel](https://github.com/JerzySpendel)
+* [NiceneNerd](https://github.com/NiceneNerd)
+* [parasyte](https://github.com/parasyte)
+* [spersson](https://github.com/spersson)
+* [Stock84-dev](https://github.com/Stock84-dev)
+* [sumibi-yakitori](https://github.com/sumibi-yakitori)
+* [t18b219k](https://github.com/t18b219k)
+* [TobTobXX](https://github.com/TobTobXX)
+* [zu1k](https://github.com/zu1k)
+
+
+## 0.14.2 - 2021-08-28 - Window resize fix
+
+### Fixed 🐛
+* Fixed window resize bug introduced in `0.14.1`.
+
+
+## 0.14.1 - 2021-08-28 - Layout bug fixes
+
+### Added ⭐
+* Added `Ui::horizontal_top`.
+
+### Fixed 🐛
+* Fixed `set_width/set_min_width/set_height/set_min_height/expand_to_include_x/expand_to_include_y`.
+* Make minimum grid column width propagate properly.
+* Make sure `TextEdit` contents expand to fill width if applicable.
+* `ProgressBar`: add a minimum width and fix for having it in an infinite layout.
+* Fixed sometimes not being able to click inside a combo box or popup menu.
+
+
+## 0.14.0 - 2021-08-24 - Ui panels and bug fixes
+
+### Added ⭐
+* Panels can now be added to any `Ui`.
+* Plot:
+  * [Line styles](https://github.com/emilk/egui/pull/482).
+  * Added `show_background` and `show_axes` methods to `Plot`.
+* [Progress bar](https://github.com/emilk/egui/pull/519).
+* `Grid::num_columns`: allow the last column to take up the rest of the space of the parent `Ui`.
+* Added an API for dropping files into egui (see `RawInput`).
+* `CollapsingHeader` can now optionally be selectable.
+
+### Changed 🔧
+* A single-line `TextEdit` will now clip text that doesn't fit in it, and scroll.
+* Return closure return value from `Area::show`, `ComboBox::show_ui`, `ComboBox::combo_box_with_label`, `Window::show`, `popup::*`, `menu::menu`.
+* Only move/resize windows with primary mouse button.
+* Tooltips are now moved to not cover the widget they are attached to.
+
+### Fixed 🐛
+* Fixed custom font definitions getting replaced when `pixels_per_point` is changed.
+* Fixed `lost_focus` for `TextEdit`.
+* Clicking the edge of a menu button will now properly open the menu.
+* Fixed hover detection close to an `Area`.
+* Fixed case where `Plot`'s `min_auto_bounds` could be ignored after the first call to `Plot::ui`.
+* Fixed slow startup when using large font files.
+
+### Contributors 🙏
+* [barrowsys](https://github.com/barrowsys)
+* [EmbersArc](https://github.com/EmbersArc)
+* [gents83](https://github.com/gents83 )
+* [lucaspoffo](https://github.com/lucaspoffo)
+* [mankinskin](https://github.com/mankinskin)
+* [mental32](https://github.com/mental32)
+* [mitchmindtree](https://github.com/mitchmindtree)
+* [parasyte](https://github.com/parasyte)
+* [rekka](https://github.com/rekka)
+* [zu1k](https://github.com/zu1k)
+
+
+## 0.13.1 - 2021-06-28 - Plot fixes
+
+### Added ⭐
+* Plot: you can now set the stroke of a `HLine/VLine`.
+
+### Changed 🔧
+* `Plot::new` now takes an `id_source: impl Hash` instead of a `name: impl ToString`. Functionally it is the same.
+
+
+## 0.13.0 - 2021-06-24 - Better panels, plots and new visual style
+
+### Added ⭐
+* Plot:
+  * [More plot items: Arrows, Polygons, Text, Images](https://github.com/emilk/egui/pull/471).
+  * [Plot legend improvements](https://github.com/emilk/egui/pull/410).
+  * [Line markers for plots](https://github.com/emilk/egui/pull/363).
+* Panels:
+  * Added right and bottom panels (`SidePanel::right` and `Panel::bottom`).
+  * Panels can now be resized.
+  * Added an option to overwrite frame of a `Panel`.
+* [Improve accessibility / screen reader](https://github.com/emilk/egui/pull/412).
+* Added `ScrollArea::show_rows` for efficient scrolling of huge UI:s.
+* Added `ScrollArea::enable_scrolling` to allow freezing scrolling when editing TextEdit widgets within it
+* Added `Ui::set_visible` as a way to hide widgets.
+* Added `Style::override_text_style` to easily change the text style of everything in a `Ui` (or globally).
+* You can now change `TextStyle` on checkboxes, radio buttons and `SelectableLabel`.
+* Added support for [cint](https://crates.io/crates/cint) under `cint` feature.
+* Added features `extra_asserts` and `extra_debug_asserts` to enable additional checks.
+* `TextEdit` now supports edits on a generic buffer using `TextBuffer`.
+* Added `Context::set_debug_on_hover` and `egui::trace!(ui)`
+
+### Changed 🔧
+* Minimum Rust version is now 1.51 (used to be 1.52)
+* [Tweaked the default visuals style](https://github.com/emilk/egui/pull/450).
+* Plot: Renamed `Curve` to `Line`.
+* `TopPanel::top` is now `TopBottomPanel::top`.
+* `SidePanel::left` no longet takes the default width by argument, but by a builder call.
+* `SidePanel::left` is resizable by default.
+
+### Fixed 🐛
+* Fixed uneven lettering on non-integral device scales ("extortion lettering").
+* Fixed invisible scroll bar when native window is too narrow for egui.
+
+
+## 0.12.0 - 2021-05-10 - Multitouch, user memory, window pivots, and improved plots
+
+### Added ⭐
+* Added anchors to windows and areas so you can put a window in e.g. the top right corner.
+* Make labels interactive with `Label::sense(Sense::click())`.
+* Added `Response::request_focus` and `Response::surrender_focus`.
+* Added `TextEdit::code_editor` (VERY basic).
+* [Pan and zoom plots](https://github.com/emilk/egui/pull/317).
+* [Add plot legends](https://github.com/emilk/egui/pull/349).
+* [Users can now store custom state in `egui::Memory`](https://github.com/emilk/egui/pull/257).
+* Added `Response::on_disabled_hover_text` to show tooltip for disabled widgets.
+* Zoom input: ctrl-scroll and (on `eframe` web) trackpad-pinch gesture.
+* Support for raw [multi touch](https://github.com/emilk/egui/pull/306) events,
+  enabling zoom, rotate, and more. Works with `eframe` web on mobile devices,
+  and should work with `egui_glium` for certain touch devices/screens.
+* Added (optional) compatibility with [mint](https://docs.rs/mint).
+
+### Changed 🔧
+* Make `Memory::has_focus` public (again).
+* `Plot` must now be given a name that is unique within its scope.
+* Tab only selects labels if the `screen_reader` option is turned on.
+* Renamed `ui.wrap` to `ui.scope`.
+
+### Fixed 🐛
+* Fixed [defocus-bug on touch screens](https://github.com/emilk/egui/issues/288).
+* Fixed bug with the layout of wide `DragValue`s.
+
+### Removed 🔥
+* Moved experimental markup language to `egui_demo_lib`
+
+
+## 0.11.0 - 2021-04-05 - Optimization, screen reader & new layout logic
+
+### Added ⭐
+* You can now give focus to any clickable widget with tab/shift-tab.
+  * Use space or enter to click the selected widget.
+  * Use arrow keys to adjust sliders and `DragValue`s.
+* egui will now output events when widgets gain keyboard focus.
+  * This can be hooked up to a screen reader to aid the visually impaired
+* Added the option to restrict the dragging bounds of `Window` and `Area` to a specified area using `drag_bounds(rect)`.
+* Added support for small and raised text.
+* Added `ui.set_row_height`.
+* Added `DebugOptions::show_widgets` to debug layouting by hovering widgets.
+* Added `ComboBox` to more easily customize combo boxes.
+* Added `Slider::new` and `DragValue::new` to replace old type-specific constructors.
+* Added `TextEdit::password` to hide input characters.
+
+### Changed 🔧
+* `ui.advance_cursor` is now called `ui.add_space`.
+* `kb_focus` is now just called `focus`.
+
+### Fixed 🐛
+* Fixed some bugs related to centered layouts.
+* Fixed secondary-click to open a menu.
+* [Fix panic for zero-range sliders and zero-speed drag values](https://github.com/emilk/egui/pull/216).
+* Fixed false id clash error for wrapping text.
+* Fixed bug that would close a popup (e.g. the color picker) when clicking inside of it.
+
+### Deprecated ☢️
+* Deprecated `combo_box_with_label` in favor of new `ComboBox`.
+* Deprecated type-specific constructors for `Slider` and `DragValue` (`Slider::f32`, `DragValue::usize` etc).
+
+
+## 0.10.0 - 2021-02-28 - Plot and polish
+
+<img src="media/egui-0.10-plot.gif" width="50%">
+
+### Added ⭐
+* Added `egui::plot::Plot` to plot some 2D data.
+* Added `Ui::hyperlink_to(label, url)`.
+* Sliders can now have a value prefix and suffix (e.g. the suffix `"°"` works like a unit).
+* `Context::set_pixels_per_point` to control the scale of the UI.
+* Added `Response::changed()` to query if e.g. a slider was dragged, text was entered or a checkbox was clicked.
+* Added support for all integers in `DragValue` and `Slider` (except 128-bit).
+
+### Changed 🔧
+* Improve the positioning of tooltips.
+* Only show tooltips if mouse is still.
+* `Slider` will now show the value display by default, unless turned off with `.show_value(false)`.
+* The `Slider` value is now a `DragValue` which when dragged can pick values outside of the slider range (unless `clamp_to_range` is set).
+
+
+## 0.9.0 - 2021-02-07 - Light Mode and much more
+
+<img src="media/0.9.0-disabled.gif" width="50%">
+
+### Added ⭐
+* Added support for secondary and middle mouse buttons.
+* Added `Label` methods for code, strong, strikethrough, underline and italics.
+* Added `ui.group(|ui| { … })` to visually group some widgets within a frame.
+* Added `Ui` helpers for doing manual layout (`ui.put`, `ui.allocate_ui_at_rect` and more).
+* Added `ui.set_enabled(false)` to disable all widgets in a `Ui` (grayed out and non-interactive).
+* Added `TextEdit::hint_text` for showing a weak hint text when empty.
+* `egui::popup::popup_below_widget`: show a popup area below another widget.
+* Added `Slider::clamp_to_range(bool)`: if set, clamp the incoming and outgoing values to the slider range.
+* Add: `ui.spacing()`, `ui.spacing_mut()`, `ui.visuals()`, `ui.visuals_mut()`.
+* Add: `ctx.set_visuals()`.
+* You can now control text wrapping with `Style::wrap`.
+* Added `Grid::max_col_width`.
+
+### Changed 🔧
+* Text will now wrap at newlines, spaces, dashes, punctuation or in the middle of a words if necessary, in that order of priority.
+* Widgets will now always line break at `\n` characters.
+* Widgets will now more intelligently choose whether or not to wrap text.
+* `mouse` has been renamed `pointer` everywhere (to make it clear it includes touches too).
+* Most parts of `Response` are now methods, so `if ui.button("…").clicked {` is now `if ui.button("…").clicked() {`.
+* `Response::active` is now gone. You can use `response.dragged()` or `response.clicked()` instead.
+* Backend: pointer (mouse/touch) position and buttons are now passed to egui in the event stream.
+* `DragValue::range` is now called `clamp_range` and also clamps incoming values.
+* Renamed `Triangles` to `Mesh`.
+* The tessellator now wraps the clip rectangle and mesh in `struct ClippedMesh(Rect, Mesh)`.
+* `Mesh::split_to_u16` now returns a 16-bit indexed `Mesh16`.
+
+### Fixed 🐛
+* It is now possible to click widgets even when FPS is very low.
+* Tessellator: handle sharp path corners better (switch to bevel instead of miter joints for > 90°).
+
+
+## 0.8.0 - 2021-01-17 - Grid layout & new visual style
+
+<img src="media/widget_gallery_0.8.0.gif" width="50%">
+
+### Added ⭐
+* Added a simple grid layout (`Grid`).
+* Added `ui.allocate_at_least` and `ui.allocate_exact_size`.
+* Added function `InputState::key_down`.
+* Added `Window::current_pos` to position a window.
+
+### Changed 🔧
+* New simpler and sleeker look!
+* Renamed `PaintCmd` to `Shape`.
+* Replace tuple `(Rect, Shape)` with tuple-struct `ClippedShape`.
+* Renamed feature `"serde"` to `"persistence"`.
+* Break out the modules `math` and `paint` into separate crates `emath` and `epaint`.
+
+### Fixed 🐛
+* Fixed a bug that would sometimes trigger a "Mismatching panels" panic in debug builds.
+* `Image` and `ImageButton` will no longer stretch to fill a justified layout.
+
+
+## 0.7.0 - 2021-01-04
+
+### Added ⭐
+* Added `ui.scroll_to_cursor` and `response.scroll_to_me` ([#81](https://github.com/emilk/egui/pull/81) by [lucaspoffo](https://github.com/lucaspoffo)).
+* Added `window.id(…)` and `area.id(…)` for overriding the default `Id`.
+
+### Changed 🔧
+* Renamed `Srgba` to `Color32`.
+* All color constructors now starts with `from_`, e.g. `Color32::from_rgb`.
+* Renamed `FontFamily::VariableWidth` to `FontFamily::Proportional`.
+* Removed `pixels_per_point` from `FontDefinitions`.
+
+### Fixed 🐛
+* `RepaintSignal` now implements `Sync` so it can be sent to a background thread.
+* `TextEdit` widgets are now slightly larger to accommodate their frames.
+
+### Deprecated ☢️
+* Deprecated `color::srgba`.
+
+
+## 0.6.0 - 2020-12-26
+
+### Added ⭐
+* Turn off `Window` title bars with `window.title_bar(false)`.
+* `ImageButton` - `ui.add(ImageButton::new(…))`.
+* `ui.vertical_centered` and `ui.vertical_centered_justified`.
+* `ui.allocate_painter` helper.
+* Mouse-over explanation to duplicate ID warning.
+* You can now easily constrain egui to a portion of the screen using `RawInput::screen_rect`.
+* You can now control the minimum and maixumum number of decimals to show in a `Slider` or `DragValue`.
+* Added `egui::math::Rot2`: rotation helper.
+* `Response` now contains the `Id` of the widget it pertains to.
+* `ui.allocate_response` that allocates space and checks for interactions.
+* Added `response.interact(sense)`, e.g. to check for clicks on labels.
+
+### Changed 🔧
+* `ui.allocate_space` now returns an `(Id, Rect)` tuple.
+* `Arc<Context>` has been replaced with `CtxRef` everywhere.
+* Slight tweak of the default `Style` and font sizes.
+* `SidePanel::left` and `TopPanel::top` now takes `impl Hash` as first argument.
+* A `Window` may now cover an existing `CentralPanel`.
+* `ui.image` now takes `impl Into<Vec2>` as a `size` argument.
+* Made some more fields of `RawInput` optional.
+* `Slider` and `DragValue` uses fewer decimals by default. See the full precision by hovering over the value.
+* `egui::App`: added `fn name(&self)` and `fn clear_color(&self)`.
+* Combo boxes has scroll bars when needed.
+* Expand `Window` + `Resize` containers to be large enough for last frames content
+* `ui.columns`: Columns now defaults to justified top-to-down layouts.
+* Renamed `Sense::nothing()` to  `Sense::hover()`.
+* Replaced `parking_lot` dependency with `atomic_refcell` by default.
+
+### Fixed 🐛
+* The background for `CentralPanel` will now cover unused space too.
+* `ui.columns`: Improve allocated size estimation.
+
+### Deprecated ☢️
+* `RawInput::screen_size` - use `RawInput::screen_rect` instead.
+* left/centered/right column functions on `Ui`.
+* `ui.interact_hover` and `ui.hovered`.
+
+
+## 0.5.0 - 2020-12-13
+
+### Added ⭐
+* Emoji support: 1216 different emojis that work in any text.
+  * The Demo app comes with a Font Book to explore the available glyphs.
+* `ui.horizontal_wrapped(|ui| …)`: Add widgets on a row but wrap at `max_size`.
+* `ui.horizontal_wrapped_for_text`: Like `ui.horizontal_wrapped`, but with spacing made for embedding text.
+* `ui.horizontal_for_text`: Like `ui.horizontal`, but with spacing made for embedding text.
+* `egui::Layout` now supports justified layouts where contents is _also_ centered, right-aligned, etc.
+* `ui.allocate_ui(size, |ui| …)`: Easily create a child-`Ui` of a given size.
+* `SelectableLabel` (`ui.selectable_label` and `ui.selectable_value`): A text-button that can be selected.
+* `ui.small_button`: A smaller button that looks good embedded in text.
+* `ui.drag_angle_tau`: For those who want to specify angles as fractions of τ (a full turn).
+* Added `Resize::id_source` and `ScrollArea::id_source` to let the user avoid Id clashes.
+
+### Changed 🔧
+* New default font: [Ubuntu-Light](https://fonts.google.com/specimen/Ubuntu).
+* Make it simpler to override fonts in `FontDefinitions`.
+* Remove minimum button width.
+* Refactor `egui::Layout` substantially, changing its interface.
+* Calling `on_hover_text`/`on_hover_ui` multiple times will stack tooltips underneath the previous ones.
+* Text wrapping on labels, buttons, checkboxes and radio buttons is now based on the layout.
+
+### Removed 🔥
+
+* Removed the `label!` macro.
+
+
+## 0.4.0 - 2020-11-28
+
+### Added ⭐
+* `TextEdit` improvements:
+  * Much improved text editing, with better navigation and selection.
+  * Move focus between `TextEdit` widgets with tab and shift-tab.
+  * Undo edtis in a `TextEdit`.
+  * You can now check if a `TextEdit` lost keyboard focus with `response.lost_focus`.
+  * Added `ui.text_edit_singleline` and `ui.text_edit_multiline`.
+* You can now debug why your `Ui` is unexpectedly wide with `ui.style_mut().debug.show_expand_width = true;`
+
+### Changed 🔧
+* Pressing enter in a single-line `TextEdit` will now surrender keyboard focus for it.
+* You must now be explicit when creating a `TextEdit` if you want it to be singeline or multiline.
+* Improved automatic `Id` generation, making `Id` clashes less likely.
+* egui now requires modifier key state from the integration
+* Added, renamed and removed some keys in the `Key` enum.
+* Fixed incorrect text wrapping width on radio buttons
+
+### Fixed 🐛
+* Fixed bug where a lost widget could still retain keyboard focus.
+
+
+## 0.3.0 - 2020-11-07
+
+### Added ⭐
+* Panels: you can now create panels using `SidePanel`, `TopPanel` and `CentralPanel`.
+* You can now override the default egui fonts.
+* Added ability to override text color with `visuals.override_text_color`.
+* The demo now includes a simple drag-and-drop example.
+* The demo app now has a slider to scale all of egui.
+
+### Changed 🔧
+* `ui.horizontal(…)` etc returns `Response`.
+* Refactored the interface for `egui::app::App`.
+* Windows are now constrained to the screen.
+* `Context::begin_frame()` no longer returns a `Ui`. Instead put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
+* `Context::end_frame()` now returns shapes that need to be converted to triangles with `Context::tessellate()`.
+* Anti-aliasing is now off by default in debug builds.
+
+### Removed 🔥
+
+* You can no longer throw windows.
+
+### Fixed 🐛
+* Fixed a bug where some regions would slowly grow for non-integral scales (`pixels_per_point`).
+
+
+## 0.2.0 - 2020-10-10
+
+* Color picker
+* Unicode characters in labels (limited by [what the default font supports](https://fonts.google.com/specimen/Comfortaa#glyphs))
+* Simple drop-down combo box menu
+* Logarithmic sliders
+* Optimization: coarse culling in the tessellator
+* CHANGED: switch argument order of `ui.checkbox` and `ui.radio`
+
+
+## 0.1.4 - 2020-09-08
+
+This is when I started the CHANGELOG.md, after almost two years of development. Better late than never.
+
+* Widgets: label, text button, hyperlink, checkbox, radio button, slider, draggable value, text editing
+* Layouts: horizontal, vertical, columns
+* Text input: very basic, multiline, copy/paste
+* Windows: move, resize, name, minimize and close. Automatically sized and positioned.
+* Regions: resizing, vertical scrolling, collapsing headers (sections)
+* Rendering: Anti-aliased rendering of lines, circles, text and convex polygons.
+* Tooltips on hover
+
+
+## Earlier:
+
+* 2020-08-10: renamed the project to "egui"
+* 2020-05-30: first release on crates.io (0.1.0)
+* 2020-04-01: serious work starts (pandemic project)
+* 2019-03-12: gave a talk about what would later become egui: https://www.youtube.com/watch?v=-pmwLHw5Gbs
+* 2018-12-23: [initial commit](https://github.com/emilk/egui/commit/856bbf4dae4a69693a0324da34e8b0dd3754dfdf)
+* 2018-11-04: started tinkering on a train
diff --git a/egui/CODE_OF_CONDUCT.md b/egui/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..5640e4f
--- /dev/null
+++ b/egui/CODE_OF_CONDUCT.md
@@ -0,0 +1,133 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[the egui discord](https://discord.gg/JFcEma9bJq).
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
+
diff --git a/egui/CONTRIBUTING.md b/egui/CONTRIBUTING.md
new file mode 100644
index 0000000..ff84e3a
--- /dev/null
+++ b/egui/CONTRIBUTING.md
@@ -0,0 +1,102 @@
+# Contributing guidelines
+
+## Introduction
+
+`egui` has been an on-and-off weekend project of mine since late 2018. I am grateful to any help I can get, but bare in mind that sometimes I can be slow to respond because I am busy with other things!
+
+/ Emil
+
+
+## Discussion
+
+You can ask questions, share screenshots and more at [GitHub Discussions](https://github.com/emilk/egui/discussions).
+
+There is an `egui` discord at <https://discord.gg/vbuv9Xan65>.
+
+
+## Filing an issue
+
+[Issues](https://github.com/emilk/egui/issues) are for bug reports and feature requests. Issues are not for asking questions (use [Discussions](https://github.com/emilk/egui/discussions) or [Discord](https://discord.gg/vbuv9Xan65) for that).
+
+Always make sure there is not already a similar issue to the one you are creating.
+
+If you are filing a bug, please provide a way to reproduce it.
+
+
+## Making a PR
+
+First file an issue (or find an existing one) and announce that you plan to work on something. That way we will avoid having several people doing double work. Please ask for feedback before you start working on something non-trivial!
+
+Browse through [`ARCHITECTURE.md`](https://github.com/emilk/egui/blob/master/ARCHITECTURE.md) to get a sense of how all pieces connects.
+
+You can test your code locally by running `./scripts/check.sh`.
+
+When you have something that works, open a draft PR. You may get some helpful feedback early!
+When you feel the PR is ready to go, do a self-review of the code, and then open it for review.
+
+Please keep pull requests small and focused.
+
+Don't worry about having many small commits in the PR - they will be squashed to one commit once merged.
+
+Do not include the `.js` and `.wasm` build artifacts generated for building for web.
+`git` is not great at storing large files like these, so we only commit a new web demo after a new egui release.
+
+
+## Creating an integration for egui
+
+If you make an integration for `egui` for some engine or renderer, please share it with the world!
+I will add a link to it from the `egui` README.md so others can easily find it.
+
+Read the section on integrations at <https://github.com/emilk/egui#integrations>.
+
+
+## Code Conventions
+Conventions unless otherwise specified:
+
+* angles are in radians
+* `Vec2::X` is right and `Vec2::Y` is down.
+* `Pos2::ZERO` is left top.
+
+While using an immediate mode gui is simple, implementing one is a lot more tricky. There are many subtle corner-case you need to think through. The `egui` source code is a bit messy, partially because it is still evolving.
+
+* Read some code before writing your own.
+* Follow the `egui` code style.
+* Add blank lines around all `fn`, `struct`, `enum`, etc.
+* `// Comment like this.` and not `//like this`.
+* Use `TODO` instead of `FIXME`.
+* Add your github handle to the `TODO`:s you write, e.g: `TODO(emilk): clean this up`.
+* Write idiomatic rust.
+* Avoid `unsafe`.
+* Avoid code that can cause panics.
+* Use good names for everything.
+* Add docstrings to types, `struct` fields and all `pub fn`.
+* Add some example code (doc-tests).
+* Before making a function longer, consider adding a helper function.
+* If you are only using it in one function, put the `use` statement in that function. This improves locality, making it easier to read and move the code.
+* When importing a `trait` to use it's trait methods, do this: `use Trait as _;`. That lets the reader know why you imported it, even though it seems unused.
+* Follow the [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/).
+* Break the above rules when it makes sense.
+
+
+### Good:
+``` rust
+/// The name of the thing.
+fn name(&self) -> &str {
+    &self.name
+}
+
+fn foo(&self) {
+    // TODO(emilk): implement
+}
+```
+
+### Bad:
+``` rust
+//some function
+fn get_name(&self) -> &str {
+    &self.name
+}
+fn foo(&self) {
+    //FIXME: implement
+}
+```
diff --git a/egui/Cargo.lock b/egui/Cargo.lock
new file mode 100644
index 0000000..1af8f61
--- /dev/null
+++ b/egui/Cargo.lock
@@ -0,0 +1,4662 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ab_glyph"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe21446ad43aa56417a767f3e2f3d7c4ca522904de1dd640529a76e9c5c3b33c"
+dependencies = [
+ "ab_glyph_rasterizer",
+ "owned_ttf_parser",
+]
+
+[[package]]
+name = "ab_glyph_rasterizer"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c71b1793ee61086797f5c80b6efa2b8ffa6d5dd703f118545808a7f2e27f7046"
+
+[[package]]
+name = "accesskit"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704d532b1cd3d912bb37499c55a81ac748cc1afa737eedd100ba441acdd47d38"
+dependencies = [
+ "enumn",
+ "serde",
+]
+
+[[package]]
+name = "accesskit_consumer"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48ba8b23cfca3944012ee2e5c71c02077a400e034c720eed6bd927cb6b4d1fd9"
+dependencies = [
+ "accesskit",
+]
+
+[[package]]
+name = "accesskit_macos"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58d062544d6cc36f4213323b7cb3a0d74ddff4b0d2311ab5e7596f4278bb2cc9"
+dependencies = [
+ "accesskit",
+ "accesskit_consumer",
+ "objc2",
+ "once_cell",
+]
+
+[[package]]
+name = "accesskit_unix"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f8df4021f31969877b295fa80c4b07fcc7eb83f1985b0d3aa4f889c3427c3d5"
+dependencies = [
+ "accesskit",
+ "accesskit_consumer",
+ "async-channel",
+ "atspi",
+ "futures-lite",
+ "serde",
+ "zbus",
+]
+
+[[package]]
+name = "accesskit_windows"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aaf5b3c3828397ee832ba4a72fb1a4ace10f781e31885f774cbd531014059115"
+dependencies = [
+ "accesskit",
+ "accesskit_consumer",
+ "arrayvec",
+ "once_cell",
+ "paste",
+ "windows 0.44.0",
+]
+
+[[package]]
+name = "accesskit_winit"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbcb615217efc79c4bed3094c4ca76c4bc554751d1da16f3ed4ba0459b1e8f31"
+dependencies = [
+ "accesskit",
+ "accesskit_macos",
+ "accesskit_unix",
+ "accesskit_windows",
+ "winit",
+]
+
+[[package]]
+name = "addr2line"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a76fd60b23679b7d19bd066031410fb7e458ccc5e958eb5c325888ce4baedc97"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "ahash"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "serde",
+ "version_check",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android-activity"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4165a1aef703232031b40a6e8908c2f9e314d495f11aa7f98db75d39a497cc6a"
+dependencies = [
+ "android-properties",
+ "bitflags",
+ "cc",
+ "jni-sys",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-context",
+ "ndk-sys",
+ "num_enum",
+]
+
+[[package]]
+name = "android-properties"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anyhow"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800"
+
+[[package]]
+name = "arboard"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6041616acea41d67c4a984709ddab1587fd0b10efe5cc563fee954d2f011854"
+dependencies = [
+ "clipboard-win",
+ "log",
+ "objc",
+ "objc-foundation",
+ "objc_id",
+ "once_cell",
+ "parking_lot",
+ "thiserror",
+ "winapi",
+ "x11rb",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+
+[[package]]
+name = "ash"
+version = "0.37.2+1.3.238"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28bf19c1f0a470be5fbf7522a308a05df06610252c5bcf5143e1b23f629a9a03"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "async-broadcast"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b19760fa2b7301cf235360ffd6d3558b1ed4249edd16d6cca8d690cee265b95"
+dependencies = [
+ "event-listener",
+ "futures-core",
+ "parking_lot",
+]
+
+[[package]]
+name = "async-channel"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf46fee83e5ccffc220104713af3292ff9bc7c64c7de289f66dae8e38d826833"
+dependencies = [
+ "concurrent-queue",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17adb73da160dfb475c183343c8cccd80721ea5a605d3eb57125f0a7b7a92d0b"
+dependencies = [
+ "async-lock",
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-io"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c374dda1ed3e7d8f0d9ba58715f924862c63eae6849c92d3a18e7fbde9e2794"
+dependencies = [
+ "async-lock",
+ "autocfg",
+ "concurrent-queue",
+ "futures-lite",
+ "libc",
+ "log",
+ "parking",
+ "polling",
+ "slab",
+ "socket2",
+ "waker-fn",
+ "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "async-lock"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8101efe8695a6c17e02911402145357e718ac92d3ff88ae8419e84b1707b685"
+dependencies = [
+ "event-listener",
+ "futures-lite",
+]
+
+[[package]]
+name = "async-recursion"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b015a331cc64ebd1774ba119538573603427eaace0a1950c423ab971f903796"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "async-task"
+version = "4.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a40729d2133846d9ed0ea60a8b9541bccddab49cd30f0715a1da672fe9a2524"
+
+[[package]]
+name = "async-trait"
+version = "0.1.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cd7fce9ba8c3c042128ce72d8b2ddbf3a05747efb67ea0313c635e10bda47a2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "atk-sys"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ad703eb64dc058024f0e57ccfa069e15a413b98dbd50a1a950e743b7f11148"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "atomic_refcell"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "857253367827bd9d0fd973f0ef15506a96e79e41b0ad7aa691203a4e3214f6c8"
+
+[[package]]
+name = "atspi"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "674e7a3376837b2e7d12d34d58ac47073c491dc3bf6f71a7adaf687d4d817faa"
+dependencies = [
+ "async-recursion",
+ "async-trait",
+ "atspi-macros",
+ "enumflags2",
+ "futures-lite",
+ "serde",
+ "tracing",
+ "zbus",
+ "zbus_names",
+]
+
+[[package]]
+name = "atspi-macros"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb4870a32c0eaa17e35bca0e6b16020635157121fb7d45593d242c295bc768"
+dependencies = [
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "backtrace"
+version = "0.3.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233d376d6d185f2a3093e58f283f60f880315b6c60075b01f36b3b85154564ca"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.64.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4243e6031260db77ede97ad86c27e501d646a27ab57b59a574f725d98ab1fb4"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "lazy_static",
+ "lazycell",
+ "log",
+ "peeking_take_while",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 1.0.107",
+ "which",
+]
+
+[[package]]
+name = "bit-set"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "block"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-sys"
+version = "0.1.0-beta.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa55741ee90902547802152aaf3f8e5248aab7e21468089560d4c8840561146"
+dependencies = [
+ "objc-sys",
+]
+
+[[package]]
+name = "block2"
+version = "0.2.0-alpha.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8dd9e63c1744f755c2f60332b88de39d341e5e86239014ad839bd71c106dec42"
+dependencies = [
+ "block-sys",
+ "objc2-encode",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+
+[[package]]
+name = "bytemuck"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c041d3eab048880cb0b86b256447da3f18859a163c3b8d8893f4e6368abe6393"
+dependencies = [
+ "bytemuck_derive",
+]
+
+[[package]]
+name = "bytemuck_derive"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aca418a974d83d40a0c1f0c5cba6ff4bc28d8df099109ca459a2118d40b6322"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "bytes"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c48f4af05fabdcfa9658178e1326efa061853f040ce7d72e33af6885196f421"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "calloop"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a59225be45a478d772ce015d9743e49e92798ece9e34eda9a6aa2a6a7f40192"
+dependencies = [
+ "log",
+ "nix 0.25.1",
+ "slotmap",
+ "thiserror",
+ "vec_map",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+dependencies = [
+ "jobserver",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0357a6402b295ca3a86bc148e84df46c02e41f41fef186bda662557ef6328aa"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
+name = "cgl"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ced0551234e87afee12411d535648dd89d2e7f34c78b753395567aff3d447ff"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-integer",
+ "num-traits",
+ "time 0.1.45",
+ "wasm-bindgen",
+ "winapi",
+]
+
+[[package]]
+name = "ciborium"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c137568cc60b904a7724001b35ce2630fd00d5d84805fbb608ab89509d788f"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346de753af073cc87b52b2083a506b38ac176a44cfb05497b622e27be899b369"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213030a2b5a4e0c0892b6652260cf6ccac84827b83a85a534e178e3906c4cf1b"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "cint"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0e87cdf78571d9fbeff16861c37a006cd718d2433dc6d5b80beaae367d899a"
+
+[[package]]
+name = "clang-sys"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa2e27ae6ab525c3d369ded447057bca5438d86dc3a68f6faafb8269ba82ebf3"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "clap"
+version = "3.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71655c45cb9845d3270c9d6df84ebe72b4dad3c2ba3f7023ad47c144e4e473a5"
+dependencies = [
+ "bitflags",
+ "clap_lex",
+ "indexmap",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]
+
+[[package]]
+name = "clipboard-win"
+version = "4.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362"
+dependencies = [
+ "error-code",
+ "str-buf",
+ "winapi",
+]
+
+[[package]]
+name = "cocoa-foundation"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ade49b65d560ca58c403a479bb396592b155c0185eada742ee323d1d68d6318"
+dependencies = [
+ "bitflags",
+ "block",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types",
+ "libc",
+ "objc",
+]
+
+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
+[[package]]
+name = "color-hex"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecdffb913a326b6c642290a0d0ec8e8d6597291acdc07cc4c9cb4b3635d44cf9"
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "com-rs"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf43edc576402991846b093a7ca18a3477e0ef9c588cde84964b5d3e43016642"
+
+[[package]]
+name = "combine"
+version = "4.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c278839b831783b70278b14df4d45e1beb1aad306c07bb796637de9a0e323e8e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "confirm_exit"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+
+[[package]]
+name = "core-graphics"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a68b68b3446082644c91ac778bf50cd4104bfb002b5a6a7c44cca5a2c70788b"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "criterion"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c76e09c1aae2bc52b3d2f29e13c6572553b30c4aa1b8a49fd70de6412654cb"
+dependencies = [
+ "anes",
+ "atty",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "itertools",
+ "lazy_static",
+ "num-traits",
+ "oorandom",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cty"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35"
+
+[[package]]
+name = "custom_3d_glow"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "egui_glow",
+ "glow",
+]
+
+[[package]]
+name = "custom_font"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+]
+
+[[package]]
+name = "custom_font_style"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+]
+
+[[package]]
+name = "custom_window_frame"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+]
+
+[[package]]
+name = "cxx"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc831ee6a32dd495436e317595e639a587aa9907bef96fe6e6abc290ab6204e9"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94331d54f1b1a8895cd81049f7eaaaef9d05a7dcb4d1fd08bf3ff0806246789d"
+dependencies = [
+ "cc",
+ "codespan-reporting",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "cxxbridge-flags"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48dcd35ba14ca9b40d6e4b4b39961f23d835dbb8eed74565ded361d93e1feb8a"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81bbeb29798b407ccd82a3324ade1a7286e0d29851475990b612670f6f5124d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "d3d12"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8f0de2f5a8e7bd4a9eec0e3c781992a4ce1724f68aec7d7a3715344de8b39da"
+dependencies = [
+ "bitflags",
+ "libloading",
+ "winapi",
+]
+
+[[package]]
+name = "dark-light"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a62007a65515b3cd88c733dd3464431f05d2ad066999a824259d8edc3cf6f645"
+dependencies = [
+ "dconf_rs",
+ "detect-desktop-environment",
+ "dirs",
+ "objc",
+ "rust-ini",
+ "web-sys",
+ "winreg",
+ "zbus",
+ "zvariant",
+]
+
+[[package]]
+name = "darling"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "data-url"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d7439c3735f405729d52c3fbbe4de140eaf938a1fe47d227c27f8254d4302a5"
+
+[[package]]
+name = "dconf_rs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7046468a81e6a002061c01e6a7c83139daf91b11c30e66795b13217c2d885c8b"
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "detect-desktop-environment"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21d8ad60dd5b13a4ee6bd8fa2d5d88965c597c67bce32b5fc49c94f55cb50810"
+
+[[package]]
+name = "digest"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "directories-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "dispatch"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
+
+[[package]]
+name = "dlib"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac1b7517328c04c2aa68422fc60a41b92208182142ed04a25879c26c8f878794"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "dlv-list"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
+
+[[package]]
+name = "document-features"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e493c573fce17f00dcab13b6ac057994f3ce17d1af4dc39bfd482b83c6eb6157"
+dependencies = [
+ "litrs",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
+
+[[package]]
+name = "download_image"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "egui_extras",
+ "ehttp",
+ "image",
+ "poll-promise",
+]
+
+[[package]]
+name = "dyn-clonable"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e9232f0e607a262ceb9bd5141a3dfb3e4db6994b31989bbfd845878cba59fd4"
+dependencies = [
+ "dyn-clonable-impl",
+ "dyn-clone",
+]
+
+[[package]]
+name = "dyn-clonable-impl"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9b0705efd4599c15a38151f4721f7bc388306f61084d3bfd50bd07fbca5cb60"
+
+[[package]]
+name = "ecolor"
+version = "0.21.0"
+dependencies = [
+ "bytemuck",
+ "cint",
+ "color-hex",
+ "document-features",
+ "serde",
+]
+
+[[package]]
+name = "eframe"
+version = "0.21.3"
+dependencies = [
+ "bytemuck",
+ "dark-light",
+ "directories-next",
+ "document-features",
+ "egui",
+ "egui-wgpu",
+ "egui-winit",
+ "egui_glow",
+ "glow",
+ "glutin",
+ "glutin-winit",
+ "image",
+ "js-sys",
+ "percent-encoding",
+ "pollster",
+ "puffin",
+ "raw-window-handle",
+ "ron",
+ "serde",
+ "thiserror",
+ "tracing",
+ "tts",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "wgpu",
+ "winit",
+]
+
+[[package]]
+name = "egui"
+version = "0.21.0"
+dependencies = [
+ "accesskit",
+ "ahash 0.8.3",
+ "document-features",
+ "epaint",
+ "nohash-hasher",
+ "ron",
+ "serde",
+ "tracing",
+]
+
+[[package]]
+name = "egui-wgpu"
+version = "0.21.0"
+dependencies = [
+ "bytemuck",
+ "document-features",
+ "epaint",
+ "puffin",
+ "tracing",
+ "type-map",
+ "wgpu",
+ "winit",
+]
+
+[[package]]
+name = "egui-winit"
+version = "0.21.1"
+dependencies = [
+ "accesskit_winit",
+ "arboard",
+ "document-features",
+ "egui",
+ "instant",
+ "puffin",
+ "serde",
+ "smithay-clipboard",
+ "tracing",
+ "webbrowser",
+ "winit",
+]
+
+[[package]]
+name = "egui_demo_app"
+version = "0.21.0"
+dependencies = [
+ "bytemuck",
+ "chrono",
+ "console_error_panic_hook",
+ "eframe",
+ "egui",
+ "egui_demo_lib",
+ "egui_extras",
+ "ehttp",
+ "image",
+ "poll-promise",
+ "serde",
+ "tracing",
+ "tracing-subscriber",
+ "tracing-wasm",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "egui_demo_lib"
+version = "0.21.0"
+dependencies = [
+ "chrono",
+ "criterion",
+ "document-features",
+ "egui",
+ "egui_extras",
+ "enum-map",
+ "serde",
+ "syntect",
+ "tracing",
+ "unicode_names2",
+]
+
+[[package]]
+name = "egui_extras"
+version = "0.21.0"
+dependencies = [
+ "chrono",
+ "document-features",
+ "egui",
+ "image",
+ "resvg",
+ "serde",
+ "tiny-skia",
+ "tracing",
+ "usvg",
+]
+
+[[package]]
+name = "egui_glow"
+version = "0.21.0"
+dependencies = [
+ "bytemuck",
+ "document-features",
+ "egui",
+ "egui-winit",
+ "glow",
+ "glutin",
+ "glutin-winit",
+ "memoffset",
+ "puffin",
+ "raw-window-handle",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "ehttp"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80b69a6f9168b96c0ae04763bec27a8b06b34343c334dd2703a4ec21f0f5e110"
+dependencies = [
+ "js-sys",
+ "ureq",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "either"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+
+[[package]]
+name = "emath"
+version = "0.21.0"
+dependencies = [
+ "bytemuck",
+ "document-features",
+ "mint",
+ "serde",
+]
+
+[[package]]
+name = "enum-map"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c25992259941eb7e57b936157961b217a4fc8597829ddef0596d6c3cd86e1a"
+dependencies = [
+ "enum-map-derive",
+ "serde",
+]
+
+[[package]]
+name = "enum-map-derive"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a4da76b3b6116d758c7ba93f7ec6a35d2e2cf24feda76c6e38a375f4d5c59f2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "enumflags2"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c041f5090df68b32bcd905365fd51769c8b9d553fe87fde0b683534f10c01bd2"
+dependencies = [
+ "enumflags2_derive",
+ "serde",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e9a1f9f7d83e59740248a6e14ecf93929ade55027844dfcea78beafccc15745"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.15",
+]
+
+[[package]]
+name = "enumn"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88bcb3a067a6555d577aba299e75eff9942da276e6506fc6274327daa026132"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "epaint"
+version = "0.21.0"
+dependencies = [
+ "ab_glyph",
+ "ahash 0.8.3",
+ "atomic_refcell",
+ "backtrace",
+ "bytemuck",
+ "criterion",
+ "document-features",
+ "ecolor",
+ "emath",
+ "nohash-hasher",
+ "parking_lot",
+ "serde",
+]
+
+[[package]]
+name = "errno"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "error-code"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21"
+dependencies = [
+ "libc",
+ "str-buf",
+]
+
+[[package]]
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
+[[package]]
+name = "fancy-regex"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d6b8560a05112eb52f04b00e5d3790c0dd75d9d980eb8a122fb23b92a623ccf"
+dependencies = [
+ "bit-set",
+ "regex",
+]
+
+[[package]]
+name = "fastrand"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "file_dialog"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "rfd",
+]
+
+[[package]]
+name = "flate2"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec90ff4d0fe1f57d600049061dc6bb68ed03c7d2fbd697274c41805dcb3f8608"
+
+[[package]]
+name = "futures-io"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfb8371b6fb2aeb2d280374607aeabfc99d95c72edfe51692e42d3d7f0d08531"
+
+[[package]]
+name = "futures-lite"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "parking",
+ "pin-project-lite",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f310820bb3e8cfd46c80db4d7fb8353e15dfff853a127158425f31e0be6c8364"
+
+[[package]]
+name = "futures-task"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf79a1bf610b10f42aea489289c5a2c478a786509693b80cd39c44ccd936366"
+
+[[package]]
+name = "futures-util"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c1d6de3acfef38d2be4b1f543f553131788603495be83da675e180c8d6b7bd1"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "gdk-pixbuf-sys"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3092cf797a5f1210479ea38070d9ae8a5b8e9f8f1be9f32f4643c529c7d70016"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gdk-sys"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76354f97a913e55b984759a997b693aa7dc71068c9e98bcce51aa167a0a5c5a"
+dependencies = [
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "gethostname"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1ebd34e35c46e00bb73e81363248d627782724609fe1b6396f553f68fe3862e"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "gimli"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "221996f774192f0f718773def8201c4ae31f02616a54ccfc2d358bb0e5cefdec"
+
+[[package]]
+name = "gio-sys"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9b693b8e39d042a95547fc258a7b07349b1f0b48f4b2fa3108ba3c51c0b5229"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+ "winapi",
+]
+
+[[package]]
+name = "gl_generator"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d"
+dependencies = [
+ "khronos_api",
+ "log",
+ "xml-rs",
+]
+
+[[package]]
+name = "glib-sys"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61a4f46316d06bfa33a7ac22df6f0524c8be58e3db2d9ca99ccb1f357b62a65"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "glow"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8edf6019dff2d92ad27c1e3ff82ad50a0aea5b01370353cc928bfdc33e95925c"
+dependencies = [
+ "js-sys",
+ "slotmap",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "glutin"
+version = "0.30.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "373e3fbcfa6b9c313faa03625a08268168ba9be1003d1ecfcebd5266388aa131"
+dependencies = [
+ "bitflags",
+ "cfg_aliases",
+ "cgl",
+ "core-foundation",
+ "dispatch",
+ "glutin_egl_sys",
+ "glutin_glx_sys",
+ "glutin_wgl_sys",
+ "libloading",
+ "objc2",
+ "once_cell",
+ "raw-window-handle",
+ "wayland-sys 0.30.1",
+ "windows-sys 0.45.0",
+ "x11-dl",
+]
+
+[[package]]
+name = "glutin-winit"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "629a873fc04062830bfe8f97c03773bcd7b371e23bcc465d0a61448cd1588fa4"
+dependencies = [
+ "cfg_aliases",
+ "glutin",
+ "raw-window-handle",
+ "winit",
+]
+
+[[package]]
+name = "glutin_egl_sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5aaf0abb5c4148685b33101ae326a207946b4d3764d6cdc79f8316cdaa8367d"
+dependencies = [
+ "gl_generator",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "glutin_glx_sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b53cb5fe568964aa066a3ba91eac5ecbac869fb0842cd0dc9e412434f1a1494"
+dependencies = [
+ "gl_generator",
+ "x11-dl",
+]
+
+[[package]]
+name = "glutin_wgl_sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef89398e90033fc6bc65e9bd42fd29bbbfd483bda5b56dc5562f455550618165"
+dependencies = [
+ "gl_generator",
+]
+
+[[package]]
+name = "gobject-sys"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3520bb9c07ae2a12c7f2fbb24d4efc11231c8146a86956413fb1a79bb760a0f1"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gpu-alloc"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fc59e5f710e310e76e6707f86c561dd646f69a8876da9131703b2f717de818d"
+dependencies = [
+ "bitflags",
+ "gpu-alloc-types",
+]
+
+[[package]]
+name = "gpu-alloc-types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54804d0d6bc9d7f26db4eaec1ad10def69b599315f487d32c334a80d1efe67a5"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "gpu-allocator"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "434618454f74b63f9b39328298097256977c41ea0ba9d75a47238b77790b6163"
+dependencies = [
+ "backtrace",
+ "log",
+ "thiserror",
+ "winapi",
+ "windows 0.43.0",
+]
+
+[[package]]
+name = "gpu-descriptor"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b0c02e1ba0bdb14e965058ca34e09c020f8e507a760df1121728e0aef68d57a"
+dependencies = [
+ "bitflags",
+ "gpu-descriptor-types",
+ "hashbrown",
+]
+
+[[package]]
+name = "gpu-descriptor-types"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "363e3677e55ad168fef68cf9de3a4a310b53124c5e784c53a1d70e92d23f2126"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "gtk-sys"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89b5f8946685d5fe44497007786600c2f368ff6b1e61a16251c89f72a97520a3"
+dependencies = [
+ "atk-sys",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.6",
+]
+
+[[package]]
+name = "hassle-rs"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90601c6189668c7345fc53842cb3f3a3d872203d523be1b3cb44a36a3e62fb85"
+dependencies = [
+ "bitflags",
+ "com-rs",
+ "libc",
+ "libloading",
+ "thiserror",
+ "widestring",
+ "winapi",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "hello_world"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "hello_world_par"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+]
+
+[[package]]
+name = "hello_world_simple"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hexf-parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "winapi",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+dependencies = [
+ "cxx",
+ "cxx-build",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "image"
+version = "0.24.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69b7ea949b537b0fd0af141fff8c77690f2ce96f4f41f042ccb6c69c6c965945"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+ "color_quant",
+ "jpeg-decoder",
+ "num-rational",
+ "num-traits",
+ "png",
+]
+
+[[package]]
+name = "imagesize"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df19da1e92fbfec043ca97d622955381b1f3ee72a180ec999912df31b1ccd951"
+
+[[package]]
+name = "indexmap"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "io-lifetimes"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfa919a82ea574332e2de6e74b4c36e74d41982b335080fa59d4ef31be20fdf3"
+dependencies = [
+ "libc",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
+
+[[package]]
+name = "jni"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "039022cdf4d7b1cf548d31f60ae783138e5fd42013f6271049d7df7afadef96c"
+dependencies = [
+ "cesu8",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror",
+ "walkdir",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "jobserver"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc0000e42512c92e31c2252315bda326620a4e034105e900c98ec492fa077b3e"
+
+[[package]]
+name = "js-sys"
+version = "0.3.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "keyboard_events"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "khronos-egl"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c2352bd1d0bceb871cb9d40f24360c8133c11d7486b68b5381c1dd1a32015e3"
+dependencies = [
+ "libc",
+ "libloading",
+ "pkg-config",
+]
+
+[[package]]
+name = "khronos_api"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
+
+[[package]]
+name = "kurbo"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a53776d271cfb873b17c618af0298445c88afc52837f3e948fa3fafd131f449"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.139"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "line-wrap"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f30344350a2a51da54c1d53be93fade8a237e545dbcc4bdbe635413f2117cab9"
+dependencies = [
+ "safemem",
+]
+
+[[package]]
+name = "link-cplusplus"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
+
+[[package]]
+name = "litrs"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9275e0933cf8bb20f008924c0cb07a0692fe54d8064996520bf998de9eb79aa"
+
+[[package]]
+name = "lock_api"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "malloc_buf"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "memmap2"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "metal"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de11355d1f6781482d027a3b4d4de7825dcedb197bf573e0596d00008402d060"
+dependencies = [
+ "bitflags",
+ "block",
+ "core-graphics-types",
+ "foreign-types",
+ "log",
+ "objc",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "mint"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
+
+[[package]]
+name = "mio"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "naga"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eafe22a23b797c9bc227c6c896419b26b5bb88fa903417a3adaed08778850d5"
+dependencies = [
+ "bit-set",
+ "bitflags",
+ "codespan-reporting",
+ "hexf-parse",
+ "indexmap",
+ "log",
+ "num-traits",
+ "rustc-hash",
+ "spirv",
+ "termcolor",
+ "thiserror",
+ "unicode-xid",
+]
+
+[[package]]
+name = "ndk"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "451422b7e4718271c8b5b3aadf5adedba43dc76312454b387e98fae0fc951aa0"
+dependencies = [
+ "bitflags",
+ "jni-sys",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror",
+]
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "ndk-glue"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0434fabdd2c15e0aab768ca31d5b7b333717f03cf02037d5a0a3ff3c278ed67f"
+dependencies = [
+ "libc",
+ "log",
+ "ndk",
+ "ndk-context",
+ "ndk-macro",
+ "ndk-sys",
+ "once_cell",
+ "parking_lot",
+]
+
+[[package]]
+name = "ndk-macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0df7ac00c4672f9d5aece54ee3347520b7e20f158656c7db2e6de01902eb7a6c"
+dependencies = [
+ "darling",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "ndk-sys"
+version = "0.4.1+23.1.7779620"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cf2aae958bd232cac5069850591667ad422d263686d75b52a065f9badeee5a3"
+dependencies = [
+ "jni-sys",
+]
+
+[[package]]
+name = "nix"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "memoffset",
+]
+
+[[package]]
+name = "nix"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
+dependencies = [
+ "autocfg",
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "memoffset",
+ "pin-utils",
+]
+
+[[package]]
+name = "nohash-hasher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "nom8"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d829733185c1ca374f17e52b762f24f535ec625d2cc1f070e34c8a9068f341b"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2be1598bf1c313dcdd12092e3f1920f463462525a21b7b4e11b4168353d0123e"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
+ "objc_exception",
+]
+
+[[package]]
+name = "objc-foundation"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9"
+dependencies = [
+ "block",
+ "objc",
+ "objc_id",
+]
+
+[[package]]
+name = "objc-sys"
+version = "0.2.0-beta.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b9834c1e95694a05a828b59f55fa2afec6288359cda67146126b3f90a55d7"
+
+[[package]]
+name = "objc2"
+version = "0.3.0-beta.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe31e5425d3d0b89a15982c024392815da40689aceb34bad364d58732bcfd649"
+dependencies = [
+ "block2",
+ "objc-sys",
+ "objc2-encode",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "2.0.0-pre.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abfcac41015b00a120608fdaa6938c44cb983fee294351cc4bac7638b4e50512"
+dependencies = [
+ "objc-sys",
+]
+
+[[package]]
+name = "objc_exception"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "objc_id"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b"
+dependencies = [
+ "objc",
+]
+
+[[package]]
+name = "object"
+version = "0.30.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea86265d3d3dcb6a27fc51bd29a4bf387fae9d2986b823079d4986af253eb439"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "orbclient"
+version = "0.3.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba683f1641c11041c59d5d93689187abcab3c1349dc6d9d70c550c9f9360802f"
+dependencies = [
+ "cfg-if",
+ "redox_syscall 0.2.16",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "ordered-multimap"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccd746e37177e1711c20dd619a1620f34f5c8b569c53590a72dedd5344d8924a"
+dependencies = [
+ "dlv-list",
+ "hashbrown",
+]
+
+[[package]]
+name = "ordered-stream"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "360a24bdacdb7801a1a6af8500392864791c130ebe8bd9a063158cab00040c90"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "os_str_bytes"
+version = "6.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
+
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
+[[package]]
+name = "owned_ttf_parser"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e25e9fb15717794fae58ab55c26e044103aad13186fbb625893f9a3bbcc24228"
+dependencies = [
+ "ttf-parser",
+]
+
+[[package]]
+name = "oxilangtag"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d91edf4fbb970279443471345a4e8c491bf05bb283b3e6c88e4e606fd8c181b"
+
+[[package]]
+name = "pango-sys"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e134909a9a293e04d2cc31928aa95679c5e4df954d0b85483159bd20d8f047f"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "parking"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.2.16",
+ "smallvec",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d01a5bd0424d00070b0098dd17ebca6f961a959dead1dbcbbbc1d1cd8d3deeba"
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "percent-encoding"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+
+[[package]]
+name = "pico-args"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+
+[[package]]
+name = "plist"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5329b8f106a176ab0dce4aae5da86bfcb139bb74fb00882859e03745011f3635"
+dependencies = [
+ "base64",
+ "indexmap",
+ "line-wrap",
+ "quick-xml",
+ "serde",
+ "time 0.3.17",
+]
+
+[[package]]
+name = "png"
+version = "0.17.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d708eaf860a19b19ce538740d2b4bdeeb8337fa53f7738455e706623ad5c638"
+dependencies = [
+ "bitflags",
+ "crc32fast",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "poll-promise"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcf2a02372dfae23c9c01267fb296b8a3413bb4e45fbd589c3ac73c6dcfbb305"
+dependencies = [
+ "static_assertions",
+]
+
+[[package]]
+name = "polling"
+version = "2.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22122d5ec4f9fe1b3916419b76be1e80bcb93f618d071d2edf841b137b2a2bd6"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "libc",
+ "log",
+ "wepoll-ffi",
+ "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "pollster"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22686f4785f02a4fcc856d3b3bb19bf6c8160d103f7a99cc258bddd0251dc7f2"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66618389e4ec1c7afe67d51a9bf34ff9236480f8d51e7489b7d5ab0303c13f34"
+dependencies = [
+ "once_cell",
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "profiling"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74605f360ce573babfe43964cbe520294dcb081afbf8c108fc6e23036b4da2df"
+
+[[package]]
+name = "puffin"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6755c40ac18b4af2c6dc147fde017de518bdacbf63f5969490f3b62e7c33680"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "byteorder",
+ "instant",
+ "once_cell",
+ "parking_lot",
+ "ruzstd",
+ "serde",
+ "zstd",
+]
+
+[[package]]
+name = "puffin_http"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0248f6b7425d45ac24cecefc9272d679b8fc18e82c5d3777e90146eb9a9f85"
+dependencies = [
+ "anyhow",
+ "crossbeam-channel",
+ "log",
+ "puffin",
+]
+
+[[package]]
+name = "puffin_profiler"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "puffin",
+ "puffin_http",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f50b1c63b38611e7d4d7f68b82d3ad0cc71a2ad2e7f61fc10f1328d917c93cd"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "range-alloc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e935c45e09cc6dcf00d2f0b2d630a58f4095320223d47fc68918722f0538b6"
+
+[[package]]
+name = "raw-window-handle"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed7e3d950b66e19e0c372f3fa3fbbcf85b1746b571f74e0c2af6042a5c93420a"
+dependencies = [
+ "cty",
+]
+
+[[package]]
+name = "rctree"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b42e27ef78c35d3998403c1d26f3efd9e135d3e5121b0a4845cc5cc27547f4f"
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb02a9aee8e8c7ad8d86890f1e16b49e0bbbffc9961ff3788c31d57c98bcbf03"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+dependencies = [
+ "getrandom",
+ "redox_syscall 0.2.16",
+ "thiserror",
+]
+
+[[package]]
+name = "regex"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+
+[[package]]
+name = "renderdoc-sys"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1382d1f0a252c4bf97dc20d979a2fdd05b024acd7c2ed0f7595d7817666a157"
+
+[[package]]
+name = "resvg"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c115863f2d3621999cf187e318bc92b16402dfeff6a48c74df700d77381394c1"
+dependencies = [
+ "log",
+ "pico-args",
+ "rgb",
+ "svgtypes",
+ "tiny-skia",
+ "usvg",
+]
+
+[[package]]
+name = "retained_image"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "egui_extras",
+ "image",
+]
+
+[[package]]
+name = "rfd"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc2583255eadc4e0d816cb7648371cc91e49cbac85b0748b6ab417093bff4040"
+dependencies = [
+ "block",
+ "dispatch",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "js-sys",
+ "log",
+ "objc",
+ "objc-foundation",
+ "objc_id",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows 0.44.0",
+]
+
+[[package]]
+name = "rgb"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7495acf66551cdb696b7711408144bcd3194fc78e32f3a09e809bfe7dd4a7ce3"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin",
+ "untrusted",
+ "web-sys",
+ "winapi",
+]
+
+[[package]]
+name = "ron"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300a51053b1cb55c80b7a9fde4120726ddf25ca241a1cbb926626f62fb136bff"
+dependencies = [
+ "base64",
+ "bitflags",
+ "serde",
+]
+
+[[package]]
+name = "roxmltree"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b9de9831a129b122e7e61f242db509fa9d0838008bf0b29bb0624669edfe48a"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "rust-ini"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6d5f2436026b4f6e79dc829837d467cc7e9a55ee40e750d716713540715a2df"
+dependencies = [
+ "cfg-if",
+ "ordered-multimap",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustix"
+version = "0.36.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd5c6ff11fecd55b40746d1995a02f2eb375bf8c00d192d521ee09f42bef37bc"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "rustls"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f"
+dependencies = [
+ "log",
+ "ring",
+ "sct",
+ "webpki",
+]
+
+[[package]]
+name = "ruzstd"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffae8df4aa221781b715c27bbed0fac16b6f1e2643efb7af8a24dfc78d444493"
+dependencies = [
+ "byteorder",
+ "thiserror",
+ "twox-hash",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"
+
+[[package]]
+name = "safemem"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "scratch"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddccb15bcce173023b3fedd9436f882a0739b8dfb45e4f6b6002bee5929f61b2"
+
+[[package]]
+name = "screenshot"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "image",
+ "itertools",
+]
+
+[[package]]
+name = "sct"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "sctk-adwaita"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc56402866c717f54e48b122eb93c69f709bc5a6359c403598992fd92f017931"
+dependencies = [
+ "ab_glyph",
+ "log",
+ "memmap2",
+ "smithay-client-toolkit",
+ "tiny-skia",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.152"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.152"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7434af0dc1cbd59268aa98b4c22c131c0584d2232f6fb166efb993e2832e896a"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a5ec9fa74a20ebbe5d9ac23dac1fc96ba0ecfe9f50f2843b52e537b10fbcb4e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "serial_windows"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+
+[[package]]
+name = "simplecss"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a11be7c62927d9427e9f40f3444d5499d868648e2edbc4e2116de69e7ec0e89d"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "siphasher"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+
+[[package]]
+name = "slab"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "slotmap"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1e08e261d0e8f5c43123b7adf3e4ca1690d655377ac93a03b2c9d3e98de1342"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+
+[[package]]
+name = "smithay-client-toolkit"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f307c47d32d2715eb2e0ece5589057820e0e5e70d07c247d1063e844e107f454"
+dependencies = [
+ "bitflags",
+ "calloop",
+ "dlib",
+ "lazy_static",
+ "log",
+ "memmap2",
+ "nix 0.24.3",
+ "pkg-config",
+ "wayland-client",
+ "wayland-cursor",
+ "wayland-protocols",
+]
+
+[[package]]
+name = "smithay-clipboard"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a345c870a1fae0b1b779085e81b51e614767c239e93503588e54c5b17f4b0e8"
+dependencies = [
+ "smithay-client-toolkit",
+ "wayland-client",
+]
+
+[[package]]
+name = "socket2"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "speech-dispatcher"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5727d53c474ba5ada07784ad7d203cf896a74854cfee0eb32376b00759eb2972"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "speech-dispatcher-sys",
+]
+
+[[package]]
+name = "speech-dispatcher-sys"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c3e8acdf2b1f4bb13f1813b40b52f3edf4cc94d8a55fe713a584f672a10388d"
+dependencies = [
+ "bindgen",
+]
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "spirv"
+version = "0.2.0+1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "246bfa38fe3db3f1dfc8ca5a2cdeb7348c78be2112740cc0ec8ef18b6d94f830"
+dependencies = [
+ "bitflags",
+ "num-traits",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "str-buf"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0"
+
+[[package]]
+name = "strict-num"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df65f20698aeed245efdde3628a6b559ea1239bbb871af1b6e3b58c413b2bd1"
+dependencies = [
+ "float-cmp",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "svg"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "egui_extras",
+]
+
+[[package]]
+name = "svgtypes"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22975e8a2bac6a76bb54f898a6b18764633b00e780330f0b689f65afb3975564"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syntect"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6c454c27d9d7d9a84c7803aaa3c50cd088d2906fe3c6e42da3209aa623576a8"
+dependencies = [
+ "bincode",
+ "bitflags",
+ "fancy-regex",
+ "flate2",
+ "fnv",
+ "lazy_static",
+ "once_cell",
+ "plist",
+ "regex-syntax",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "thiserror",
+ "walkdir",
+ "yaml-rust",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2955b1fe31e1fa2fbd1976b71cc69a606d7d4da16f6de3333d0c92d51419aeff"
+dependencies = [
+ "cfg-expr",
+ "heck",
+ "pkg-config",
+ "toml",
+ "version-compare",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af18f7ae1acd354b992402e9ec5864359d693cd8a79dcbef59f76891701c1e95"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "redox_syscall 0.2.16",
+ "rustix",
+ "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+
+[[package]]
+name = "thiserror"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi",
+]
+
+[[package]]
+name = "time"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a561bf4617eebd33bca6434b988f39ed798e527f51a1e797d0ee4f61c0a38376"
+dependencies = [
+ "itoa",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+
+[[package]]
+name = "time-macros"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d967f99f534ca7e495c575c62638eebc2898a8c84c119b89e250477bc4ba16b2"
+dependencies = [
+ "time-core",
+]
+
+[[package]]
+name = "tiny-skia"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfef3412c6975196fdfac41ef232f910be2bb37b9dd3313a49a1a6bc815a5bdb"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "bytemuck",
+ "cfg-if",
+ "png",
+ "tiny-skia-path",
+]
+
+[[package]]
+name = "tiny-skia-path"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4b5edac058fc98f51c935daea4d805b695b38e2f151241cad125ade2a2ac20d"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "strict-num",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4553f467ac8e3d374bc9a177a26801e5d0f9b211aa1673fb137a403afd1c9cf5"
+
+[[package]]
+name = "toml_edit"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c59d8dd7d0dcbc6428bf7aa2f0e823e26e43b3c9aca15bbc9475d23e5fa12b"
+dependencies = [
+ "indexmap",
+ "nom8",
+ "toml_datetime",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+dependencies = [
+ "cfg-if",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
+dependencies = [
+ "lazy_static",
+ "log",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6176eae26dd70d0c919749377897b54a9276bd7061339665dd68777926b5a70"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "tracing-wasm"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ttf-parser"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0609f771ad9c6155384897e1df4d948e692667cc0588548b68eb44d052b27633"
+
+[[package]]
+name = "tts"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7d2f3540357cbcd1d3f16aefc6357ba2fb3960591d1468eb951c9021f854338"
+dependencies = [
+ "cocoa-foundation",
+ "core-foundation",
+ "dyn-clonable",
+ "jni",
+ "lazy_static",
+ "libc",
+ "log",
+ "ndk-context",
+ "ndk-glue",
+ "objc",
+ "oxilangtag",
+ "speech-dispatcher",
+ "thiserror",
+ "wasm-bindgen",
+ "web-sys",
+ "windows 0.43.0",
+]
+
+[[package]]
+name = "twox-hash"
+version = "1.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+dependencies = [
+ "cfg-if",
+ "static_assertions",
+]
+
+[[package]]
+name = "type-map"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f"
+dependencies = [
+ "rustc-hash",
+]
+
+[[package]]
+name = "typenum"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+
+[[package]]
+name = "uds_windows"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce65604324d3cce9b966701489fbd0cf318cb1f7bd9dd07ac9a4ee6fb791930d"
+dependencies = [
+ "tempfile",
+ "winapi",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54675592c1dbefd78cbd98db9bacd89886e1ca50692a0692baefffdeb92dd58"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
+[[package]]
+name = "unicode_names2"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446c96c6dd42604779487f0a981060717156648c1706aa1f464677f03c6cc059"
+
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "ureq"
+version = "2.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "338b31dd1314f68f3aabf3ed57ab922df95ffcd902476ca7ba3c4ce7b908c46d"
+dependencies = [
+ "base64",
+ "flate2",
+ "log",
+ "once_cell",
+ "rustls",
+ "url",
+ "webpki",
+ "webpki-roots",
+]
+
+[[package]]
+name = "url"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+]
+
+[[package]]
+name = "usvg"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b5b7c2b30845b3348c067ca3d09e20cc6e327c288f0ca4c48698712abf432e9"
+dependencies = [
+ "base64",
+ "data-url",
+ "flate2",
+ "imagesize",
+ "kurbo",
+ "log",
+ "rctree",
+ "roxmltree",
+ "simplecss",
+ "siphasher",
+ "strict-num",
+ "svgtypes",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
+name = "version-compare"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "waker-fn"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+
+[[package]]
+name = "walkdir"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+dependencies = [
+ "same-file",
+ "winapi",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
+
+[[package]]
+name = "wayland-client"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f3b068c05a039c9f755f881dc50f01732214f5685e379829759088967c46715"
+dependencies = [
+ "bitflags",
+ "downcast-rs",
+ "libc",
+ "nix 0.24.3",
+ "scoped-tls",
+ "wayland-commons",
+ "wayland-scanner",
+ "wayland-sys 0.29.5",
+]
+
+[[package]]
+name = "wayland-commons"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8691f134d584a33a6606d9d717b95c4fa20065605f798a3f350d78dced02a902"
+dependencies = [
+ "nix 0.24.3",
+ "once_cell",
+ "smallvec",
+ "wayland-sys 0.29.5",
+]
+
+[[package]]
+name = "wayland-cursor"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6865c6b66f13d6257bef1cd40cbfe8ef2f150fb8ebbdb1e8e873455931377661"
+dependencies = [
+ "nix 0.24.3",
+ "wayland-client",
+ "xcursor",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b950621f9354b322ee817a23474e479b34be96c2e909c14f7bc0100e9a970bc6"
+dependencies = [
+ "bitflags",
+ "wayland-client",
+ "wayland-commons",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4303d8fa22ab852f789e75a967f0a2cdc430a607751c0499bada3e451cbd53"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "xml-rs",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be12ce1a3c39ec7dba25594b97b42cb3195d54953ddb9d3d95a7c3902bc6e9d4"
+dependencies = [
+ "dlib",
+ "lazy_static",
+ "pkg-config",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b2a02ac608e07132978689a6f9bf4214949c85998c247abadd4f4129b1aa06"
+dependencies = [
+ "dlib",
+ "lazy_static",
+ "log",
+ "pkg-config",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webbrowser"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97d1fa1e5c829b2bf9eb1e28fb950248b797cd6a04866fbdfa8bc31e5eef4c78"
+dependencies = [
+ "core-foundation",
+ "dirs",
+ "jni",
+ "log",
+ "ndk-context",
+ "objc",
+ "raw-window-handle",
+ "url",
+ "web-sys",
+]
+
+[[package]]
+name = "webpki"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
+dependencies = [
+ "webpki",
+]
+
+[[package]]
+name = "wepoll-ffi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d743fdedc5c64377b5fc2bc036b01c7fd642205a0d96356034ae3404d49eb7fb"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "wgpu"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d14c6bfcf3b10f4273f522a95994553c0a5f2934976e62e61a720ae4bc2eb8f2"
+dependencies = [
+ "arrayvec",
+ "cfg-if",
+ "js-sys",
+ "log",
+ "naga",
+ "parking_lot",
+ "profiling",
+ "raw-window-handle",
+ "smallvec",
+ "static_assertions",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "wgpu-core",
+ "wgpu-hal",
+ "wgpu-types",
+]
+
+[[package]]
+name = "wgpu-core"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be1f61be28e557a6ecb2506cac06c63fae3b6d302a006f38195a7a80995abeb9"
+dependencies = [
+ "arrayvec",
+ "bit-vec",
+ "bitflags",
+ "codespan-reporting",
+ "fxhash",
+ "log",
+ "naga",
+ "parking_lot",
+ "profiling",
+ "raw-window-handle",
+ "smallvec",
+ "thiserror",
+ "web-sys",
+ "wgpu-hal",
+ "wgpu-types",
+]
+
+[[package]]
+name = "wgpu-hal"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82e95792925fe3d58950b9a5c2a191caa145e2bc570e2d233f0d7320f6a8e814"
+dependencies = [
+ "android_system_properties",
+ "arrayvec",
+ "ash",
+ "bit-set",
+ "bitflags",
+ "block",
+ "core-graphics-types",
+ "d3d12",
+ "foreign-types",
+ "fxhash",
+ "glow",
+ "gpu-alloc",
+ "gpu-allocator",
+ "gpu-descriptor",
+ "hassle-rs",
+ "js-sys",
+ "khronos-egl",
+ "libc",
+ "libloading",
+ "log",
+ "metal",
+ "naga",
+ "objc",
+ "parking_lot",
+ "profiling",
+ "range-alloc",
+ "raw-window-handle",
+ "renderdoc-sys",
+ "smallvec",
+ "thiserror",
+ "wasm-bindgen",
+ "web-sys",
+ "wgpu-types",
+ "winapi",
+]
+
+[[package]]
+name = "wgpu-types"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecf8cfcbf98f94cc8bd5981544c687140cf9d3948e2ab83849367ead2cd737cf"
+dependencies = [
+ "bitflags",
+ "js-sys",
+ "web-sys",
+]
+
+[[package]]
+name = "which"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
+dependencies = [
+ "either",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "widestring"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17882f045410753661207383517a6f62ec3dbeb6a4ed2acce01f0728238d1983"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-wsapoll"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c17110f57155602a80dca10be03852116403c9ff3cd25b079d666f2aa3df6e"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.43.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04662ed0e3e5630dfa9b26e4cb823b817f1a9addda855d973a9458c236556244"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e745dab35a0c4c77aa3ce42d595e13d2003d6902d6b08c9ef5fc326d08da12b"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce87ca8e3417b02dc2a8a22769306658670ec92d78f1bd420d6310a67c245c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "853f69a591ecd4f810d29f17e902d40e349fb05b0b11fff63b08b826bfe39c7f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2522491fbfcd58cc84d47aeb2958948c4b8982e9a2d8a2a35bbaed431390e7"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
+
+[[package]]
+name = "winit"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4755d4ba0e3d30fc7beef2095e246b1e6a6fad0717608bcb87a2df4b003bcf"
+dependencies = [
+ "android-activity",
+ "bitflags",
+ "cfg_aliases",
+ "core-foundation",
+ "core-graphics",
+ "dispatch",
+ "instant",
+ "libc",
+ "log",
+ "mio",
+ "ndk",
+ "objc2",
+ "once_cell",
+ "orbclient",
+ "percent-encoding",
+ "raw-window-handle",
+ "redox_syscall 0.3.4",
+ "sctk-adwaita",
+ "smithay-client-toolkit",
+ "wasm-bindgen",
+ "wayland-client",
+ "wayland-commons",
+ "wayland-protocols",
+ "wayland-scanner",
+ "web-sys",
+ "windows-sys 0.45.0",
+ "x11-dl",
+]
+
+[[package]]
+name = "winreg"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11rb"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "592b4883219f345e712b3209c62654ebda0bb50887f330cbd018d0f654bfd507"
+dependencies = [
+ "gethostname",
+ "nix 0.24.3",
+ "winapi",
+ "winapi-wsapoll",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56b245751c0ac9db0e006dc812031482784e434630205a93c73cfefcaabeac67"
+dependencies = [
+ "nix 0.24.3",
+]
+
+[[package]]
+name = "xcursor"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "463705a63313cd4301184381c5e8042f0a7e9b4bb63653f216311d4ae74690b7"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "xml-rs"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2d7d3948613f75c98fd9328cfdcc45acc4d360655289d0a7d4ec931392200a3"
+
+[[package]]
+name = "xmlparser"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d25c75bf9ea12c4040a97f829154768bbbce366287e2dc044af160cd79a13fd"
+
+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "zbus"
+version = "3.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76f1a9e02a5659c712de386c2af5156c51a530fac0668d3ff85fa26a2bc006ba"
+dependencies = [
+ "async-broadcast",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "async-recursion",
+ "async-task",
+ "async-trait",
+ "byteorder",
+ "derivative",
+ "dirs",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "hex",
+ "nix 0.25.1",
+ "once_cell",
+ "ordered-stream",
+ "rand",
+ "serde",
+ "serde_repr",
+ "sha1",
+ "static_assertions",
+ "tracing",
+ "uds_windows",
+ "winapi",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "3.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414cd9f07964695e00bfef8e589d1752ea0480b8a619f2064cbaccb8a6c2ed59"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "syn 1.0.107",
+]
+
+[[package]]
+name = "zbus_names"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f34f314916bd89bdb9934154627fab152f4f28acdda03e7c4c68181b214fe7e3"
+dependencies = [
+ "serde",
+ "static_assertions",
+ "zvariant",
+]
+
+[[package]]
+name = "zstd"
+version = "0.11.2+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "5.0.2+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db"
+dependencies = [
+ "libc",
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.6+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68a3f9792c0c3dc6c165840a75f47ae1f4da402c2d006881129579f6597e801b"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "zvariant"
+version = "3.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "576cc41e65c7f283e5460f5818073e68fb1f1631502b969ef228c2e03c862efb"
+dependencies = [
+ "byteorder",
+ "enumflags2",
+ "libc",
+ "serde",
+ "static_assertions",
+ "zvariant_derive",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "3.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fd4aafc0dee96ae7242a24249ce9babf21e1562822f03df650d4e68c20e41ed"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.107",
+]
diff --git a/egui/Cargo.toml b/egui/Cargo.toml
new file mode 100644
index 0000000..30eac61
--- /dev/null
+++ b/egui/Cargo.toml
@@ -0,0 +1,35 @@
+[workspace]
+resolver = "2"
+members = [
+    "crates/ecolor",
+    "crates/egui_demo_app",
+    "crates/egui_demo_lib",
+    "crates/egui_extras",
+    "crates/egui_glow",
+    "crates/egui-wgpu",
+    "crates/egui-winit",
+    "crates/egui",
+    "crates/emath",
+    "crates/epaint",
+
+    "examples/*",
+]
+
+[profile.release]
+# lto = true # VERY slightly smaller wasm
+# opt-level = 's' # 10-20% smaller wasm compared to `opt-level = 3`
+# opt-level = 1 # very slow and big wasm. Don't do this.
+opt-level = 2 # fast and small wasm, basically same as `opt-level = 's'`
+# opt-level = 3 # unnecessarily large wasm for no performance gain
+
+# debug = true # include debug symbols, useful when profiling wasm
+
+
+[profile.dev]
+# Can't leave this on by default, because it breaks the Windows build. Related: https://github.com/rust-lang/cargo/issues/4897
+# split-debuginfo = "unpacked" # faster debug builds on mac
+# opt-level = 1                # Make debug builds run faster
+
+# Optimize all dependencies even in debug builds (does not affect workspace packages):
+[profile.dev.package."*"]
+opt-level = 2
diff --git a/egui/Cranky.toml b/egui/Cranky.toml
new file mode 100644
index 0000000..6fa6ca0
--- /dev/null
+++ b/egui/Cranky.toml
@@ -0,0 +1,124 @@
+# https://github.com/ericseppanen/cargo-cranky
+# cargo install cargo-cranky && cargo cranky
+
+deny = ["unsafe_code"]
+
+warn = [
+  "clippy::all",
+  "clippy::await_holding_lock",
+  "clippy::bool_to_int_with_if",
+  "clippy::char_lit_as_u8",
+  "clippy::checked_conversions",
+  "clippy::cloned_instead_of_copied",
+  "clippy::dbg_macro",
+  "clippy::debug_assert_with_mut_call",
+  "clippy::derive_partial_eq_without_eq",
+  "clippy::disallowed_methods",
+  "clippy::disallowed_script_idents",
+  "clippy::doc_link_with_quotes",
+  "clippy::doc_markdown",
+  "clippy::empty_enum",
+  "clippy::enum_glob_use",
+  "clippy::equatable_if_let",
+  "clippy::exit",
+  "clippy::expl_impl_clone_on_copy",
+  "clippy::explicit_deref_methods",
+  "clippy::explicit_into_iter_loop",
+  "clippy::explicit_iter_loop",
+  "clippy::fallible_impl_from",
+  "clippy::filter_map_next",
+  "clippy::flat_map_option",
+  "clippy::float_cmp_const",
+  "clippy::fn_params_excessive_bools",
+  "clippy::fn_to_numeric_cast_any",
+  "clippy::from_iter_instead_of_collect",
+  "clippy::if_let_mutex",
+  "clippy::implicit_clone",
+  "clippy::imprecise_flops",
+  "clippy::index_refutable_slice",
+  "clippy::inefficient_to_string",
+  "clippy::invalid_upcast_comparisons",
+  "clippy::iter_not_returning_iterator",
+  "clippy::iter_on_empty_collections",
+  "clippy::iter_on_single_items",
+  "clippy::large_digit_groups",
+  "clippy::large_stack_arrays",
+  "clippy::large_types_passed_by_value",
+  "clippy::let_unit_value",
+  "clippy::linkedlist",
+  "clippy::lossy_float_literal",
+  "clippy::macro_use_imports",
+  "clippy::manual_assert",
+  "clippy::manual_instant_elapsed",
+  "clippy::manual_ok_or",
+  "clippy::manual_string_new",
+  "clippy::map_err_ignore",
+  "clippy::map_flatten",
+  "clippy::map_unwrap_or",
+  "clippy::match_on_vec_items",
+  "clippy::match_same_arms",
+  "clippy::match_wild_err_arm",
+  "clippy::match_wildcard_for_single_variants",
+  "clippy::mem_forget",
+  "clippy::mismatched_target_os",
+  "clippy::mismatching_type_param_order",
+  "clippy::missing_enforced_import_renames",
+  "clippy::missing_errors_doc",
+  "clippy::missing_safety_doc",
+  "clippy::mut_mut",
+  "clippy::mutex_integer",
+  "clippy::needless_borrow",
+  "clippy::needless_continue",
+  "clippy::needless_for_each",
+  "clippy::needless_pass_by_value",
+  "clippy::negative_feature_names",
+  "clippy::nonstandard_macro_braces",
+  "clippy::option_option",
+  "clippy::path_buf_push_overwrite",
+  "clippy::ptr_as_ptr",
+  "clippy::rc_mutex",
+  "clippy::ref_option_ref",
+  "clippy::rest_pat_in_fully_bound_structs",
+  "clippy::same_functions_in_if_condition",
+  "clippy::semicolon_if_nothing_returned",
+  "clippy::single_match_else",
+  "clippy::str_to_string",
+  "clippy::string_add_assign",
+  "clippy::string_add",
+  "clippy::string_lit_as_bytes",
+  "clippy::string_to_string",
+  "clippy::todo",
+  "clippy::trailing_empty_array",
+  "clippy::trait_duplication_in_bounds",
+  "clippy::unimplemented",
+  "clippy::unnecessary_wraps",
+  "clippy::unnested_or_patterns",
+  "clippy::unused_peekable",
+  "clippy::unused_rounding",
+  "clippy::unused_self",
+  "clippy::useless_transmute",
+  "clippy::verbose_file_reads",
+  "clippy::zero_sized_map_values",
+  "elided_lifetimes_in_paths",
+  "future_incompatible",
+  "nonstandard_style",
+  "rust_2018_idioms",
+  "rust_2021_prelude_collisions",
+  "rustdoc::missing_crate_level_docs",
+  "semicolon_in_expressions_from_macros",
+  "trivial_numeric_casts",
+  "unused_extern_crates",
+  "unused_import_braces",
+  "unused_lifetimes",
+]
+
+allow = [
+  "clippy::manual_range_contains", # This one is just annoying
+
+  # Some of these we should try to put in "warn":
+  "clippy::type_complexity",
+  "clippy::undocumented_unsafe_blocks",
+  "trivial_casts",
+  "unsafe_op_in_unsafe_fn",             # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
+  "unused_qualifications",
+]
diff --git a/egui/LICENSE-APACHE b/egui/LICENSE-APACHE
new file mode 100644
index 0000000..11069ed
--- /dev/null
+++ b/egui/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/egui/LICENSE-MIT b/egui/LICENSE-MIT
new file mode 100644
index 0000000..673ea5f
--- /dev/null
+++ b/egui/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2018-2021 Emil Ernerfeldt <emil.ernerfeldt@gmail.com>
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/egui/README.md b/egui/README.md
new file mode 100644
index 0000000..98e30b7
--- /dev/null
+++ b/egui/README.md
@@ -0,0 +1,423 @@
+# 🖌 egui: an easy-to-use GUI in pure Rust
+
+[<img alt="github" src="https://img.shields.io/badge/github-emilk/egui-8da0cb?logo=github" height="20">](https://github.com/emilk/egui)
+[![Latest version](https://img.shields.io/crates/v/egui.svg)](https://crates.io/crates/egui)
+[![Documentation](https://docs.rs/egui/badge.svg)](https://docs.rs/egui)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+[![Build Status](https://github.com/emilk/egui/workflows/CI/badge.svg)](https://github.com/emilk/egui/actions?workflow=CI)
+[![MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/emilk/egui/blob/master/LICENSE-MIT)
+[![Apache](https://img.shields.io/badge/license-Apache-blue.svg)](https://github.com/emilk/egui/blob/master/LICENSE-APACHE)
+[![Discord](https://img.shields.io/discord/900275882684477440?label=egui%20discord)](https://discord.gg/JFcEma9bJq)
+
+👉 [Click to run the web demo](https://www.egui.rs/#demo) 👈
+
+egui (pronounced "e-gooey") is a simple, fast, and highly portable immediate mode GUI library for Rust. egui runs on the web, natively, and [in your favorite game engine](#integrations) (or will soon).
+
+egui aims to be the easiest-to-use Rust GUI library, and the simplest way to make a web app in Rust.
+
+egui can be used anywhere you can draw textured triangles, which means you can easily integrate it into your game engine of choice.
+
+Sections:
+
+* [Example](#example)
+* [Quick start](#quick-start)
+* [Demo](#demo)
+* [Goals](#goals)
+* [Who is egui for?](#who-is-egui-for)
+* [State / features](#state)
+* [Integrations](#integrations)
+* [Why immediate mode](#why-immediate-mode)
+* [FAQ](#faq)
+* [Other](#other)
+* [Credits](#credits)
+
+([egui 的中文翻译文档 / chinese translation](https://github.com/Re-Ch-Love/egui-doc-cn/blob/main/README_zh-hans.md))
+
+## Example
+
+``` rust
+ui.heading("My egui Application");
+ui.horizontal(|ui| {
+    ui.label("Your name: ");
+    ui.text_edit_singleline(&mut name);
+});
+ui.add(egui::Slider::new(&mut age, 0..=120).text("age"));
+if ui.button("Click each year").clicked() {
+    age += 1;
+}
+ui.label(format!("Hello '{}', age {}", name, age));
+```
+
+<img src="media/demo.gif">
+
+## Quick start
+
+There are simple examples in [the `examples/` folder](https://github.com/emilk/egui/blob/master/examples/). If you want to write a web app, then go to <https://github.com/emilk/eframe_template/> and follow the instructions. The official docs are at <https://docs.rs/egui>. For inspiration and more examples, check out the [the egui web demo](https://www.egui.rs/#demo) and follow the links in it to its source code.
+
+If you want to integrate egui into an existing engine, go to the [Integrations](#integrations) section.
+
+If you have questions, use [GitHub Discussions](https://github.com/emilk/egui/discussions). There is also [an egui discord server](https://discord.gg/JFcEma9bJq). If you want to contribute to egui, please read the [Contributing Guidelines](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md).
+
+## Demo
+
+[Click to run egui web demo](https://www.egui.rs/#demo) (works in any browser with WASM and WebGL support). Uses [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+
+To test the demo app locally, run `cargo run --release -p egui_demo_app`.
+
+The native backend is [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow) (using [`glow`](https://crates.io/crates/glow)) and should work out-of-the-box on Mac and Windows, but on Linux you need to first run:
+
+`sudo apt-get install -y libclang-dev libgtk-3-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev`
+
+On Fedora Rawhide you need to run:
+
+`dnf install clang clang-devel clang-tools-extra libxkbcommon-devel pkg-config openssl-devel libxcb-devel`
+
+**NOTE**: This is just for the demo app - egui itself is completely platform agnostic!
+
+## Goals
+
+* The easiest to use GUI library
+* Responsive: target 60 Hz in debug build
+* Friendly: difficult to make mistakes, and shouldn't panic
+* Portable: the same code works on the web and as a native app
+* Easy to integrate into any environment
+* A simple 2D graphics API for custom painting ([`epaint`](https://docs.rs/epaint)).
+* No callbacks
+* Pure immediate mode
+* Extensible: [easy to write your own widgets for egui](https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/demo/toggle_switch.rs)
+* Modular: You should be able to use small parts of egui and combine them in new ways
+* Safe: there is no `unsafe` code in egui
+* Minimal dependencies: [`ab_glyph`](https://crates.io/crates/ab_glyph) [`ahash`](https://crates.io/crates/ahash) [`nohash-hasher`](https://crates.io/crates/nohash-hasher) [`parking_lot`](https://crates.io/crates/parking_lot)
+
+egui is *not* a framework. egui is a library you call into, not an environment you program for.
+
+**NOTE**: egui does not claim to have reached all these goals yet! egui is still work in progress.
+
+### Non-goals
+
+* Become the most powerful GUI library
+* Native looking interface
+* Advanced and flexible layouts (that's fundamentally incompatible with immediate mode)
+
+## Who is egui for?
+
+egui aims to be the best choice when you want a simple way to create a GUI, or you want to add a GUI to a game engine.
+
+If you are not using Rust, egui is not for you. If you want a GUI that looks native, egui is not for you. If you want something that doesn't break when you upgrade it, egui isn't for you (yet).
+
+But if you are writing something interactive in Rust that needs a simple GUI, egui may be for you.
+
+### egui vs Dear ImGui
+
+The obvious alternative to egui is [`imgui-rs`](https://github.com/Gekkio/imgui-rs), the Rust wrapper around the C++ library [Dear ImGui](https://github.com/ocornut/imgui). Dear ImGui is a great library (and the main inspiration for egui), with a lot more features and polish. However, egui provides some benefits for Rust users:
+
+* egui is pure Rust
+* egui is easily compiled to WASM
+* egui lets you use native Rust string types (`imgui-rs` forces you to use annoying macros and wrappers for zero-terminated strings)
+* [Writing your own widgets in egui is simple](https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/demo/toggle_switch.rs)
+
+egui also tries to improve your experience in other small ways:
+
+* Windows are automatically sized based on their contents
+* Windows are automatically positioned to not overlap with each other
+* Some subtle animations make egui come alive
+
+So in summary:
+
+* egui: pure Rust, new, exciting, work in progress
+* Dear ImGui: feature rich, well tested, cumbersome Rust integration
+
+## State
+
+egui is in active development. It works well for what it does, but it lacks many features and the interfaces are still in flux. New releases will have breaking changes.
+
+### Features
+
+* Widgets: label, text button, hyperlink, checkbox, radio button, slider, draggable value, text editing, combo box, color picker
+* Layouts: horizontal, vertical, columns, automatic wrapping
+* Text editing: multiline, copy/paste, undo, emoji supports
+* Windows: move, resize, name, minimize and close. Automatically sized and positioned.
+* Regions: resizing, vertical scrolling, collapsing headers (sections)
+* Rendering: Anti-aliased rendering of lines, circles, text and convex polygons.
+* Tooltips on hover
+* More
+
+<img src="media/widget_gallery.gif" width="50%">
+
+Light Theme:
+
+<img src="media/light_theme.png" width="50%">
+
+## Integrations
+
+egui is built to be easy to integrate into any existing game engine or platform you are working on.
+egui itself doesn't know or care on what OS it is running or how to render things to the screen - that is the job of the egui integration.
+
+An integration needs to do the following each frame:
+
+* **Input**: Gather input (mouse, touches, keyboard, screen size, etc) and give it to egui
+* Run the application code
+* **Output**: Handle egui output (cursor changes, paste, texture allocations, …)
+* **Painting**: Render the triangle mesh egui produces (see [OpenGL example](https://github.com/emilk/egui/blob/master/crates/egui_glow/src/painter.rs))
+
+### Official integrations
+
+These are the official egui integrations:
+
+* [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) for compiling the same app to web/wasm and desktop/native. Uses `egui-winit` and `egui_glow` or `egui-wgpu`.
+* [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow) for rendering egui with [glow](https://github.com/grovesNL/glow) on native and web, and for making native apps.
+* [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu) for [wgpu](https://crates.io/crates/wgpu) (WebGPU API).
+* [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit) for integrating with [winit](https://github.com/rust-windowing/winit).
+* [`egui_glium`](https://github.com/emilk/egui/tree/master/crates/egui_glium) for compiling native apps with [Glium](https://github.com/glium/glium) (DEPRECATED - looking for new maintainer).
+
+### 3rd party integrations
+
+* [`amethyst_egui`](https://github.com/jgraef/amethyst_egui) for [the Amethyst game engine](https://amethyst.rs/).
+* [`bevy_egui`](https://github.com/mvlabat/bevy_egui) for [the Bevy game engine](https://bevyengine.org/).
+* [`egui_glfw_gl`](https://github.com/cohaereo/egui_glfw_gl) for [GLFW](https://crates.io/crates/glfw).
+* [`egui-glutin-gl`](https://github.com/h3r2tic/egui-glutin-gl/) for [glutin](https://crates.io/crates/glutin).
+* [`egui_sdl2_gl`](https://crates.io/crates/egui_sdl2_gl) for [SDL2](https://crates.io/crates/sdl2).
+* [`egui_sdl2_platform`](https://github.com/ComLarsic/egui_sdl2_platform) for [SDL2](https://crates.io/crates/sdl2).
+* [`egui_vulkano`](https://github.com/derivator/egui_vulkano) for [Vulkano](https://github.com/vulkano-rs/vulkano).
+* [`egui_winit_vulkano`](https://github.com/hakolao/egui_winit_vulkano) for [Vulkano](https://github.com/vulkano-rs/vulkano).
+* [`egui-macroquad`](https://github.com/optozorax/egui-macroquad) for [macroquad](https://github.com/not-fl3/macroquad).
+* [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad) for [Miniquad](https://github.com/not-fl3/miniquad).
+* [`egui_speedy2d`](https://github.com/heretik31/egui_speedy2d) for [Speedy2d](https://github.com/QuantumBadger/Speedy2D).
+* [`egui-tetra`](https://crates.io/crates/egui-tetra) for [Tetra](https://crates.io/crates/tetra), a 2D game framework.
+* [`egui-winit-ash-integration`](https://github.com/MatchaChoco010/egui-winit-ash-integration) for [winit](https://github.com/rust-windowing/winit) and [ash](https://github.com/MaikKlein/ash).
+* [`fltk-egui`](https://crates.io/crates/fltk-egui) for [fltk-rs](https://github.com/fltk-rs/fltk-rs).
+* [`ggegui`](https://github.com/NemuiSen/ggegui) for the [ggez](https://ggez.rs/) game framework.
+* [`godot-egui`](https://github.com/setzer22/godot-egui) for [godot-rust](https://github.com/godot-rust/godot-rust).
+* [`nannou_egui`](https://github.com/nannou-org/nannou/tree/master/nannou_egui) for [nannou](https://nannou.cc).
+* [`notan_egui`](https://github.com/Nazariglez/notan/tree/main/crates/notan_egui) for [notan](https://github.com/Nazariglez/notan).
+* [`screen-13-egui`](https://github.com/attackgoat/screen-13/tree/master/contrib/screen-13-egui) for [Screen 13](https://github.com/attackgoat/screen-13).
+* [`egui_skia`](https://github.com/lucasmerlin/egui_skia) for [skia](https://github.com/rust-skia/rust-skia/tree/master/skia-safe).
+* [`smithay-egui`](https://github.com/Smithay/smithay-egui) for [smithay](https://github.com/Smithay/smithay/).
+* [`tauri-egui`](https://github.com/tauri-apps/tauri-egui) for [tauri](https://github.com/tauri-apps/tauri).
+
+Missing an integration for the thing you're working on? Create one, it's easy!
+
+### Writing your own egui integration
+
+You need to collect [`egui::RawInput`](https://docs.rs/egui/latest/egui/struct.RawInput.html) and handle [`egui::FullOutput`](https://docs.rs/egui/latest/egui/struct.FullOutput.html). The basic structure is this:
+
+``` rust
+let mut egui_ctx = egui::CtxRef::default();
+
+// Game loop:
+loop {
+    // Gather input (mouse, touches, keyboard, screen size, etc):
+    let raw_input: egui::RawInput = my_integration.gather_input();
+    let full_output = egui_ctx.run(raw_input, |egui_ctx| {
+        my_app.ui(egui_ctx); // add panels, windows and widgets to `egui_ctx` here
+    });
+    let clipped_primitives = egui_ctx.tessellate(full_output.shapes); // creates triangles to paint
+
+    my_integration.paint(&full_output.textures_delta, clipped_primitives);
+
+    let platform_output = full_output.platform_output;
+    my_integration.set_cursor_icon(platform_output.cursor_icon);
+    if !platform_output.copied_text.is_empty() {
+        my_integration.set_clipboard_text(platform_output.copied_text);
+    }
+    // See `egui::FullOutput` and `egui::PlatformOutput` for more
+}
+```
+
+For a reference OpenGL backend, see [the `egui_glium` painter](https://github.com/emilk/egui/blob/master/crates/egui_glium/src/painter.rs) or [the `egui_glow` painter](https://github.com/emilk/egui/blob/master/crates/egui_glow/src/painter.rs).
+
+### Debugging your integration
+
+#### Things look jagged
+
+* Turn off backface culling.
+
+#### My text is blurry
+
+* Make sure you set the proper `pixels_per_point` in the input to egui.
+* Make sure the texture sampler is not off by half a pixel. Try nearest-neighbor sampler to check.
+
+#### My windows are too transparent or too dark
+
+* egui uses premultiplied alpha, so make sure your blending function is `(ONE, ONE_MINUS_SRC_ALPHA)`.
+* Make sure your texture sampler is clamped (`GL_CLAMP_TO_EDGE`).
+* egui prefers linear color spaces for all blending so:
+  * Use an sRGBA-aware texture if available (e.g. `GL_SRGB8_ALPHA8`).
+    * Otherwise: remember to decode gamma in the fragment shader.
+  * Decode the gamma of the incoming vertex colors in your vertex shader.
+  * Turn on sRGBA/linear framebuffer if available (`GL_FRAMEBUFFER_SRGB`).
+    * Otherwise: gamma-encode the colors before you write them again.
+
+
+## Why immediate mode
+
+`egui` is an [immediate mode GUI library](https://en.wikipedia.org/wiki/Immediate_mode_GUI), as opposed to a *retained mode* GUI library. The difference between retained mode and immediate mode is best illustrated with the example of a button: In a retained GUI you create a button, add it to some UI and install some on-click handler (callback). The button is retained in the UI, and to change the text on it you need to store some sort of reference to it. By contrast, in immediate mode you show the button and interact with it immediately, and you do so every frame (e.g. 60 times per second). This means there is no need for any on-click handler, nor to store any reference to it. In `egui` this looks like this: `if ui.button("Save file").clicked() { save(file); }`.
+
+A more detailed description of immediate mode can be found [in the `egui` docs](https://docs.rs/egui/latest/egui/#understanding-immediate-mode).
+
+There are advantages and disadvantages to both systems.
+
+The short of it is this: immediate mode GUI libraries are easier to use, but less powerful.
+
+### Advantages of immediate mode
+#### Usability
+The main advantage of immediate mode is that the application code becomes vastly simpler:
+
+* You never need to have any on-click handlers and callbacks that disrupts your code flow.
+* You don't have to worry about a lingering callback calling something that is gone.
+* Your GUI code can easily live in a simple function (no need for an object just for the UI).
+* You don't have to worry about app state and GUI state being out-of-sync (i.e. the GUI showing something outdated), because the GUI isn't storing any state - it is showing the latest state *immediately*.
+
+In other words, a whole lot of code, complexity and bugs are gone, and you can focus your time on something more interesting than writing GUI code.
+
+### Disadvantages of immediate mode
+
+#### Layout
+The main disadvantage of immediate mode is it makes layout more difficult. Say you want to show a small dialog window in the center of the screen. To position the window correctly the GUI library must first know the size of it. To know the size of the window the GUI library must first layout the contents of the window. In retained mode this is easy: the GUI library does the window layout, positions the window, then checks for interaction ("was the OK button clicked?").
+
+In immediate mode you run into a paradox: to know the size of the window, we must do the layout, but the layout code also checks for interaction ("was the OK button clicked?") and so it needs to know the window position *before* showing the window contents. This means we must decide where to show the window *before* we know its size!
+
+This is a fundamental shortcoming of immediate mode GUIs, and any attempt to resolve it comes with its own downsides.
+
+One workaround is to store the size and use it the next frame. This produces a frame-delay for the correct layout, producing occasional flickering the first frame something shows up. `egui` does this for some things such as windows and grid layouts.
+
+You can also call the layout code twice (once to get the size, once to do the interaction), but that is not only more expensive, it's also complex to implement, and in some cases twice is not enough. `egui` never does this.
+
+For "atomic" widgets (e.g. a button) `egui` knows the size before showing it, so centering buttons, labels etc is possible in `egui` without any special workarounds.
+
+#### CPU usage
+Since an immediate mode GUI does a full layout each frame, the layout code needs to be quick. If you have a very complex GUI this can tax the CPU. In particular, having a very large UI in a scroll area (with very long scrollback) can be slow, as the content needs to be laid out each frame.
+
+If you design the GUI with this in mind and refrain from huge scroll areas (or only lay out the part that is in view) then the performance hit is generally pretty small. For most cases you can expect `egui` to take up 1-2 ms per frame, but `egui` still has a lot of room for optimization (it's not something I've focused on yet). You can also set up `egui` to only repaint when there is interaction (e.g. mouse movement).
+
+If your GUI is highly interactive, then immediate mode may actually be more performant compared to retained mode. Go to any web page and resize the browser window, and you'll notice that the browser is very slow to do the layout and eats a lot of CPU doing it. Resize a window in `egui` by contrast, and you'll get smooth 60 FPS at no extra CPU cost.
+
+
+#### IDs
+There are some GUI state that you want the GUI library to retain, even in an immediate mode library such as `egui`. This includes position and sizes of windows and how far the user has scrolled in some UI. In these cases you need to provide `egui` with a seed of a unique identifier (unique within the parent UI). For instance: by default `egui` uses the window titles as unique IDs to store window positions. If you want two windows with the same name (or one window with a dynamic name) you must provide some other ID source to `egui` (some unique integer or string).
+
+`egui` also needs to track which widget is being interacted with (e.g. which slider is being dragged). `egui` uses unique id:s for this awell, but in this case the IDs are automatically generated, so there is no need for the user to worry about it. In particular, having two buttons with the same name is no problem (this is in contrast with [`Dear ImGui`](https://github.com/ocornut/imgui)).
+
+Overall, ID handling is a rare inconvenience, and not a big disadvantage.
+
+
+## FAQ
+
+Also see [GitHub Discussions](https://github.com/emilk/egui/discussions/categories/q-a).
+
+### Can I use `egui` with non-latin characters?
+Yes! But you need to install your own font (`.ttf` or `.otf`) using `Context::set_fonts`.
+
+### Can I customize the look of egui?
+Yes! You can customize the colors, spacing, fonts and sizes of everything using `Context::set_style`.
+
+Here is an example (from https://github.com/AlexxxRu/TinyPomodoro):
+
+<img src="media/pompodoro-skin.png" width="50%">
+
+### How do I use egui with `async`?
+If you call `.await` in your GUI code, the UI will freeze, which is very bad UX. Instead, keep the GUI thread non-blocking and communicate with any concurrent tasks (`async` tasks or other threads) with something like:
+* Channels (e.g. [`std::sync::mpsc::channel`](https://doc.rust-lang.org/std/sync/mpsc/fn.channel.html)). Make sure to use [`try_recv`](https://doc.rust-lang.org/std/sync/mpsc/struct.Receiver.html#method.try_recv) so you don't block the gui thread!
+* `Arc<Mutex<Value>>` (background thread sets a value; GUI thread reads it)
+* [`poll_promise::Promise`](https://docs.rs/poll-promise) (example: [`examples/download_image/`](https://github.com/emilk/egui/blob/master/examples/download_image/))
+* [`eventuals::Eventual`](https://docs.rs/eventuals/latest/eventuals/struct.Eventual.html)
+* [`tokio::sync::watch::channel`](https://docs.rs/tokio/latest/tokio/sync/watch/fn.channel.html)
+
+### What about accessibility, such as screen readers?
+egui includes optional support for [AccessKit](https://accesskit.dev/), which currently implements the native accessibility APIs on Windows and macOS. This feature is enabled by default in eframe. For platforms that AccessKit doesn't yet support, including web, there is an experimental built-in screen reader; in [the web demo](https://www.egui.rs/#demo) you can enable it in the "Backend" tab.
+
+The original discussion of accessibility in egui is at <https://github.com/emilk/egui/issues/167>. Now that AccessKit support is merged, providing a strong foundation for future accessibility work, please open new issues on specific accessibility problems.
+
+### What is the difference between [egui](https://docs.rs/egui) and [eframe](https://github.com/emilk/egui/tree/master/crates/eframe)?
+
+`egui` is a 2D user interface library for laying out and interacting with buttons, sliders, etc.
+`egui` has no idea if it is running on the web or natively, and does not know how to collect input or show things on screen.
+That is the job of *the integration* or *backend*.
+
+It is common to use `egui` from a game engine (using e.g. [`bevy_egui`](https://docs.rs/bevy_egui)),
+but you can also use `egui` stand-alone using `eframe`. `eframe` has integration for web and native, and handles input and rendering.
+The _frame_ in `eframe` stands both for the frame in which your egui app resides and also for "framework" (`frame` is a framework, `egui` is a library).
+
+### How do I render 3D stuff in an egui area?
+There are multiple ways to combine egui with 3D. The simplest way is to use a 3D library and have egui sit on top of the 3D view. See for instance [`bevy_egui`](https://github.com/mvlabat/bevy_egui) or [`three-d`](https://github.com/asny/three-d).
+
+If you want to embed 3D into an egui view there are two options.
+
+#### `Shape::Callback`
+Examples:
+* <https://github.com/emilk/egui/blob/master/examples/custom_3d_three-d.rs>
+* <https://github.com/emilk/egui/blob/master/examples/custom_3d_glow.rs>
+
+`Shape::Callback` will call your code when egui gets painted, to show anything using whatever the background rendering context is. When using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) this will be [`glow`](https://github.com/grovesNL/glow). Other integrations will give you other rendering contexts, if they support `Shape::Callback` at all.
+
+#### Render-to-texture
+You can also render your 3D scene to a texture and display it using [`ui.image(…)`](https://docs.rs/egui/latest/egui/struct.Ui.html#method.image). You first need to convert the native texture to an [`egui::TextureId`](https://docs.rs/egui/latest/egui/enum.TextureId.html), and how to do this depends on the integration you use.
+
+Examples:
+* Using [`egui-miniquad`]( https://github.com/not-fl3/egui-miniquad): https://github.com/not-fl3/egui-miniquad/blob/master/examples/render_to_egui_image.rs
+* Using [`egui_glium`](https://github.com/emilk/egui/tree/master/crates/egui_glium): <https://github.com/emilk/egui/blob/master/crates/egui_glium/examples/native_texture.rs>.
+
+
+## Other
+
+### Conventions and design choices
+
+All coordinates are in screen space coordinates, with (0, 0) in the top left corner
+
+All coordinates are in "points" which may consist of many physical pixels.
+
+All colors have premultiplied alpha.
+
+egui uses the builder pattern for construction widgets. For instance: `ui.add(Label::new("Hello").text_color(RED));` I am not a big fan of the builder pattern (it is quite verbose both in implementation and in use) but until Rust has named, default arguments it is the best we can do. To alleviate some of the verbosity there are common-case helper functions, like `ui.label("Hello");`.
+
+Instead of using matching `begin/end` style function calls (which can be error prone) egui prefers to use `FnOnce` closures passed to a wrapping function. Lambdas are a bit ugly though, so I'd like to find a nicer solution to this. More discussion of this at <https://github.com/emilk/egui/issues/1004#issuecomment-1001650754>.
+
+egui uses a single `RwLock` for short-time locks on each access of `Context` data. This is to leave implementation simple and transactional and allow users to run their UI logic in parallel. Instead of creating mutex guards, egui uses closures passed to a wrapping function, e.g. `ctx.input(|i| i.key_down(Key::A))`. This is to make it less likely that a user would accidentally double-lock the `Context`, which would lead to a deadlock.
+
+### Inspiration
+
+The one and only [Dear ImGui](https://github.com/ocornut/imgui) is a great Immediate Mode GUI for C++ which works with many backends. That library revolutionized how I think about GUI code and turned GUI programming from something I hated to do to something I now enjoy.
+
+### Name
+
+The name of the library and the project is "egui" and pronounced as "e-gooey". Please don't write it as "EGUI".
+
+The library was originally called "Emigui", but was renamed to "egui" in 2020.
+
+## Credits
+
+egui author and maintainer: Emil Ernerfeldt [(@emilk](https://github.com/emilk)).
+
+Notable contributions by:
+
+* [@n2](https://github.com/n2): [Mobile web input and IME support](https://github.com/emilk/egui/pull/253).
+* [@optozorax](https://github.com/optozorax): [Arbitrary widget data storage](https://github.com/emilk/egui/pull/257).
+* [@quadruple-output](https://github.com/quadruple-output): [Multitouch](https://github.com/emilk/egui/pull/306).
+* [@EmbersArc](https://github.com/EmbersArc): [Plots](https://github.com/emilk/egui/pulls?q=+is%3Apr+author%3AEmbersArc).
+* [@AsmPrgmC3](https://github.com/AsmPrgmC3): [Proper sRGBA blending for web](https://github.com/emilk/egui/pull/650).
+* [@AlexApps99](https://github.com/AlexApps99): [`egui_glow`](https://github.com/emilk/egui/pull/685).
+* [@mankinskin](https://github.com/mankinskin): [Context menus](https://github.com/emilk/egui/pull/543).
+* [@t18b219k](https://github.com/t18b219k): [Port glow painter to web](https://github.com/emilk/egui/pull/868).
+* [@danielkeller](https://github.com/danielkeller): [`Context` refactor](https://github.com/emilk/egui/pull/1050).
+* [@MaximOsipenko](https://github.com/MaximOsipenko): [`Context` lock refactor](https://github.com/emilk/egui/pull/2625).
+* And [many more](https://github.com/emilk/egui/graphs/contributors?type=a).
+
+egui is licensed under [MIT](LICENSE-MIT) OR [Apache-2.0](LICENSE-APACHE).
+
+* The flattening algorithm for the cubic bezier curve and quadratic bezier curve is from [lyon_geom](https://docs.rs/lyon_geom/latest/lyon_geom/)
+
+Default fonts:
+
+* `emoji-icon-font.ttf`: [Copyright (c) 2014 John Slegers](https://github.com/jslegers/emoji-icon-font) , MIT License
+* `Hack-Regular.ttf`: <https://github.com/source-foundry/Hack>, [MIT Licence](https://github.com/source-foundry/Hack/blob/master/LICENSE.md)
+* `NotoEmoji-Regular.ttf`: [google.com/get/noto](https://google.com/get/noto), [SIL Open Font License](https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL)
+* `Ubuntu-Light.ttf` by [Dalton Maag](http://www.daltonmaag.com/): [Ubuntu font licence](https://ubuntu.com/legal/font-licence)
+
+---
+
+<div align="center">
+<img src="media/rerun_io_logo.png" width="50%">
+
+egui development is sponsored by [Rerun](https://www.rerun.io/), a startup doing<br>
+visualizations for computer vision and robotics.
+</div>
diff --git a/egui/_typos.toml b/egui/_typos.toml
new file mode 100644
index 0000000..2d9cf89
--- /dev/null
+++ b/egui/_typos.toml
@@ -0,0 +1,10 @@
+# https://github.com/crate-ci/typos
+# install:  cargo install typos-cli
+# run:      typos
+
+[default.extend-words]
+nknown = "nknown"     # part of @55nknown username
+Prefence = "Prefence" # typo in glutin_winit API
+
+[files]
+extend-exclude = ["docs/egui_demo_app.js"] # auto-generated
diff --git a/egui/bacon.toml b/egui/bacon.toml
new file mode 100644
index 0000000..e0d4af9
--- /dev/null
+++ b/egui/bacon.toml
@@ -0,0 +1,46 @@
+# This is a configuration file for the bacon tool
+# More info at https://github.com/Canop/bacon
+
+default_job = "cranky"
+
+[jobs]
+
+[jobs.cranky]
+command = ["cargo", "cranky", "--all-targets", "--all-features", "--color", "always"]
+need_stdout = false
+watch = ["tests", "benches", "examples"]
+
+[jobs.test]
+command = ["cargo", "test", "--color", "always"]
+need_stdout = true
+watch = ["tests"]
+
+[jobs.doc]
+command = ["cargo", "doc", "--color", "always", "--all-features", "--no-deps"]
+need_stdout = false
+
+# if the doc compiles, then it opens in your browser and bacon switches
+# to the previous job
+[jobs.doc-open]
+command = ["cargo", "doc", "--color", "always", "--all-features", "--no-deps", "--open"]
+need_stdout = false
+on_success = "back" # so that we don't open the browser at each change
+
+# You can run your application and have the result displayed in bacon,
+# *if* it makes sense for this crate. You can run an example the same
+# way. Don't forget the `--color always` part or the errors won't be
+# properly parsed.
+[jobs.run]
+command = ["cargo", "run", "--color", "always"]
+need_stdout = true
+
+# You may define here keybindings that would be specific to
+# a project, for example a shortcut to launch a specific job.
+# Shortcuts to internal functions (scrolling, toggling, etc.)
+# should go in your personal prefs.toml file instead.
+[keybindings]
+i = "job:initial"
+c = "job:cranky"
+d = "job:doc-open"
+t = "job:test"
+r = "job:run"
diff --git a/egui/clippy.toml b/egui/clippy.toml
new file mode 100644
index 0000000..f09ee27
--- /dev/null
+++ b/egui/clippy.toml
@@ -0,0 +1 @@
+doc-valid-idents = ["AccessKit", ".."]
diff --git a/egui/crates/ecolor/CHANGELOG.md b/egui/crates/ecolor/CHANGELOG.md
new file mode 100644
index 0000000..e278e36
--- /dev/null
+++ b/egui/crates/ecolor/CHANGELOG.md
@@ -0,0 +1,13 @@
+# Changelog for ecolor
+All notable changes to the `ecolor` crate will be noted in this file.
+
+
+## Unreleased
+
+
+## 0.21.0 - 2023-02-08
+* Add `Color32::gamma_multiply` ([#2437](https://github.com/emilk/egui/pull/2437)).
+
+
+## 0.20.0 - 2022-12-08
+* Split out `ecolor` crate from `epaint`
diff --git a/egui/crates/ecolor/Cargo.toml b/egui/crates/ecolor/Cargo.toml
new file mode 100644
index 0000000..14f76ad
--- /dev/null
+++ b/egui/crates/ecolor/Cargo.toml
@@ -0,0 +1,50 @@
+[package]
+name = "ecolor"
+version = "0.21.0"
+authors = [
+  "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
+  "Andreas Reich <reichandreas@gmx.de>",
+]
+description = "Color structs and color conversion utilities"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui"
+categories = ["mathematics", "encoding"]
+keywords = ["gui", "color", "conversion", "gamedev", "images"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = []
+
+## Enable additional checks if debug assertions are enabled (debug builds).
+extra_debug_asserts = []
+## Always enable additional checks.
+extra_asserts = []
+
+
+[dependencies]
+#! ### Optional dependencies
+
+## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast `ecolor` types to `&[u8]`.
+bytemuck = { version = "1.7.2", optional = true, features = ["derive"] }
+
+## [`cint`](https://docs.rs/cint) enables interoperability with other color libraries.
+cint = { version = "0.3.1", optional = true }
+
+## Enable the [`hex_color`] macro.
+color-hex = { version = "0.2.0", optional = true }
+
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+## Allow serialization using [`serde`](https://docs.rs/serde).
+serde = { version = "1", optional = true, features = ["derive"] }
diff --git a/egui/crates/ecolor/README.md b/egui/crates/ecolor/README.md
new file mode 100644
index 0000000..4c84da0
--- /dev/null
+++ b/egui/crates/ecolor/README.md
@@ -0,0 +1,11 @@
+# ecolor - egui color library
+
+[![Latest version](https://img.shields.io/crates/v/ecolor.svg)](https://crates.io/crates/ecolor)
+[![Documentation](https://docs.rs/ecolor/badge.svg)](https://docs.rs/ecolor)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+A simple color storage and conversion library.
+
+Made for [`egui`](https://github.com/emilk/egui/).
diff --git a/egui/crates/ecolor/src/cint_impl.rs b/egui/crates/ecolor/src/cint_impl.rs
new file mode 100644
index 0000000..a730fda
--- /dev/null
+++ b/egui/crates/ecolor/src/cint_impl.rs
@@ -0,0 +1,161 @@
+use super::*;
+use cint::{Alpha, ColorInterop, EncodedSrgb, Hsv, LinearSrgb, PremultipliedAlpha};
+
+// ---- Color32 ----
+
+impl From<Alpha<EncodedSrgb<u8>>> for Color32 {
+    fn from(srgba: Alpha<EncodedSrgb<u8>>) -> Self {
+        let Alpha {
+            color: EncodedSrgb { r, g, b },
+            alpha: a,
+        } = srgba;
+
+        Color32::from_rgba_unmultiplied(r, g, b, a)
+    }
+}
+
+// No From<Color32> for Alpha<_> because Color32 is premultiplied
+
+impl From<PremultipliedAlpha<EncodedSrgb<u8>>> for Color32 {
+    fn from(srgba: PremultipliedAlpha<EncodedSrgb<u8>>) -> Self {
+        let PremultipliedAlpha {
+            color: EncodedSrgb { r, g, b },
+            alpha: a,
+        } = srgba;
+
+        Color32::from_rgba_premultiplied(r, g, b, a)
+    }
+}
+
+impl From<Color32> for PremultipliedAlpha<EncodedSrgb<u8>> {
+    fn from(col: Color32) -> Self {
+        let (r, g, b, a) = col.to_tuple();
+
+        PremultipliedAlpha {
+            color: EncodedSrgb { r, g, b },
+            alpha: a,
+        }
+    }
+}
+
+impl From<PremultipliedAlpha<EncodedSrgb<f32>>> for Color32 {
+    fn from(srgba: PremultipliedAlpha<EncodedSrgb<f32>>) -> Self {
+        let PremultipliedAlpha {
+            color: EncodedSrgb { r, g, b },
+            alpha: a,
+        } = srgba;
+
+        // This is a bit of an abuse of the function name but it does what we want.
+        let r = linear_u8_from_linear_f32(r);
+        let g = linear_u8_from_linear_f32(g);
+        let b = linear_u8_from_linear_f32(b);
+        let a = linear_u8_from_linear_f32(a);
+
+        Color32::from_rgba_premultiplied(r, g, b, a)
+    }
+}
+
+impl From<Color32> for PremultipliedAlpha<EncodedSrgb<f32>> {
+    fn from(col: Color32) -> Self {
+        let (r, g, b, a) = col.to_tuple();
+
+        // This is a bit of an abuse of the function name but it does what we want.
+        let r = linear_f32_from_linear_u8(r);
+        let g = linear_f32_from_linear_u8(g);
+        let b = linear_f32_from_linear_u8(b);
+        let a = linear_f32_from_linear_u8(a);
+
+        PremultipliedAlpha {
+            color: EncodedSrgb { r, g, b },
+            alpha: a,
+        }
+    }
+}
+
+impl ColorInterop for Color32 {
+    type CintTy = PremultipliedAlpha<EncodedSrgb<u8>>;
+}
+
+// ---- Rgba ----
+
+impl From<PremultipliedAlpha<LinearSrgb<f32>>> for Rgba {
+    fn from(srgba: PremultipliedAlpha<LinearSrgb<f32>>) -> Self {
+        let PremultipliedAlpha {
+            color: LinearSrgb { r, g, b },
+            alpha: a,
+        } = srgba;
+
+        Rgba([r, g, b, a])
+    }
+}
+
+impl From<Rgba> for PremultipliedAlpha<LinearSrgb<f32>> {
+    fn from(col: Rgba) -> Self {
+        let (r, g, b, a) = col.to_tuple();
+
+        PremultipliedAlpha {
+            color: LinearSrgb { r, g, b },
+            alpha: a,
+        }
+    }
+}
+
+impl ColorInterop for Rgba {
+    type CintTy = PremultipliedAlpha<LinearSrgb<f32>>;
+}
+
+// ---- Hsva ----
+
+impl From<Alpha<Hsv<f32>>> for Hsva {
+    fn from(srgba: Alpha<Hsv<f32>>) -> Self {
+        let Alpha {
+            color: Hsv { h, s, v },
+            alpha: a,
+        } = srgba;
+
+        Hsva::new(h, s, v, a)
+    }
+}
+
+impl From<Hsva> for Alpha<Hsv<f32>> {
+    fn from(col: Hsva) -> Self {
+        let Hsva { h, s, v, a } = col;
+
+        Alpha {
+            color: Hsv { h, s, v },
+            alpha: a,
+        }
+    }
+}
+
+impl ColorInterop for Hsva {
+    type CintTy = Alpha<Hsv<f32>>;
+}
+
+// ---- HsvaGamma ----
+
+impl ColorInterop for HsvaGamma {
+    type CintTy = Alpha<Hsv<f32>>;
+}
+
+impl From<Alpha<Hsv<f32>>> for HsvaGamma {
+    fn from(srgba: Alpha<Hsv<f32>>) -> Self {
+        let Alpha {
+            color: Hsv { h, s, v },
+            alpha: a,
+        } = srgba;
+
+        Hsva::new(h, s, v, a).into()
+    }
+}
+
+impl From<HsvaGamma> for Alpha<Hsv<f32>> {
+    fn from(col: HsvaGamma) -> Self {
+        let Hsva { h, s, v, a } = col.into();
+
+        Alpha {
+            color: Hsv { h, s, v },
+            alpha: a,
+        }
+    }
+}
diff --git a/egui/crates/ecolor/src/color32.rs b/egui/crates/ecolor/src/color32.rs
new file mode 100644
index 0000000..09e6811
--- /dev/null
+++ b/egui/crates/ecolor/src/color32.rs
@@ -0,0 +1,216 @@
+use crate::{gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8, Rgba};
+
+/// This format is used for space-efficient color representation (32 bits).
+///
+/// Instead of manipulating this directly it is often better
+/// to first convert it to either [`Rgba`] or [`crate::Hsva`].
+///
+/// Internally this uses 0-255 gamma space `sRGBA` color with premultiplied alpha.
+/// Alpha channel is in linear space.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Color32(pub(crate) [u8; 4]);
+
+impl std::ops::Index<usize> for Color32 {
+    type Output = u8;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &u8 {
+        &self.0[index]
+    }
+}
+
+impl std::ops::IndexMut<usize> for Color32 {
+    #[inline(always)]
+    fn index_mut(&mut self, index: usize) -> &mut u8 {
+        &mut self.0[index]
+    }
+}
+
+impl Color32 {
+    // Mostly follows CSS names:
+
+    pub const TRANSPARENT: Color32 = Color32::from_rgba_premultiplied(0, 0, 0, 0);
+    pub const BLACK: Color32 = Color32::from_rgb(0, 0, 0);
+    pub const DARK_GRAY: Color32 = Color32::from_rgb(96, 96, 96);
+    pub const GRAY: Color32 = Color32::from_rgb(160, 160, 160);
+    pub const LIGHT_GRAY: Color32 = Color32::from_rgb(220, 220, 220);
+    pub const WHITE: Color32 = Color32::from_rgb(255, 255, 255);
+
+    pub const BROWN: Color32 = Color32::from_rgb(165, 42, 42);
+    pub const DARK_RED: Color32 = Color32::from_rgb(0x8B, 0, 0);
+    pub const RED: Color32 = Color32::from_rgb(255, 0, 0);
+    pub const LIGHT_RED: Color32 = Color32::from_rgb(255, 128, 128);
+
+    pub const YELLOW: Color32 = Color32::from_rgb(255, 255, 0);
+    pub const LIGHT_YELLOW: Color32 = Color32::from_rgb(255, 255, 0xE0);
+    pub const KHAKI: Color32 = Color32::from_rgb(240, 230, 140);
+
+    pub const DARK_GREEN: Color32 = Color32::from_rgb(0, 0x64, 0);
+    pub const GREEN: Color32 = Color32::from_rgb(0, 255, 0);
+    pub const LIGHT_GREEN: Color32 = Color32::from_rgb(0x90, 0xEE, 0x90);
+
+    pub const DARK_BLUE: Color32 = Color32::from_rgb(0, 0, 0x8B);
+    pub const BLUE: Color32 = Color32::from_rgb(0, 0, 255);
+    pub const LIGHT_BLUE: Color32 = Color32::from_rgb(0xAD, 0xD8, 0xE6);
+
+    pub const GOLD: Color32 = Color32::from_rgb(255, 215, 0);
+
+    pub const DEBUG_COLOR: Color32 = Color32::from_rgba_premultiplied(0, 200, 0, 128);
+
+    /// An ugly color that is planned to be replaced before making it to the screen.
+    pub const TEMPORARY_COLOR: Color32 = Color32::from_rgb(64, 254, 0);
+
+    #[inline(always)]
+    pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
+        Self([r, g, b, 255])
+    }
+
+    #[inline(always)]
+    pub const fn from_rgb_additive(r: u8, g: u8, b: u8) -> Self {
+        Self([r, g, b, 0])
+    }
+
+    /// From `sRGBA` with premultiplied alpha.
+    #[inline(always)]
+    pub const fn from_rgba_premultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
+        Self([r, g, b, a])
+    }
+
+    /// From `sRGBA` WITHOUT premultiplied alpha.
+    pub fn from_rgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
+        if a == 255 {
+            Self::from_rgb(r, g, b) // common-case optimization
+        } else if a == 0 {
+            Self::TRANSPARENT // common-case optimization
+        } else {
+            let r_lin = linear_f32_from_gamma_u8(r);
+            let g_lin = linear_f32_from_gamma_u8(g);
+            let b_lin = linear_f32_from_gamma_u8(b);
+            let a_lin = linear_f32_from_linear_u8(a);
+
+            let r = gamma_u8_from_linear_f32(r_lin * a_lin);
+            let g = gamma_u8_from_linear_f32(g_lin * a_lin);
+            let b = gamma_u8_from_linear_f32(b_lin * a_lin);
+
+            Self::from_rgba_premultiplied(r, g, b, a)
+        }
+    }
+
+    #[inline(always)]
+    pub const fn from_gray(l: u8) -> Self {
+        Self([l, l, l, 255])
+    }
+
+    #[inline(always)]
+    pub const fn from_black_alpha(a: u8) -> Self {
+        Self([0, 0, 0, a])
+    }
+
+    pub fn from_white_alpha(a: u8) -> Self {
+        Rgba::from_white_alpha(linear_f32_from_linear_u8(a)).into()
+    }
+
+    #[inline(always)]
+    pub const fn from_additive_luminance(l: u8) -> Self {
+        Self([l, l, l, 0])
+    }
+
+    #[inline(always)]
+    pub const fn is_opaque(&self) -> bool {
+        self.a() == 255
+    }
+
+    #[inline(always)]
+    pub const fn r(&self) -> u8 {
+        self.0[0]
+    }
+
+    #[inline(always)]
+    pub const fn g(&self) -> u8 {
+        self.0[1]
+    }
+
+    #[inline(always)]
+    pub const fn b(&self) -> u8 {
+        self.0[2]
+    }
+
+    #[inline(always)]
+    pub const fn a(&self) -> u8 {
+        self.0[3]
+    }
+
+    /// Returns an opaque version of self
+    pub fn to_opaque(self) -> Self {
+        Rgba::from(self).to_opaque().into()
+    }
+
+    /// Returns an additive version of self
+    #[inline(always)]
+    pub const fn additive(self) -> Self {
+        let [r, g, b, _] = self.to_array();
+        Self([r, g, b, 0])
+    }
+
+    /// Premultiplied RGBA
+    #[inline(always)]
+    pub const fn to_array(&self) -> [u8; 4] {
+        [self.r(), self.g(), self.b(), self.a()]
+    }
+
+    /// Premultiplied RGBA
+    #[inline(always)]
+    pub const fn to_tuple(&self) -> (u8, u8, u8, u8) {
+        (self.r(), self.g(), self.b(), self.a())
+    }
+
+    pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
+        Rgba::from(*self).to_srgba_unmultiplied()
+    }
+
+    /// Multiply with 0.5 to make color half as opaque, perceptually.
+    ///
+    /// Fast multiplication in gamma-space.
+    ///
+    /// This is perceptually even, and faster that [`Self::linear_multiply`].
+    #[inline]
+    pub fn gamma_multiply(self, factor: f32) -> Color32 {
+        crate::ecolor_assert!(0.0 <= factor && factor <= 1.0);
+        let Self([r, g, b, a]) = self;
+        Self([
+            (r as f32 * factor + 0.5) as u8,
+            (g as f32 * factor + 0.5) as u8,
+            (b as f32 * factor + 0.5) as u8,
+            (a as f32 * factor + 0.5) as u8,
+        ])
+    }
+
+    /// Multiply with 0.5 to make color half as opaque in linear space.
+    ///
+    /// This is using linear space, which is not perceptually even.
+    /// You may want to use [`Self::gamma_multiply`] instead.
+    pub fn linear_multiply(self, factor: f32) -> Color32 {
+        crate::ecolor_assert!(0.0 <= factor && factor <= 1.0);
+        // As an unfortunate side-effect of using premultiplied alpha
+        // we need a somewhat expensive conversion to linear space and back.
+        Rgba::from(self).multiply(factor).into()
+    }
+
+    /// Converts to floating point values in the range 0-1 without any gamma space conversion.
+    ///
+    /// Use this with great care! In almost all cases, you want to convert to [`crate::Rgba`] instead
+    /// in order to obtain linear space color values.
+    #[inline]
+    pub fn to_normalized_gamma_f32(self) -> [f32; 4] {
+        let Self([r, g, b, a]) = self;
+        [
+            r as f32 / 255.0,
+            g as f32 / 255.0,
+            b as f32 / 255.0,
+            a as f32 / 255.0,
+        ]
+    }
+}
diff --git a/egui/crates/ecolor/src/hex_color_macro.rs b/egui/crates/ecolor/src/hex_color_macro.rs
new file mode 100644
index 0000000..450e6a8
--- /dev/null
+++ b/egui/crates/ecolor/src/hex_color_macro.rs
@@ -0,0 +1,39 @@
+/// Construct a [`crate::Color32`] from a hex RGB or RGBA string.
+///
+/// ```
+/// # use ecolor::{hex_color, Color32};
+/// assert_eq!(hex_color!("#202122"), Color32::from_rgb(0x20, 0x21, 0x22));
+/// assert_eq!(hex_color!("#abcdef12"), Color32::from_rgba_unmultiplied(0xab, 0xcd, 0xef, 0x12));
+/// ```
+#[macro_export]
+macro_rules! hex_color {
+    ($s:literal) => {{
+        let array = color_hex::color_from_hex!($s);
+        if array.len() == 3 {
+            $crate::Color32::from_rgb(array[0], array[1], array[2])
+        } else {
+            #[allow(unconditional_panic)]
+            $crate::Color32::from_rgba_unmultiplied(array[0], array[1], array[2], array[3])
+        }
+    }};
+}
+
+#[test]
+fn test_from_rgb_hex() {
+    assert_eq!(
+        crate::Color32::from_rgb(0x20, 0x21, 0x22),
+        hex_color!("#202122")
+    );
+    assert_eq!(
+        crate::Color32::from_rgb_additive(0x20, 0x21, 0x22),
+        hex_color!("#202122").additive()
+    );
+}
+
+#[test]
+fn test_from_rgba_hex() {
+    assert_eq!(
+        crate::Color32::from_rgba_unmultiplied(0x20, 0x21, 0x22, 0x50),
+        hex_color!("20212250")
+    );
+}
diff --git a/egui/crates/ecolor/src/hsva.rs b/egui/crates/ecolor/src/hsva.rs
new file mode 100644
index 0000000..8a68cb9
--- /dev/null
+++ b/egui/crates/ecolor/src/hsva.rs
@@ -0,0 +1,231 @@
+use crate::{
+    gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8,
+    linear_u8_from_linear_f32, Color32, Rgba,
+};
+
+/// Hue, saturation, value, alpha. All in the range [0, 1].
+/// No premultiplied alpha.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Hsva {
+    /// hue 0-1
+    pub h: f32,
+
+    /// saturation 0-1
+    pub s: f32,
+
+    /// value 0-1
+    pub v: f32,
+
+    /// alpha 0-1. A negative value signifies an additive color (and alpha is ignored).
+    pub a: f32,
+}
+
+impl Hsva {
+    pub fn new(h: f32, s: f32, v: f32, a: f32) -> Self {
+        Self { h, s, v, a }
+    }
+
+    /// From `sRGBA` with premultiplied alpha
+    pub fn from_srgba_premultiplied(srgba: [u8; 4]) -> Self {
+        Self::from_rgba_premultiplied(
+            linear_f32_from_gamma_u8(srgba[0]),
+            linear_f32_from_gamma_u8(srgba[1]),
+            linear_f32_from_gamma_u8(srgba[2]),
+            linear_f32_from_linear_u8(srgba[3]),
+        )
+    }
+
+    /// From `sRGBA` without premultiplied alpha
+    pub fn from_srgba_unmultiplied(srgba: [u8; 4]) -> Self {
+        Self::from_rgba_unmultiplied(
+            linear_f32_from_gamma_u8(srgba[0]),
+            linear_f32_from_gamma_u8(srgba[1]),
+            linear_f32_from_gamma_u8(srgba[2]),
+            linear_f32_from_linear_u8(srgba[3]),
+        )
+    }
+
+    /// From linear RGBA with premultiplied alpha
+    pub fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
+        #![allow(clippy::many_single_char_names)]
+        if a == 0.0 {
+            if r == 0.0 && b == 0.0 && a == 0.0 {
+                Hsva::default()
+            } else {
+                Hsva::from_additive_rgb([r, g, b])
+            }
+        } else {
+            let (h, s, v) = hsv_from_rgb([r / a, g / a, b / a]);
+            Hsva { h, s, v, a }
+        }
+    }
+
+    /// From linear RGBA without premultiplied alpha
+    pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
+        #![allow(clippy::many_single_char_names)]
+        let (h, s, v) = hsv_from_rgb([r, g, b]);
+        Hsva { h, s, v, a }
+    }
+
+    pub fn from_additive_rgb(rgb: [f32; 3]) -> Self {
+        let (h, s, v) = hsv_from_rgb(rgb);
+        Hsva {
+            h,
+            s,
+            v,
+            a: -0.5, // anything negative is treated as additive
+        }
+    }
+
+    pub fn from_rgb(rgb: [f32; 3]) -> Self {
+        let (h, s, v) = hsv_from_rgb(rgb);
+        Hsva { h, s, v, a: 1.0 }
+    }
+
+    pub fn from_srgb([r, g, b]: [u8; 3]) -> Self {
+        Self::from_rgb([
+            linear_f32_from_gamma_u8(r),
+            linear_f32_from_gamma_u8(g),
+            linear_f32_from_gamma_u8(b),
+        ])
+    }
+
+    // ------------------------------------------------------------------------
+
+    pub fn to_opaque(self) -> Self {
+        Self { a: 1.0, ..self }
+    }
+
+    pub fn to_rgb(&self) -> [f32; 3] {
+        rgb_from_hsv((self.h, self.s, self.v))
+    }
+
+    pub fn to_srgb(&self) -> [u8; 3] {
+        let [r, g, b] = self.to_rgb();
+        [
+            gamma_u8_from_linear_f32(r),
+            gamma_u8_from_linear_f32(g),
+            gamma_u8_from_linear_f32(b),
+        ]
+    }
+
+    pub fn to_rgba_premultiplied(&self) -> [f32; 4] {
+        let [r, g, b, a] = self.to_rgba_unmultiplied();
+        let additive = a < 0.0;
+        if additive {
+            [r, g, b, 0.0]
+        } else {
+            [a * r, a * g, a * b, a]
+        }
+    }
+
+    /// Represents additive colors using a negative alpha.
+    pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
+        let Hsva { h, s, v, a } = *self;
+        let [r, g, b] = rgb_from_hsv((h, s, v));
+        [r, g, b, a]
+    }
+
+    pub fn to_srgba_premultiplied(&self) -> [u8; 4] {
+        let [r, g, b, a] = self.to_rgba_premultiplied();
+        [
+            gamma_u8_from_linear_f32(r),
+            gamma_u8_from_linear_f32(g),
+            gamma_u8_from_linear_f32(b),
+            linear_u8_from_linear_f32(a),
+        ]
+    }
+
+    pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
+        let [r, g, b, a] = self.to_rgba_unmultiplied();
+        [
+            gamma_u8_from_linear_f32(r),
+            gamma_u8_from_linear_f32(g),
+            gamma_u8_from_linear_f32(b),
+            linear_u8_from_linear_f32(a.abs()),
+        ]
+    }
+}
+
+impl From<Hsva> for Rgba {
+    fn from(hsva: Hsva) -> Rgba {
+        Rgba(hsva.to_rgba_premultiplied())
+    }
+}
+
+impl From<Rgba> for Hsva {
+    fn from(rgba: Rgba) -> Hsva {
+        Self::from_rgba_premultiplied(rgba.0[0], rgba.0[1], rgba.0[2], rgba.0[3])
+    }
+}
+
+impl From<Hsva> for Color32 {
+    fn from(hsva: Hsva) -> Color32 {
+        Color32::from(Rgba::from(hsva))
+    }
+}
+
+impl From<Color32> for Hsva {
+    fn from(srgba: Color32) -> Hsva {
+        Hsva::from(Rgba::from(srgba))
+    }
+}
+
+/// All ranges in 0-1, rgb is linear.
+pub fn hsv_from_rgb([r, g, b]: [f32; 3]) -> (f32, f32, f32) {
+    #![allow(clippy::many_single_char_names)]
+    let min = r.min(g.min(b));
+    let max = r.max(g.max(b)); // value
+
+    let range = max - min;
+
+    let h = if max == min {
+        0.0 // hue is undefined
+    } else if max == r {
+        (g - b) / (6.0 * range)
+    } else if max == g {
+        (b - r) / (6.0 * range) + 1.0 / 3.0
+    } else {
+        // max == b
+        (r - g) / (6.0 * range) + 2.0 / 3.0
+    };
+    let h = (h + 1.0).fract(); // wrap
+    let s = if max == 0.0 { 0.0 } else { 1.0 - min / max };
+    (h, s, max)
+}
+
+/// All ranges in 0-1, rgb is linear.
+pub fn rgb_from_hsv((h, s, v): (f32, f32, f32)) -> [f32; 3] {
+    #![allow(clippy::many_single_char_names)]
+    let h = (h.fract() + 1.0).fract(); // wrap
+    let s = s.clamp(0.0, 1.0);
+
+    let f = h * 6.0 - (h * 6.0).floor();
+    let p = v * (1.0 - s);
+    let q = v * (1.0 - f * s);
+    let t = v * (1.0 - (1.0 - f) * s);
+
+    match (h * 6.0).floor() as i32 % 6 {
+        0 => [v, t, p],
+        1 => [q, v, p],
+        2 => [p, v, t],
+        3 => [p, q, v],
+        4 => [t, p, v],
+        5 => [v, p, q],
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+#[ignore] // a bit expensive
+fn test_hsv_roundtrip() {
+    for r in 0..=255 {
+        for g in 0..=255 {
+            for b in 0..=255 {
+                let srgba = Color32::from_rgb(r, g, b);
+                let hsva = Hsva::from(srgba);
+                assert_eq!(srgba, Color32::from(hsva));
+            }
+        }
+    }
+}
diff --git a/egui/crates/ecolor/src/hsva_gamma.rs b/egui/crates/ecolor/src/hsva_gamma.rs
new file mode 100644
index 0000000..3135ef1
--- /dev/null
+++ b/egui/crates/ecolor/src/hsva_gamma.rs
@@ -0,0 +1,66 @@
+use crate::{gamma_from_linear, linear_from_gamma, Color32, Hsva, Rgba};
+
+/// Like Hsva but with the `v` value (brightness) being gamma corrected
+/// so that it is somewhat perceptually even.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct HsvaGamma {
+    /// hue 0-1
+    pub h: f32,
+
+    /// saturation 0-1
+    pub s: f32,
+
+    /// value 0-1, in gamma-space (~perceptually even)
+    pub v: f32,
+
+    /// alpha 0-1. A negative value signifies an additive color (and alpha is ignored).
+    pub a: f32,
+}
+
+impl From<HsvaGamma> for Rgba {
+    fn from(hsvag: HsvaGamma) -> Rgba {
+        Hsva::from(hsvag).into()
+    }
+}
+
+impl From<HsvaGamma> for Color32 {
+    fn from(hsvag: HsvaGamma) -> Color32 {
+        Rgba::from(hsvag).into()
+    }
+}
+
+impl From<HsvaGamma> for Hsva {
+    fn from(hsvag: HsvaGamma) -> Hsva {
+        let HsvaGamma { h, s, v, a } = hsvag;
+        Hsva {
+            h,
+            s,
+            v: linear_from_gamma(v),
+            a,
+        }
+    }
+}
+
+impl From<Rgba> for HsvaGamma {
+    fn from(rgba: Rgba) -> HsvaGamma {
+        Hsva::from(rgba).into()
+    }
+}
+
+impl From<Color32> for HsvaGamma {
+    fn from(srgba: Color32) -> HsvaGamma {
+        Hsva::from(srgba).into()
+    }
+}
+
+impl From<Hsva> for HsvaGamma {
+    fn from(hsva: Hsva) -> HsvaGamma {
+        let Hsva { h, s, v, a } = hsva;
+        HsvaGamma {
+            h,
+            s,
+            v: gamma_from_linear(v),
+            a,
+        }
+    }
+}
diff --git a/egui/crates/ecolor/src/lib.rs b/egui/crates/ecolor/src/lib.rs
new file mode 100644
index 0000000..9bc42c4
--- /dev/null
+++ b/egui/crates/ecolor/src/lib.rs
@@ -0,0 +1,173 @@
+//! Color conversions and types.
+//!
+//! If you want a compact color representation, use [`Color32`].
+//! If you want to manipulate RGBA colors use [`Rgba`].
+//! If you want to manipulate colors in a way closer to how humans think about colors, use [`HsvaGamma`].
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::wrong_self_convention)]
+
+#[cfg(feature = "cint")]
+mod cint_impl;
+#[cfg(feature = "cint")]
+pub use cint_impl::*;
+
+mod color32;
+pub use color32::*;
+
+mod hsva_gamma;
+pub use hsva_gamma::*;
+
+mod hsva;
+pub use hsva::*;
+
+#[cfg(feature = "color-hex")]
+mod hex_color_macro;
+
+mod rgba;
+pub use rgba::*;
+
+// ----------------------------------------------------------------------------
+// Color conversion:
+
+impl From<Color32> for Rgba {
+    fn from(srgba: Color32) -> Rgba {
+        Rgba([
+            linear_f32_from_gamma_u8(srgba.0[0]),
+            linear_f32_from_gamma_u8(srgba.0[1]),
+            linear_f32_from_gamma_u8(srgba.0[2]),
+            linear_f32_from_linear_u8(srgba.0[3]),
+        ])
+    }
+}
+
+impl From<Rgba> for Color32 {
+    fn from(rgba: Rgba) -> Color32 {
+        Color32([
+            gamma_u8_from_linear_f32(rgba.0[0]),
+            gamma_u8_from_linear_f32(rgba.0[1]),
+            gamma_u8_from_linear_f32(rgba.0[2]),
+            linear_u8_from_linear_f32(rgba.0[3]),
+        ])
+    }
+}
+
+/// gamma [0, 255] -> linear [0, 1].
+pub fn linear_f32_from_gamma_u8(s: u8) -> f32 {
+    if s <= 10 {
+        s as f32 / 3294.6
+    } else {
+        ((s as f32 + 14.025) / 269.025).powf(2.4)
+    }
+}
+
+/// linear [0, 255] -> linear [0, 1].
+/// Useful for alpha-channel.
+#[inline(always)]
+pub fn linear_f32_from_linear_u8(a: u8) -> f32 {
+    a as f32 / 255.0
+}
+
+/// linear [0, 1] -> gamma [0, 255] (clamped).
+/// Values outside this range will be clamped to the range.
+pub fn gamma_u8_from_linear_f32(l: f32) -> u8 {
+    if l <= 0.0 {
+        0
+    } else if l <= 0.0031308 {
+        fast_round(3294.6 * l)
+    } else if l <= 1.0 {
+        fast_round(269.025 * l.powf(1.0 / 2.4) - 14.025)
+    } else {
+        255
+    }
+}
+
+/// linear [0, 1] -> linear [0, 255] (clamped).
+/// Useful for alpha-channel.
+#[inline(always)]
+pub fn linear_u8_from_linear_f32(a: f32) -> u8 {
+    fast_round(a * 255.0)
+}
+
+fn fast_round(r: f32) -> u8 {
+    (r + 0.5).floor() as _ // rust does a saturating cast since 1.45
+}
+
+#[test]
+pub fn test_srgba_conversion() {
+    for b in 0..=255 {
+        let l = linear_f32_from_gamma_u8(b);
+        assert!(0.0 <= l && l <= 1.0);
+        assert_eq!(gamma_u8_from_linear_f32(l), b);
+    }
+}
+
+/// gamma [0, 1] -> linear [0, 1] (not clamped).
+/// Works for numbers outside this range (e.g. negative numbers).
+pub fn linear_from_gamma(gamma: f32) -> f32 {
+    if gamma < 0.0 {
+        -linear_from_gamma(-gamma)
+    } else if gamma <= 0.04045 {
+        gamma / 12.92
+    } else {
+        ((gamma + 0.055) / 1.055).powf(2.4)
+    }
+}
+
+/// linear [0, 1] -> gamma [0, 1] (not clamped).
+/// Works for numbers outside this range (e.g. negative numbers).
+pub fn gamma_from_linear(linear: f32) -> f32 {
+    if linear < 0.0 {
+        -gamma_from_linear(-linear)
+    } else if linear <= 0.0031308 {
+        12.92 * linear
+    } else {
+        1.055 * linear.powf(1.0 / 2.4) - 0.055
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// An assert that is only active when `epaint` is compiled with the `extra_asserts` feature
+/// or with the `extra_debug_asserts` feature in debug builds.
+#[macro_export]
+macro_rules! ecolor_assert {
+    ($($arg: tt)*) => {
+        if cfg!(any(
+            feature = "extra_asserts",
+            all(feature = "extra_debug_asserts", debug_assertions),
+        )) {
+            assert!($($arg)*);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Cheap and ugly.
+/// Made for graying out disabled `Ui`s.
+pub fn tint_color_towards(color: Color32, target: Color32) -> Color32 {
+    let [mut r, mut g, mut b, mut a] = color.to_array();
+
+    if a == 0 {
+        r /= 2;
+        g /= 2;
+        b /= 2;
+    } else if a < 170 {
+        // Cheapish and looks ok.
+        // Works for e.g. grid stripes.
+        let div = (2 * 255 / a as i32) as u8;
+        r = r / 2 + target.r() / div;
+        g = g / 2 + target.g() / div;
+        b = b / 2 + target.b() / div;
+        a /= 2;
+    } else {
+        r = r / 2 + target.r() / 2;
+        g = g / 2 + target.g() / 2;
+        b = b / 2 + target.b() / 2;
+    }
+    Color32::from_rgba_premultiplied(r, g, b, a)
+}
diff --git a/egui/crates/ecolor/src/rgba.rs b/egui/crates/ecolor/src/rgba.rs
new file mode 100644
index 0000000..f9d671f
--- /dev/null
+++ b/egui/crates/ecolor/src/rgba.rs
@@ -0,0 +1,266 @@
+use crate::{
+    gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8,
+    linear_u8_from_linear_f32,
+};
+
+/// 0-1 linear space `RGBA` color with premultiplied alpha.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Rgba(pub(crate) [f32; 4]);
+
+impl std::ops::Index<usize> for Rgba {
+    type Output = f32;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &f32 {
+        &self.0[index]
+    }
+}
+
+impl std::ops::IndexMut<usize> for Rgba {
+    #[inline(always)]
+    fn index_mut(&mut self, index: usize) -> &mut f32 {
+        &mut self.0[index]
+    }
+}
+
+#[inline(always)]
+pub(crate) fn f32_hash<H: std::hash::Hasher>(state: &mut H, f: f32) {
+    if f == 0.0 {
+        state.write_u8(0);
+    } else if f.is_nan() {
+        state.write_u8(1);
+    } else {
+        use std::hash::Hash;
+        f.to_bits().hash(state);
+    }
+}
+
+#[allow(clippy::derive_hash_xor_eq)]
+impl std::hash::Hash for Rgba {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        crate::f32_hash(state, self.0[0]);
+        crate::f32_hash(state, self.0[1]);
+        crate::f32_hash(state, self.0[2]);
+        crate::f32_hash(state, self.0[3]);
+    }
+}
+
+impl Rgba {
+    pub const TRANSPARENT: Rgba = Rgba::from_rgba_premultiplied(0.0, 0.0, 0.0, 0.0);
+    pub const BLACK: Rgba = Rgba::from_rgb(0.0, 0.0, 0.0);
+    pub const WHITE: Rgba = Rgba::from_rgb(1.0, 1.0, 1.0);
+    pub const RED: Rgba = Rgba::from_rgb(1.0, 0.0, 0.0);
+    pub const GREEN: Rgba = Rgba::from_rgb(0.0, 1.0, 0.0);
+    pub const BLUE: Rgba = Rgba::from_rgb(0.0, 0.0, 1.0);
+
+    #[inline(always)]
+    pub const fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
+        Self([r, g, b, a])
+    }
+
+    #[inline(always)]
+    pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
+        Self([r * a, g * a, b * a, a])
+    }
+
+    #[inline(always)]
+    pub fn from_srgba_premultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
+        let r = linear_f32_from_gamma_u8(r);
+        let g = linear_f32_from_gamma_u8(g);
+        let b = linear_f32_from_gamma_u8(b);
+        let a = linear_f32_from_linear_u8(a);
+        Self::from_rgba_premultiplied(r, g, b, a)
+    }
+
+    #[inline(always)]
+    pub fn from_srgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
+        let r = linear_f32_from_gamma_u8(r);
+        let g = linear_f32_from_gamma_u8(g);
+        let b = linear_f32_from_gamma_u8(b);
+        let a = linear_f32_from_linear_u8(a);
+        Self::from_rgba_premultiplied(r * a, g * a, b * a, a)
+    }
+
+    #[inline(always)]
+    pub const fn from_rgb(r: f32, g: f32, b: f32) -> Self {
+        Self([r, g, b, 1.0])
+    }
+
+    #[inline(always)]
+    pub const fn from_gray(l: f32) -> Self {
+        Self([l, l, l, 1.0])
+    }
+
+    pub fn from_luminance_alpha(l: f32, a: f32) -> Self {
+        crate::ecolor_assert!(0.0 <= l && l <= 1.0);
+        crate::ecolor_assert!(0.0 <= a && a <= 1.0);
+        Self([l * a, l * a, l * a, a])
+    }
+
+    /// Transparent black
+    #[inline(always)]
+    pub fn from_black_alpha(a: f32) -> Self {
+        crate::ecolor_assert!(0.0 <= a && a <= 1.0);
+        Self([0.0, 0.0, 0.0, a])
+    }
+
+    /// Transparent white
+    #[inline(always)]
+    pub fn from_white_alpha(a: f32) -> Self {
+        crate::ecolor_assert!(0.0 <= a && a <= 1.0, "a: {}", a);
+        Self([a, a, a, a])
+    }
+
+    /// Return an additive version of this color (alpha = 0)
+    #[inline(always)]
+    pub fn additive(self) -> Self {
+        let [r, g, b, _] = self.0;
+        Self([r, g, b, 0.0])
+    }
+
+    /// Multiply with e.g. 0.5 to make us half transparent
+    #[inline(always)]
+    pub fn multiply(self, alpha: f32) -> Self {
+        Self([
+            alpha * self[0],
+            alpha * self[1],
+            alpha * self[2],
+            alpha * self[3],
+        ])
+    }
+
+    #[inline(always)]
+    pub fn r(&self) -> f32 {
+        self.0[0]
+    }
+
+    #[inline(always)]
+    pub fn g(&self) -> f32 {
+        self.0[1]
+    }
+
+    #[inline(always)]
+    pub fn b(&self) -> f32 {
+        self.0[2]
+    }
+
+    #[inline(always)]
+    pub fn a(&self) -> f32 {
+        self.0[3]
+    }
+
+    /// How perceptually intense (bright) is the color?
+    #[inline]
+    pub fn intensity(&self) -> f32 {
+        0.3 * self.r() + 0.59 * self.g() + 0.11 * self.b()
+    }
+
+    /// Returns an opaque version of self
+    pub fn to_opaque(&self) -> Self {
+        if self.a() == 0.0 {
+            // Additive or fully transparent black.
+            Self::from_rgb(self.r(), self.g(), self.b())
+        } else {
+            // un-multiply alpha:
+            Self::from_rgb(
+                self.r() / self.a(),
+                self.g() / self.a(),
+                self.b() / self.a(),
+            )
+        }
+    }
+
+    /// Premultiplied RGBA
+    #[inline(always)]
+    pub fn to_array(&self) -> [f32; 4] {
+        [self.r(), self.g(), self.b(), self.a()]
+    }
+
+    /// Premultiplied RGBA
+    #[inline(always)]
+    pub fn to_tuple(&self) -> (f32, f32, f32, f32) {
+        (self.r(), self.g(), self.b(), self.a())
+    }
+
+    /// unmultiply the alpha
+    pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
+        let a = self.a();
+        if a == 0.0 {
+            // Additive, let's assume we are black
+            self.0
+        } else {
+            [self.r() / a, self.g() / a, self.b() / a, a]
+        }
+    }
+
+    /// unmultiply the alpha
+    pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
+        let [r, g, b, a] = self.to_rgba_unmultiplied();
+        [
+            gamma_u8_from_linear_f32(r),
+            gamma_u8_from_linear_f32(g),
+            gamma_u8_from_linear_f32(b),
+            linear_u8_from_linear_f32(a.abs()),
+        ]
+    }
+}
+
+impl std::ops::Add for Rgba {
+    type Output = Rgba;
+
+    #[inline(always)]
+    fn add(self, rhs: Rgba) -> Rgba {
+        Rgba([
+            self[0] + rhs[0],
+            self[1] + rhs[1],
+            self[2] + rhs[2],
+            self[3] + rhs[3],
+        ])
+    }
+}
+
+impl std::ops::Mul<Rgba> for Rgba {
+    type Output = Rgba;
+
+    #[inline(always)]
+    fn mul(self, other: Rgba) -> Rgba {
+        Rgba([
+            self[0] * other[0],
+            self[1] * other[1],
+            self[2] * other[2],
+            self[3] * other[3],
+        ])
+    }
+}
+
+impl std::ops::Mul<f32> for Rgba {
+    type Output = Rgba;
+
+    #[inline(always)]
+    fn mul(self, factor: f32) -> Rgba {
+        Rgba([
+            self[0] * factor,
+            self[1] * factor,
+            self[2] * factor,
+            self[3] * factor,
+        ])
+    }
+}
+
+impl std::ops::Mul<Rgba> for f32 {
+    type Output = Rgba;
+
+    #[inline(always)]
+    fn mul(self, rgba: Rgba) -> Rgba {
+        Rgba([
+            self * rgba[0],
+            self * rgba[1],
+            self * rgba[2],
+            self * rgba[3],
+        ])
+    }
+}
diff --git a/egui/crates/eframe/CHANGELOG.md b/egui/crates/eframe/CHANGELOG.md
new file mode 100644
index 0000000..d50d667
--- /dev/null
+++ b/egui/crates/eframe/CHANGELOG.md
@@ -0,0 +1,235 @@
+# Changelog for eframe
+All notable changes to the `eframe` crate.
+
+NOTE: [`egui-winit`](../egui-winit/CHANGELOG.md), [`egui_glium`](../egui_glium/CHANGELOG.md), [`egui_glow`](../egui_glow/CHANGELOG.md),and [`egui-wgpu`](../egui-wgpu/CHANGELOG.md) have their own changelogs!
+
+
+## Unreleased
+#### Desktop/Native:
+* Add `Frame::request_screenshot` and `Frame::screenshot` to communicate to the backend that a screenshot of the current frame should be exposed by `Frame` during `App::post_rendering` ([#2676](https://github.com/emilk/egui/pull/2676)).
+* Add `eframe::run_simple_native` - a simple API for simple apps ([#2453](https://github.com/emilk/egui/pull/2453)).
+* Fix bug where the eframe window is never destroyed on Linux when using `run_and_return` ([#2892](https://github.com/emilk/egui/issues/2892))
+
+#### Web:
+* Bug fix: modifiers keys getting stuck on alt-tab ([#2857](https://github.com/emilk/egui/pull/2857)).
+
+## 0.21.3 - 2023-02-15
+* Fix typing the letter 'P' on web ([#2740](https://github.com/emilk/egui/pull/2740)).
+
+
+## 0.21.2 - 2023-02-12
+* Allow compiling `eframe` with `--no-default-features` ([#2728](https://github.com/emilk/egui/pull/2728)).
+
+
+## 0.21.1 - 2023-02-12
+* Fixed crash when native window position is in an invalid state, which could happen e.g. due to changes in monitor size or DPI ([#2722](https://github.com/emilk/egui/issues/2722)).
+
+
+## 0.21.0 - 2023-02-08 - Update to `winit` 0.28
+* ⚠️ BREAKING: `App::clear_color` now expects you to return a raw float array ([#2666](https://github.com/emilk/egui/pull/2666)).
+* The `screen_reader` feature has now been renamed `web_screen_reader` and only work on web. On other platforms, use the `accesskit` feature flag instead ([#2669](https://github.com/emilk/egui/pull/2669)).
+
+#### Desktop/Native:
+* `eframe::run_native` now returns a `Result` ([#2433](https://github.com/emilk/egui/pull/2433)).
+* Update to `winit` 0.28, adding support for mac trackpad zoom ([#2654](https://github.com/emilk/egui/pull/2654)).
+* Fix bug where the cursor could get stuck using the wrong icon.
+* `NativeOptions::transparent` now works with the wgpu backend ([#2684](https://github.com/emilk/egui/pull/2684)).
+* Add `Frame::set_minimized` and `set_maximized` ([#2292](https://github.com/emilk/egui/pull/2292), [#2672](https://github.com/emilk/egui/pull/2672)).
+* Fixed persistence of native window position on Windows OS ([#2583](https://github.com/emilk/egui/issues/2583)).
+
+#### Web:
+* Prevent ctrl-P/cmd-P from opening the print dialog ([#2598](https://github.com/emilk/egui/pull/2598)).
+
+
+## 0.20.1 - 2022-12-11
+* Fix [docs.rs](https://docs.rs/eframe) build ([#2420](https://github.com/emilk/egui/pull/2420)).
+
+
+## 0.20.0 - 2022-12-08 - AccessKit integration and `wgpu` web support
+* MSRV (Minimum Supported Rust Version) is now `1.65.0` ([#2314](https://github.com/emilk/egui/pull/2314)).
+* Allow empty textures with the glow renderer.
+
+#### Desktop/Native:
+* Don't repaint when just moving window ([#1980](https://github.com/emilk/egui/pull/1980)).
+* Added `NativeOptions::event_loop_builder` hook for apps to change platform specific event loop options ([#1952](https://github.com/emilk/egui/pull/1952)).
+* Enabled deferred render state initialization to support Android ([#1952](https://github.com/emilk/egui/pull/1952)).
+* Added `shader_version` to `NativeOptions` for cross compiling support on different target OpenGL | ES versions (on native `glow` renderer only) ([#1993](https://github.com/emilk/egui/pull/1993)).
+* Fix: app state is now saved when user presses Cmd-Q on Mac ([#2013](https://github.com/emilk/egui/pull/2013)).
+* Added `center` to `NativeOptions` and `monitor_size` to `WindowInfo` on desktop ([#2035](https://github.com/emilk/egui/pull/2035)).
+* Improve IME support ([#2046](https://github.com/emilk/egui/pull/2046)).
+* Added mouse-passthrough option ([#2080](https://github.com/emilk/egui/pull/2080)).
+* Added `NativeOptions::fullsize_content` option on Mac to build titlebar-less windows with floating window controls ([#2049](https://github.com/emilk/egui/pull/2049)).
+* Wgpu device/adapter/surface creation has now various configuration options exposed via `NativeOptions/WebOptions::wgpu_options` ([#2207](https://github.com/emilk/egui/pull/2207)).
+* Fix: Make sure that `native_pixels_per_point` is updated ([#2256](https://github.com/emilk/egui/pull/2256)).
+* Added optional, but enabled by default, integration with [AccessKit](https://accesskit.dev/) for implementing platform accessibility APIs ([#2294](https://github.com/emilk/egui/pull/2294)).
+* Fix: Less flickering on resize on Windows ([#2280](https://github.com/emilk/egui/pull/2280)).
+
+#### Web:
+* ⚠️ BREAKING: `start_web` is a now `async` ([#2107](https://github.com/emilk/egui/pull/2107)).
+* Web: You can now use WebGL on top of `wgpu` by enabling the `wgpu` feature (and disabling `glow` via disabling default features) ([#2107](https://github.com/emilk/egui/pull/2107)).
+* Web: Add `WebInfo::user_agent` ([#2202](https://github.com/emilk/egui/pull/2202)).
+* Web: you can access your application from JS using `AppRunner::app_mut`. See `crates/egui_demo_app/src/lib.rs` ([#1886](https://github.com/emilk/egui/pull/1886)).
+
+
+## 0.19.0 - 2022-08-20
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* Added `wgpu` rendering backed ([#1564](https://github.com/emilk/egui/pull/1564)):
+  * Added features `wgpu` and `glow`.
+  * Added `NativeOptions::renderer` to switch between the rendering backends.
+* `egui_glow`: remove calls to `gl.get_error` in release builds to speed up rendering ([#1583](https://github.com/emilk/egui/pull/1583)).
+* Added `App::post_rendering` for e.g. reading the framebuffer ([#1591](https://github.com/emilk/egui/pull/1591)).
+* Use `Arc` for `glow::Context` instead of `Rc` ([#1640](https://github.com/emilk/egui/pull/1640)).
+* Fixed bug where the result returned from `App::on_exit_event` would sometimes be ignored ([#1696](https://github.com/emilk/egui/pull/1696)).
+* Added `NativeOptions::follow_system_theme` and `NativeOptions::default_theme` ([#1726](https://github.com/emilk/egui/pull/1726)).
+* Selectively expose parts of the API based on target arch (`wasm32` or not) ([#1867](https://github.com/emilk/egui/pull/1867)).
+
+#### Desktop/Native:
+* Fixed clipboard on Wayland ([#1613](https://github.com/emilk/egui/pull/1613)).
+* Added ability to read window position and size with `frame.info().window_info` ([#1617](https://github.com/emilk/egui/pull/1617)).
+* Allow running on native without hardware accelerated rendering. Change with `NativeOptions::hardware_acceleration` ([#1681](https://github.com/emilk/egui/pull/1681), [#1693](https://github.com/emilk/egui/pull/1693)).
+* Fixed window position persistence ([#1745](https://github.com/emilk/egui/pull/1745)).
+* Fixed mouse cursor change on Linux ([#1747](https://github.com/emilk/egui/pull/1747)).
+* Added `Frame::set_visible` ([#1808](https://github.com/emilk/egui/pull/1808)).
+* Added fullscreen support ([#1866](https://github.com/emilk/egui/pull/1866)).
+* You can now continue execution after closing the native desktop window ([#1889](https://github.com/emilk/egui/pull/1889)).
+* `Frame::quit` has been renamed to `Frame::close` and `App::on_exit_event` is now `App::on_close_event` ([#1943](https://github.com/emilk/egui/pull/1943)).
+
+#### Web:
+* Added ability to stop/re-run web app from JavaScript. ⚠️ You need to update your CSS with `html, body: { height: 100%; width: 100%; }` ([#1803](https://github.com/emilk/egui/pull/1650)).
+* Added `WebOptions::follow_system_theme` and `WebOptions::default_theme` ([#1726](https://github.com/emilk/egui/pull/1726)).
+* Added option to select WebGL version ([#1803](https://github.com/emilk/egui/pull/1803)).
+
+
+## 0.18.0 - 2022-04-30
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Removed `eframe::epi` - everything is now in `eframe` (`eframe::App`, `eframe::Frame` etc) ([#1545](https://github.com/emilk/egui/pull/1545)).
+* Removed `Frame::request_repaint` - just call `egui::Context::request_repaint` for the same effect ([#1366](https://github.com/emilk/egui/pull/1366)).
+* Changed app creation/setup ([#1363](https://github.com/emilk/egui/pull/1363)):
+  * Removed `App::setup` and `App::name`.
+  * Provide `CreationContext` when creating app with egui context, storage, integration info and glow context.
+  * Change interface of `run_native` and `start_web`.
+* Added `Frame::storage()` and `Frame::storage_mut()` ([#1418](https://github.com/emilk/egui/pull/1418)).
+  * You can now load/save state in `App::update`
+  * Changed `App::update` to take `&mut Frame` instead of `&Frame`.
+  * `Frame` is no longer `Clone` or `Sync`.
+* Added `glow` (OpenGL) context to `Frame` ([#1425](https://github.com/emilk/egui/pull/1425)).
+
+#### Desktop/Native:
+* Remove the `egui_glium` feature. `eframe` will now always use `egui_glow` as the native backend ([#1357](https://github.com/emilk/egui/pull/1357)).
+* Change default for `NativeOptions::drag_and_drop_support` to `true` ([#1329](https://github.com/emilk/egui/pull/1329)).
+* Added new `NativeOptions`: `vsync`, `multisampling`, `depth_buffer`, `stencil_buffer`.
+* `dark-light` (dark mode detection) is now an opt-in feature ([#1437](https://github.com/emilk/egui/pull/1437)).
+* Fixed potential scale bug when DPI scaling changes (e.g. when dragging a  window between different displays) ([#1441](https://github.com/emilk/egui/pull/1441)).
+* Added new feature `puffin` to add [`puffin profiler`](https://github.com/EmbarkStudios/puffin) scopes ([#1483](https://github.com/emilk/egui/pull/1483)).
+* Moved app persistence to a background thread, allowing for smoother frame rates (on native).
+* Added `Frame::set_window_pos` ([#1505](https://github.com/emilk/egui/pull/1505)).
+
+#### Web:
+* Use full browser width by default ([#1378](https://github.com/emilk/egui/pull/1378)).
+* egui code will no longer be called after panic ([#1306](https://github.com/emilk/egui/pull/1306)).
+
+
+## 0.17.0 - 2022-02-22
+* Removed `Frame::alloc_texture`. Use `egui::Context::load_texture` instead ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Shift-scroll will now result in horizontal scrolling on all platforms ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Log using the `tracing` crate. Log to stdout by adding `tracing_subscriber::fmt::init();` to your `main` ([#1192](https://github.com/emilk/egui/pull/1192)).
+
+#### Desktop/Native:
+* The default native backend is now `egui_glow` (instead of `egui_glium`) ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+* Fixed horizontal scrolling direction on Linux.
+* Added `App::on_exit_event` ([#1038](https://github.com/emilk/egui/pull/1038))
+* Added `NativeOptions::initial_window_pos`.
+* Fixed `enable_drag` for Windows OS ([#1108](https://github.com/emilk/egui/pull/1108)).
+
+#### Web:
+* The default web painter is now `egui_glow` (instead of WebGL) ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Fixed glow failure on Chromium ([#1092](https://github.com/emilk/egui/pull/1092)).
+* Updated `eframe::IntegrationInfo::web_location_hash` on `hashchange` event ([#1140](https://github.com/emilk/egui/pull/1140)).
+* Expose all parts of the location/url in `frame.info().web_info` ([#1258](https://github.com/emilk/egui/pull/1258)).
+
+
+## 0.16.0 - 2021-12-29
+* `Frame` can now be cloned, saved, and passed to background threads ([#999](https://github.com/emilk/egui/pull/999)).
+* Added `Frame::request_repaint` to replace `repaint_signal` ([#999](https://github.com/emilk/egui/pull/999)).
+* Added `Frame::alloc_texture/free_texture` to replace `tex_allocator` ([#999](https://github.com/emilk/egui/pull/999)).
+
+#### Web:
+* Fixed [dark rendering in WebKitGTK](https://github.com/emilk/egui/issues/794) ([#888](https://github.com/emilk/egui/pull/888/)).
+* Added feature `glow` to switch to a [`glow`](https://github.com/grovesNL/glow) based painter ([#868](https://github.com/emilk/egui/pull/868)).
+
+
+## 0.15.0 - 2021-10-24
+* `Frame` now provides `set_window_title` to set window title dynamically ([#828](https://github.com/emilk/egui/pull/828)).
+* `Frame` now provides `set_decorations` to set whether to show window decorations.
+* Remove "http" feature (use https://github.com/emilk/ehttp instead!).
+* Added `App::persist_native_window` and `App::persist_egui_memory` to control what gets persisted.
+
+#### Desktop/Native:
+* Increase native scroll speed.
+* Added new backend `egui_glow` as an alternative to `egui_glium`. Enable with `default-features = false, features = ["default_fonts", "egui_glow"]`.
+
+#### Web:
+* Implement `eframe::NativeTexture` trait for the WebGL painter.
+* Deprecate `Painter::register_webgl_texture.
+* Fixed multiline paste.
+* Fixed painting with non-opaque backgrounds.
+* Improve text input on mobile and for IME.
+
+
+## 0.14.0 - 2021-08-24
+* Added dragging and dropping files into egui.
+* Improve http fetch API.
+* `run_native` now returns when the app is closed.
+* Web: Made text thicker and less pixelated.
+
+
+## 0.13.1 - 2021-06-24
+* Fixed `http` feature flag and docs
+
+
+## 0.13.0 - 2021-06-24
+* `App::setup` now takes a `Frame` and `Storage` by argument.
+* `App::load` has been removed. Implement `App::setup` instead.
+* Web: Default to light visuals unless the system reports a preference for dark mode.
+* Web: Improve alpha blending, making fonts look much better (especially in light mode)
+* Web: Fix double-paste bug
+
+
+## 0.12.0 - 2021-05-10
+* Moved options out of `trait App` into new `NativeOptions`.
+* Added option for `always_on_top`.
+* Web: Scroll faster when scrolling with mouse wheel.
+
+
+## 0.11.0 - 2021-04-05
+* You can now turn your window transparent with the `App::transparent` option.
+* You can now disable window decorations with the `App::decorated` option.
+* Web: [Fix mobile and IME text input](https://github.com/emilk/egui/pull/253)
+* Web: Hold down a modifier key when clicking a link to open it in a new tab.
+
+Contributors: [n2](https://github.com/n2)
+
+
+## 0.10.0 - 2021-02-28
+* [You can now set your own app icons](https://github.com/emilk/egui/pull/193).
+* You can control the initial size of the native window with `App::initial_window_size`.
+* You can control the maximum egui web canvas size with `App::max_size_points`.
+* `Frame::tex_allocator()` no longer returns an `Option` (there is always a texture allocator).
+
+
+## 0.9.0 - 2021-02-07
+* [Added support for HTTP body](https://github.com/emilk/egui/pull/139).
+* Web: Right-clicks will no longer open browser context menu.
+* Web: Fix a bug where one couldn't select items in a combo box on a touch screen.
+
+
+## 0.8.0 - 2021-01-17
+* Simplify `TextureAllocator` interface.
+* WebGL2 is now supported, with improved texture sampler. WebGL1 will be used as a fallback.
+* Web: Slightly improved alpha-blending (work-around for non-existing linear-space blending).
+* Web: Call `prevent_default` for arrow keys when entering text
+
+
+## 0.7.0 - 2021-01-04
+* Initial release of `eframe`
diff --git a/egui/crates/eframe/Cargo.toml b/egui/crates/eframe/Cargo.toml
new file mode 100644
index 0000000..649a55a
--- /dev/null
+++ b/egui/crates/eframe/Cargo.toml
@@ -0,0 +1,182 @@
+[package]
+name = "eframe"
+version = "0.21.3"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "egui framework - write GUI apps that compiles to web and/or natively"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/eframe"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/eframe"
+categories = ["gui", "game-development"]
+keywords = ["egui", "gui", "gamedev"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
+
+[lib]
+
+
+[features]
+default = ["accesskit", "default_fonts", "glow"]
+
+## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
+accesskit = ["egui/accesskit", "egui-winit/accesskit"]
+
+## Detect dark mode system preference using [`dark-light`](https://docs.rs/dark-light).
+##
+## See also [`NativeOptions::follow_system_theme`] and [`NativeOptions::default_theme`].
+dark-light = ["dep:dark-light"]
+
+## If set, egui will use `include_bytes!` to bundle some fonts.
+## If you plan on specifying your own fonts you may disable this feature.
+default_fonts = ["egui/default_fonts"]
+
+## Use [`glow`](https://github.com/grovesNL/glow) for painting, via [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow).
+glow = ["dep:glow", "dep:egui_glow", "dep:glutin", "dep:glutin-winit"]
+
+## Enables wayland support and fixes clipboard issue.
+wayland = ["egui-winit/wayland"]
+
+## Enable saving app state to disk.
+persistence = [
+  "directories-next",
+  "egui-winit/serde",
+  "egui/persistence",
+  "ron",
+  "serde",
+]
+
+## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
+##
+## Only enabled on native, because of the low resolution (1ms) of time keeping in browsers.
+## `eframe` will call `puffin::GlobalProfiler::lock().new_frame()` for you
+puffin = ["dep:puffin", "egui_glow?/puffin", "egui-wgpu?/puffin"]
+
+## Enable screen reader support (requires `ctx.options_mut(|o| o.screen_reader = true);`) on web.
+##
+## For other platforms, use the "accesskit" feature instead.
+web_screen_reader = ["tts"]
+
+## If set, eframe will look for the env-var `EFRAME_SCREENSHOT_TO` and write a screenshot to that location, and then quit.
+## This is used to generate images for the examples.
+__screenshot = ["dep:image"]
+
+## Use [`wgpu`](https://docs.rs/wgpu) for painting (via [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu)).
+## This overrides the `glow` feature.
+wgpu = ["dep:wgpu", "dep:egui-wgpu", "dep:pollster"]
+
+# Allow crates to choose an android-activity backend via Winit
+# - It's important that most applications should not have to depend on android-activity directly, and can
+#   rely on Winit to pull in a suitable version (unlike most Rust crates, any version conflicts won't link)
+# - It's also important that we don't impose an android-activity backend by taking this choice away from applications.
+
+## Enable the `native-activity` backend via `egui-winit` on Android
+android-native-activity = [ "egui-winit/android-native-activity" ]
+## Enable the `game-activity` backend via `egui-winit` on Android
+android-game-activity = [ "egui-winit/android-game-activity" ]
+
+[dependencies]
+egui = { version = "0.21.0", path = "../egui", default-features = false, features = [
+  "bytemuck",
+  "tracing",
+] }
+thiserror = "1.0.37"
+tracing = { version = "0.1", default-features = false, features = ["std"] }
+
+#! ### Optional dependencies
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+egui_glow = { version = "0.21.0", path = "../egui_glow", optional = true, default-features = false }
+glow = { version = "0.12", optional = true }
+ron = { version = "0.8", optional = true, features = ["integer128"] }
+serde = { version = "1", optional = true, features = ["derive"] }
+
+# -------------------------------------------
+# native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+egui-winit = { version = "0.21.1", path = "../egui-winit", default-features = false, features = [
+  "clipboard",
+  "links",
+] }
+raw-window-handle = { version = "0.5.0" }
+winit = "0.28.1"
+
+# optional native:
+dark-light = { version = "1.0", optional = true }
+directories-next = { version = "2", optional = true }
+egui-wgpu = { version = "0.21.0", path = "../egui-wgpu", optional = true, features = [
+  "winit",
+] } # if wgpu is used, use it with winit
+pollster = { version = "0.3", optional = true } # needed for wgpu
+
+# we can expose these to user so that they can select which backends they want to enable to avoid compiling useless deps.
+# this can be done at the same time we expose x11/wayland features of winit crate.
+glutin = { version = "0.30", optional = true }
+glutin-winit = { version = "0.3.0", optional = true }
+image = { version = "0.24", optional = true, default-features = false, features = [
+  "png",
+] }
+puffin = { version = "0.14", optional = true }
+wgpu = { version = "0.15.0", optional = true }
+
+# -------------------------------------------
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+bytemuck = "1.7"
+js-sys = "0.3"
+percent-encoding = "2.1"
+wasm-bindgen = "=0.2.84"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3.58", features = [
+  "BinaryType",
+  "Blob",
+  "Clipboard",
+  "ClipboardEvent",
+  "CompositionEvent",
+  "console",
+  "CssStyleDeclaration",
+  "DataTransfer",
+  "DataTransferItem",
+  "DataTransferItemList",
+  "Document",
+  "DomRect",
+  "DragEvent",
+  "Element",
+  "Event",
+  "EventListener",
+  "EventTarget",
+  "ExtSRgb",
+  "File",
+  "FileList",
+  "FocusEvent",
+  "HtmlCanvasElement",
+  "HtmlElement",
+  "HtmlInputElement",
+  "InputEvent",
+  "KeyboardEvent",
+  "Location",
+  "MediaQueryList",
+  "MediaQueryListEvent",
+  "MouseEvent",
+  "Navigator",
+  "Performance",
+  "Storage",
+  "Touch",
+  "TouchEvent",
+  "TouchList",
+  "WebGl2RenderingContext",
+  "WebglDebugRendererInfo",
+  "WebGlRenderingContext",
+  "WheelEvent",
+  "Window",
+] }
+
+# optional web:
+egui-wgpu = { version = "0.21.0", path = "../egui-wgpu", optional = true } # if wgpu is used, use it without (!) winit
+tts = { version = "0.25", optional = true, default-features = false }
+wgpu = { version = "0.15.0", optional = true, features = ["webgl"] }
diff --git a/egui/crates/eframe/README.md b/egui/crates/eframe/README.md
new file mode 100644
index 0000000..5599394
--- /dev/null
+++ b/egui/crates/eframe/README.md
@@ -0,0 +1,63 @@
+# eframe: the [`egui`](https://github.com/emilk/egui) framework
+
+[![Latest version](https://img.shields.io/crates/v/eframe.svg)](https://crates.io/crates/eframe)
+[![Documentation](https://docs.rs/eframe/badge.svg)](https://docs.rs/eframe)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+`eframe` is the official framework library for writing apps using [`egui`](https://github.com/emilk/egui). The app can be compiled both to run natively (cross platform) or be compiled to a web app (using WASM).
+
+To get started, see the [examples](https://github.com/emilk/egui/tree/master/examples).
+To learn how to set up `eframe` for web and native, go to <https://github.com/emilk/eframe_template/> and follow the instructions there!
+
+There is also a tutorial video at <https://www.youtube.com/watch?v=NtUkr_z7l84>.
+
+For how to use `egui`, see [the egui docs](https://docs.rs/egui).
+
+---
+
+`eframe` uses [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow) for rendering, and on native it uses [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit).
+
+To use on Linux, first run:
+
+```
+sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev
+```
+
+You need to either use `edition = "2021"`, or set `resolver = "2"` in the `[workspace]` section of your to-level `Cargo.toml`. See [this link](https://doc.rust-lang.org/edition-guide/rust-2021/default-cargo-resolver.html) for more info.
+
+You can opt-in to the using [`egui_wgpu`](https://github.com/emilk/egui/tree/master/crates/egui_wgpu) for rendering by enabling the `wgpu` feature and setting `NativeOptions::renderer` to `Renderer::Wgpu`.
+
+
+## Alternatives
+`eframe` is not the only way to write an app using `egui`! You can also try [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad), [`bevy_egui`](https://github.com/mvlabat/bevy_egui), [`egui_sdl2_gl`](https://github.com/ArjunNair/egui_sdl2_gl), and others.
+
+You can also use `egui_glow` and [`winit`](https://github.com/rust-windowing/winit) to build your own app as demonstrated in <https://github.com/emilk/egui/blob/master/crates/egui_glow/examples/pure_glow.rs>.
+
+
+## Problems with running egui on the web
+`eframe` uses WebGL (via [`glow`](https://crates.io/crates/glow)) and WASM, and almost nothing else from the web tech stack. This has some benefits, but also produces some challenges and serious downsides.
+
+* Rendering: Getting pixel-perfect rendering right on the web is very difficult.
+* Search: you cannot search an egui web page like you would a normal web page.
+* Bringing up an on-screen keyboard on mobile: there is no JS function to do this, so `eframe` fakes it by adding some invisible DOM elements. It doesn't always work.
+* Mobile text editing is not as good as for a normal web app.
+* Accessibility: There is an experimental screen reader for `eframe`, but it has to be enabled explicitly. There is no JS function to ask "Does the user want a screen reader?" (and there should probably not be such a function, due to user tracking/integrity concerns).
+* No integration with browser settings for colors and fonts.
+
+In many ways, `eframe` is trying to make the browser do something it wasn't designed to do (though there are many things browser vendors could do to improve how well libraries like egui work).
+
+The suggested use for `eframe` are for web apps where performance and responsiveness are more important than accessibility and mobile text editing.
+
+
+## Companion crates
+Not all rust crates work when compiled to WASM, but here are some useful crates have been designed to work well both natively and as WASM:
+
+* Audio: [`cpal`](https://github.com/RustAudio/cpal).
+* HTTP client: [`ehttp`](https://github.com/emilk/ehttp) and [`reqwest`](https://github.com/seanmonstar/reqwest).
+* Time: [`chrono`](https://github.com/chronotope/chrono).
+* WebSockets: [`ewebsock`](https://github.com/rerun-io/ewebsock).
+
+
+## Name
+The _frame_ in `eframe` stands both for the frame in which your `egui` app resides and also for "framework" (`frame` is a framework, `egui` is a library).
diff --git a/egui/crates/eframe/src/epi.rs b/egui/crates/eframe/src/epi.rs
new file mode 100644
index 0000000..0cc5e8e
--- /dev/null
+++ b/egui/crates/eframe/src/epi.rs
@@ -0,0 +1,1157 @@
+//! Platform-agnostic interface for writing apps using [`egui`] (epi = egui programming interface).
+//!
+//! `epi` provides interfaces for window management and serialization.
+//!
+//! Start by looking at the [`App`] trait, and implement [`App::update`].
+
+#![warn(missing_docs)] // Let's keep `epi` well-documented.
+
+#[cfg(target_arch = "wasm32")]
+use std::any::Any;
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub use crate::native::run::UserEvent;
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub use winit::event_loop::EventLoopBuilder;
+
+/// Hook into the building of an event loop before it is run
+///
+/// You can configure any platform specific details required on top of the default configuration
+/// done by `EFrame`.
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub type EventLoopBuilderHook = Box<dyn FnOnce(&mut EventLoopBuilder<UserEvent>)>;
+
+/// This is how your app is created.
+///
+/// You can use the [`CreationContext`] to setup egui, restore state, setup OpenGL things, etc.
+pub type AppCreator = Box<dyn FnOnce(&CreationContext<'_>) -> Box<dyn App>>;
+
+/// Data that is passed to [`AppCreator`] that can be used to setup and initialize your app.
+pub struct CreationContext<'s> {
+    /// The egui Context.
+    ///
+    /// You can use this to customize the look of egui, e.g to call [`egui::Context::set_fonts`],
+    /// [`egui::Context::set_visuals`] etc.
+    pub egui_ctx: egui::Context,
+
+    /// Information about the surrounding environment.
+    pub integration_info: IntegrationInfo,
+
+    /// You can use the storage to restore app state(requires the "persistence" feature).
+    pub storage: Option<&'s dyn Storage>,
+
+    /// The [`glow::Context`] allows you to initialize OpenGL resources (e.g. shaders) that
+    /// you might want to use later from a [`egui::PaintCallback`].
+    ///
+    /// Only available when compiling with the `glow` feature and using [`Renderer::Glow`].
+    #[cfg(feature = "glow")]
+    pub gl: Option<std::sync::Arc<glow::Context>>,
+
+    /// The underlying WGPU render state.
+    ///
+    /// Only available when compiling with the `wgpu` feature and using [`Renderer::Wgpu`].
+    ///
+    /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
+    #[cfg(feature = "wgpu")]
+    pub wgpu_render_state: Option<egui_wgpu::RenderState>,
+}
+
+// ----------------------------------------------------------------------------
+
+/// Implement this trait to write apps that can be compiled for both web/wasm and desktop/native using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+pub trait App {
+    /// Called each time the UI needs repainting, which may be many times per second.
+    ///
+    /// Put your widgets into a [`egui::SidePanel`], [`egui::TopBottomPanel`], [`egui::CentralPanel`], [`egui::Window`] or [`egui::Area`].
+    ///
+    /// The [`egui::Context`] can be cloned and saved if you like.
+    ///
+    /// To force a repaint, call [`egui::Context::request_repaint`] at any time (e.g. from another thread).
+    fn update(&mut self, ctx: &egui::Context, frame: &mut Frame);
+
+    /// Get a handle to the app.
+    ///
+    /// Can be used from web to interact or other external context.
+    ///
+    /// You need to implement this if you want to be able to access the application from JS using [`crate::web::backend::AppRunner`].
+    ///
+    /// This is needed because downcasting `Box<dyn App>` -> `Box<dyn Any>` to get &`ConcreteApp` is not simple in current rust.
+    ///
+    /// Just copy-paste this as your implementation:
+    /// ```ignore
+    /// #[cfg(target_arch = "wasm32")]
+    /// fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
+    ///     Some(&mut *self)
+    /// }
+    /// ```
+    #[cfg(target_arch = "wasm32")]
+    fn as_any_mut(&mut self) -> Option<&mut dyn Any> {
+        None
+    }
+
+    /// Called on shutdown, and perhaps at regular intervals. Allows you to save state.
+    ///
+    /// Only called when the "persistence" feature is enabled.
+    ///
+    /// On web the state is stored to "Local Storage".
+    /// On native the path is picked using [`directories_next::ProjectDirs::data_dir`](https://docs.rs/directories-next/2.0.0/directories_next/struct.ProjectDirs.html#method.data_dir) which is:
+    /// * Linux:   `/home/UserName/.local/share/APPNAME`
+    /// * macOS:   `/Users/UserName/Library/Application Support/APPNAME`
+    /// * Windows: `C:\Users\UserName\AppData\Roaming\APPNAME`
+    ///
+    /// where `APPNAME` is what is given to `eframe::run_native`.
+    fn save(&mut self, _storage: &mut dyn Storage) {}
+
+    /// Called when the user attempts to close the desktop window and/or quit the application.
+    ///
+    /// By returning `false` the closing will be aborted. To continue the closing return `true`.
+    ///
+    /// A scenario where this method will be run is after pressing the close button on a native
+    /// window, which allows you to ask the user whether they want to do something before exiting.
+    /// See the example at <https://github.com/emilk/egui/blob/master/examples/confirm_exit/> for practical usage.
+    ///
+    /// It will _not_ be called on the web or when the window is forcefully closed.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[doc(alias = "exit")]
+    #[doc(alias = "quit")]
+    fn on_close_event(&mut self) -> bool {
+        true
+    }
+
+    /// Called once on shutdown, after [`Self::save`].
+    ///
+    /// If you need to abort an exit use [`Self::on_close_event`].
+    ///
+    /// To get a [`glow`] context you need to compile with the `glow` feature flag,
+    /// and run eframe with the glow backend.
+    #[cfg(feature = "glow")]
+    fn on_exit(&mut self, _gl: Option<&glow::Context>) {}
+
+    /// Called once on shutdown, after [`Self::save`].
+    ///
+    /// If you need to abort an exit use [`Self::on_close_event`].
+    #[cfg(not(feature = "glow"))]
+    fn on_exit(&mut self) {}
+
+    // ---------
+    // Settings:
+
+    /// Time between automatic calls to [`Self::save`]
+    fn auto_save_interval(&self) -> std::time::Duration {
+        std::time::Duration::from_secs(30)
+    }
+
+    /// The size limit of the web app canvas.
+    ///
+    /// By default the max size is [`egui::Vec2::INFINITY`], i.e. unlimited.
+    fn max_size_points(&self) -> egui::Vec2 {
+        egui::Vec2::INFINITY
+    }
+
+    /// Background color values for the app, e.g. what is sent to `gl.clearColor`.
+    ///
+    /// This is the background of your windows if you don't set a central panel.
+    ///
+    /// ATTENTION:
+    /// Since these float values go to the render as-is, any color space conversion as done
+    /// e.g. by converting from [`egui::Color32`] to [`egui::Rgba`] may cause incorrect results.
+    /// egui recommends that rendering backends use a normal "gamma-space" (non-sRGB-aware) blending,
+    ///  which means the values you return here should also be in `sRGB` gamma-space in the 0-1 range.
+    /// You can use [`egui::Color32::to_normalized_gamma_f32`] for this.
+    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
+        // NOTE: a bright gray makes the shadows of the windows look weird.
+        // We use a bit of transparency so that if the user switches on the
+        // `transparent()` option they get immediate results.
+        egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).to_normalized_gamma_f32()
+
+        // _visuals.window_fill() would also be a natural choice
+    }
+
+    /// Controls whether or not the native window position and size will be
+    /// persisted (only if the "persistence" feature is enabled).
+    fn persist_native_window(&self) -> bool {
+        true
+    }
+
+    /// Controls whether or not the egui memory (window positions etc) will be
+    /// persisted (only if the "persistence" feature is enabled).
+    fn persist_egui_memory(&self) -> bool {
+        true
+    }
+
+    /// If `true` a warm-up call to [`Self::update`] will be issued where
+    /// `ctx.memory(|mem| mem.everything_is_visible())` will be set to `true`.
+    ///
+    /// This can help pre-caching resources loaded by different parts of the UI, preventing stutter later on.
+    ///
+    /// In this warm-up call, all painted shapes will be ignored.
+    ///
+    /// The default is `false`, and it is unlikely you will want to change this.
+    fn warm_up_enabled(&self) -> bool {
+        false
+    }
+
+    /// Called each time after the rendering the UI.
+    ///
+    /// Can be used to access pixel data with [`Frame::screenshot`]
+    fn post_rendering(&mut self, _window_size_px: [u32; 2], _frame: &Frame) {}
+}
+
+/// Selects the level of hardware graphics acceleration.
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum HardwareAcceleration {
+    /// Require graphics acceleration.
+    Required,
+
+    /// Prefer graphics acceleration, but fall back to software.
+    Preferred,
+
+    /// Do NOT use graphics acceleration.
+    ///
+    /// On some platforms (MacOS) this is ignored and treated the same as [`Self::Preferred`].
+    Off,
+}
+
+/// Options controlling the behavior of a native window.
+///
+/// Only a single native window is currently supported.
+#[cfg(not(target_arch = "wasm32"))]
+pub struct NativeOptions {
+    /// Sets whether or not the window will always be on top of other windows at initialization.
+    pub always_on_top: bool,
+
+    /// Show window in maximized mode
+    pub maximized: bool,
+
+    /// On desktop: add window decorations (i.e. a frame around your app)?
+    /// If false it will be difficult to move and resize the app.
+    pub decorated: bool,
+
+    /// Start in (borderless) fullscreen?
+    ///
+    /// Default: `false`.
+    pub fullscreen: bool,
+
+    /// On Mac: the window doesn't have a titlebar, but floating window buttons.
+    ///
+    /// See [winit's documentation][with_fullsize_content_view] for information on Mac-specific options.
+    ///
+    /// [with_fullsize_content_view]: https://docs.rs/winit/latest/x86_64-apple-darwin/winit/platform/macos/trait.WindowBuilderExtMacOS.html#tymethod.with_fullsize_content_view
+    #[cfg(target_os = "macos")]
+    pub fullsize_content: bool,
+
+    /// On Windows: enable drag and drop support. Drag and drop can
+    /// not be disabled on other platforms.
+    ///
+    /// See [winit's documentation][drag_and_drop] for information on why you
+    /// might want to disable this on windows.
+    ///
+    /// [drag_and_drop]: https://docs.rs/winit/latest/x86_64-pc-windows-msvc/winit/platform/windows/trait.WindowBuilderExtWindows.html#tymethod.with_drag_and_drop
+    pub drag_and_drop_support: bool,
+
+    /// The application icon, e.g. in the Windows task bar etc.
+    ///
+    /// This doesn't work on Mac and on Wayland.
+    /// See <https://docs.rs/winit/latest/winit/window/struct.Window.html#method.set_window_icon> for more.
+    pub icon_data: Option<IconData>,
+
+    /// The initial (inner) position of the native window in points (logical pixels).
+    pub initial_window_pos: Option<egui::Pos2>,
+
+    /// The initial inner size of the native window in points (logical pixels).
+    pub initial_window_size: Option<egui::Vec2>,
+
+    /// The minimum inner window size in points (logical pixels).
+    pub min_window_size: Option<egui::Vec2>,
+
+    /// The maximum inner window size in points (logical pixels).
+    pub max_window_size: Option<egui::Vec2>,
+
+    /// Should the app window be resizable?
+    pub resizable: bool,
+
+    /// On desktop: make the window transparent.
+    /// You control the transparency with [`App::clear_color()`].
+    /// You should avoid having a [`egui::CentralPanel`], or make sure its frame is also transparent.
+    pub transparent: bool,
+
+    /// On desktop: mouse clicks pass through the window, used for non-interactable overlays
+    /// Generally you would use this in conjunction with always_on_top
+    pub mouse_passthrough: bool,
+
+    /// Whether grant focus when window initially opened. True by default.
+    pub active: bool,
+
+    /// Turn on vertical syncing, limiting the FPS to the display refresh rate.
+    ///
+    /// The default is `true`.
+    pub vsync: bool,
+
+    /// Set the level of the multisampling anti-aliasing (MSAA).
+    ///
+    /// Must be a power-of-two. Higher = more smooth 3D.
+    ///
+    /// A value of `0` turns it off (default).
+    ///
+    /// `egui` already performs anti-aliasing via "feathering"
+    /// (controlled by [`egui::epaint::TessellationOptions`]),
+    /// but if you are embedding 3D in egui you may want to turn on multisampling.
+    pub multisampling: u16,
+
+    /// Sets the number of bits in the depth buffer.
+    ///
+    /// `egui` doesn't need the depth buffer, so the default value is 0.
+    ///
+    /// On `wgpu` backends, due to limited depth texture format options, this
+    /// will be interpreted as a boolean (non-zero = true) for whether or not
+    /// specifically a `Depth32Float` buffer is used.
+    pub depth_buffer: u8,
+
+    /// Sets the number of bits in the stencil buffer.
+    ///
+    /// `egui` doesn't need the stencil buffer, so the default value is 0.
+    pub stencil_buffer: u8,
+
+    /// Specify whether or not hardware acceleration is preferred, required, or not.
+    ///
+    /// Default: [`HardwareAcceleration::Preferred`].
+    pub hardware_acceleration: HardwareAcceleration,
+
+    /// What rendering backend to use.
+    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    pub renderer: Renderer,
+
+    /// Try to detect and follow the system preferred setting for dark vs light mode.
+    ///
+    /// By default, this is `true` on Mac and Windows, but `false` on Linux
+    /// due to <https://github.com/frewsxcv/rust-dark-light/issues/17>.
+    ///
+    /// On Mac and Windows the theme will automatically change when the dark vs light mode preference is changed.
+    ///
+    /// This only works on Linux if the `dark-light` feature is enabled.
+    ///
+    /// See also [`Self::default_theme`].
+    pub follow_system_theme: bool,
+
+    /// Which theme to use in case [`Self::follow_system_theme`] is `false`
+    /// or the `dark-light` feature is disabled.
+    ///
+    /// Default: [`Theme::Dark`].
+    pub default_theme: Theme,
+
+    /// This controls what happens when you close the main eframe window.
+    ///
+    /// If `true`, execution will continue after the eframe window is closed.
+    /// If `false`, the app will close once the eframe window is closed.
+    ///
+    /// This is `true` by default, and the `false` option is only there
+    /// so we can revert if we find any bugs.
+    ///
+    /// This feature was introduced in <https://github.com/emilk/egui/pull/1889>.
+    ///
+    /// When `true`, [`winit::platform::run_return::EventLoopExtRunReturn::run_return`] is used.
+    /// When `false`, [`winit::event_loop::EventLoop::run`] is used.
+    pub run_and_return: bool,
+
+    /// Hook into the building of an event loop before it is run.
+    ///
+    /// Specify a callback here in case you need to make platform specific changes to the
+    /// event loop before it is run.
+    ///
+    /// Note: A [`NativeOptions`] clone will not include any `event_loop_builder` hook.
+    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    pub event_loop_builder: Option<EventLoopBuilderHook>,
+
+    #[cfg(feature = "glow")]
+    /// Needed for cross compiling for VirtualBox VMSVGA driver with OpenGL ES 2.0 and OpenGL 2.1 which doesn't support SRGB texture.
+    /// See <https://github.com/emilk/egui/pull/1993>.
+    ///
+    /// For OpenGL ES 2.0: set this to [`egui_glow::ShaderVersion::Es100`] to solve blank texture problem (by using the "fallback shader").
+    pub shader_version: Option<egui_glow::ShaderVersion>,
+
+    /// On desktop: make the window position to be centered at initialization.
+    ///
+    /// Platform specific:
+    ///
+    /// Wayland desktop currently not supported.
+    pub centered: bool,
+
+    /// Configures wgpu instance/device/adapter/surface creation and renderloop.
+    #[cfg(feature = "wgpu")]
+    pub wgpu_options: egui_wgpu::WgpuConfiguration,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Clone for NativeOptions {
+    fn clone(&self) -> Self {
+        Self {
+            icon_data: self.icon_data.clone(),
+
+            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            event_loop_builder: None, // Skip any builder callbacks if cloning
+
+            #[cfg(feature = "wgpu")]
+            wgpu_options: self.wgpu_options.clone(),
+
+            ..*self
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Default for NativeOptions {
+    fn default() -> Self {
+        Self {
+            always_on_top: false,
+            maximized: false,
+            decorated: true,
+            fullscreen: false,
+
+            #[cfg(target_os = "macos")]
+            fullsize_content: false,
+
+            drag_and_drop_support: true,
+            icon_data: None,
+            initial_window_pos: None,
+            initial_window_size: None,
+            min_window_size: None,
+            max_window_size: None,
+            resizable: true,
+            transparent: false,
+            mouse_passthrough: false,
+
+            active: true,
+
+            vsync: true,
+            multisampling: 0,
+            depth_buffer: 0,
+            stencil_buffer: 0,
+            hardware_acceleration: HardwareAcceleration::Preferred,
+
+            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            renderer: Renderer::default(),
+
+            follow_system_theme: cfg!(target_os = "macos") || cfg!(target_os = "windows"),
+            default_theme: Theme::Dark,
+            run_and_return: true,
+
+            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            event_loop_builder: None,
+
+            #[cfg(feature = "glow")]
+            shader_version: None,
+
+            centered: false,
+
+            #[cfg(feature = "wgpu")]
+            wgpu_options: egui_wgpu::WgpuConfiguration::default(),
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl NativeOptions {
+    /// The theme used by the system.
+    #[cfg(feature = "dark-light")]
+    pub fn system_theme(&self) -> Option<Theme> {
+        if self.follow_system_theme {
+            crate::profile_scope!("dark_light::detect");
+            match dark_light::detect() {
+                dark_light::Mode::Dark => Some(Theme::Dark),
+                dark_light::Mode::Light => Some(Theme::Light),
+                dark_light::Mode::Default => None,
+            }
+        } else {
+            None
+        }
+    }
+
+    /// The theme used by the system.
+    #[cfg(not(feature = "dark-light"))]
+    pub fn system_theme(&self) -> Option<Theme> {
+        None
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Options when using `eframe` in a web page.
+#[cfg(target_arch = "wasm32")]
+pub struct WebOptions {
+    /// Try to detect and follow the system preferred setting for dark vs light mode.
+    ///
+    /// See also [`Self::default_theme`].
+    ///
+    /// Default: `true`.
+    pub follow_system_theme: bool,
+
+    /// Which theme to use in case [`Self::follow_system_theme`] is `false`
+    /// or system theme detection fails.
+    ///
+    /// Default: `Theme::Dark`.
+    pub default_theme: Theme,
+
+    /// Which version of WebGl context to select
+    ///
+    /// Default: [`WebGlContextOption::BestFirst`].
+    #[cfg(feature = "glow")]
+    pub webgl_context_option: WebGlContextOption,
+
+    /// Configures wgpu instance/device/adapter/surface creation and renderloop.
+    #[cfg(feature = "wgpu")]
+    pub wgpu_options: egui_wgpu::WgpuConfiguration,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl Default for WebOptions {
+    fn default() -> Self {
+        Self {
+            follow_system_theme: true,
+            default_theme: Theme::Dark,
+
+            #[cfg(feature = "glow")]
+            webgl_context_option: WebGlContextOption::BestFirst,
+
+            #[cfg(feature = "wgpu")]
+            wgpu_options: egui_wgpu::WgpuConfiguration {
+                // WebGPU is not stable enough yet, use WebGL emulation
+                backends: wgpu::Backends::GL,
+                device_descriptor: wgpu::DeviceDescriptor {
+                    label: Some("egui wgpu device"),
+                    features: wgpu::Features::default(),
+                    limits: wgpu::Limits {
+                        // When using a depth buffer, we have to be able to create a texture
+                        // large enough for the entire surface, and we want to support 4k+ displays.
+                        max_texture_dimension_2d: 8192,
+                        ..wgpu::Limits::downlevel_webgl2_defaults()
+                    },
+                },
+                ..Default::default()
+            },
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Dark or Light theme.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum Theme {
+    /// Dark mode: light text on a dark background.
+    Dark,
+
+    /// Light mode: dark text on a light background.
+    Light,
+}
+
+impl Theme {
+    /// Get the egui visuals corresponding to this theme.
+    ///
+    /// Use with [`egui::Context::set_visuals`].
+    pub fn egui_visuals(self) -> egui::Visuals {
+        match self {
+            Self::Dark => egui::Visuals::dark(),
+            Self::Light => egui::Visuals::light(),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// WebGL Context options
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum WebGlContextOption {
+    /// Force Use WebGL1.
+    WebGl1,
+
+    /// Force use WebGL2.
+    WebGl2,
+
+    /// Use WebGl2 first.
+    BestFirst,
+
+    /// Use WebGl1 first
+    CompatibilityFirst,
+}
+
+// ----------------------------------------------------------------------------
+
+/// What rendering backend to use.
+///
+/// You need to enable the "glow" and "wgpu" features to have a choice.
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+pub enum Renderer {
+    /// Use [`egui_glow`] renderer for [`glow`](https://github.com/grovesNL/glow).
+    #[cfg(feature = "glow")]
+    Glow,
+
+    /// Use [`egui_wgpu`] renderer for [`wgpu`](https://github.com/gfx-rs/wgpu).
+    #[cfg(feature = "wgpu")]
+    Wgpu,
+}
+
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+impl Default for Renderer {
+    fn default() -> Self {
+        #[cfg(feature = "glow")]
+        return Self::Glow;
+
+        #[cfg(not(feature = "glow"))]
+        #[cfg(feature = "wgpu")]
+        return Self::Wgpu;
+
+        #[cfg(not(feature = "glow"))]
+        #[cfg(not(feature = "wgpu"))]
+        compile_error!("eframe: you must enable at least one of the rendering backend features: 'glow' or 'wgpu'");
+    }
+}
+
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+impl std::fmt::Display for Renderer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(feature = "glow")]
+            Self::Glow => "glow".fmt(f),
+
+            #[cfg(feature = "wgpu")]
+            Self::Wgpu => "wgpu".fmt(f),
+        }
+    }
+}
+
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+impl std::str::FromStr for Renderer {
+    type Err = String;
+
+    fn from_str(name: &str) -> Result<Self, String> {
+        match name.to_lowercase().as_str() {
+            #[cfg(feature = "glow")]
+            "glow" => Ok(Self::Glow),
+
+            #[cfg(feature = "wgpu")]
+            "wgpu" => Ok(Self::Wgpu),
+
+            _ => Err(format!("eframe renderer {name:?} is not available. Make sure that the corresponding eframe feature is enabled."))
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Image data for an application icon.
+#[derive(Clone)]
+pub struct IconData {
+    /// RGBA pixels, unmultiplied.
+    pub rgba: Vec<u8>,
+
+    /// Image width. This should be a multiple of 4.
+    pub width: u32,
+
+    /// Image height. This should be a multiple of 4.
+    pub height: u32,
+}
+
+/// Represents the surroundings of your app.
+///
+/// It provides methods to inspect the surroundings (are we on the web?),
+/// allocate textures, and change settings (e.g. window size).
+pub struct Frame {
+    /// Information about the integration.
+    pub(crate) info: IntegrationInfo,
+
+    /// Where the app can issue commands back to the integration.
+    pub(crate) output: backend::AppOutput,
+
+    /// A place where you can store custom data in a way that persists when you restart the app.
+    pub(crate) storage: Option<Box<dyn Storage>>,
+
+    /// A reference to the underlying [`glow`] (OpenGL) context.
+    #[cfg(feature = "glow")]
+    pub(crate) gl: Option<std::sync::Arc<glow::Context>>,
+
+    /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
+    #[cfg(feature = "wgpu")]
+    pub(crate) wgpu_render_state: Option<egui_wgpu::RenderState>,
+
+    /// If [`Frame::request_screenshot`] was called during a frame, this field will store the screenshot
+    /// such that it can be retrieved during [`App::post_rendering`] with [`Frame::screenshot`]
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(crate) screenshot: std::cell::Cell<Option<egui::ColorImage>>,
+}
+
+impl Frame {
+    /// True if you are in a web environment.
+    ///
+    /// Equivalent to `cfg!(target_arch = "wasm32")`
+    #[allow(clippy::unused_self)]
+    pub fn is_web(&self) -> bool {
+        cfg!(target_arch = "wasm32")
+    }
+
+    /// Information about the integration.
+    pub fn info(&self) -> IntegrationInfo {
+        self.info.clone()
+    }
+
+    /// A place where you can store custom data in a way that persists when you restart the app.
+    pub fn storage(&self) -> Option<&dyn Storage> {
+        self.storage.as_deref()
+    }
+
+    /// Request the current frame's pixel data. Needs to be retrieved by calling [`Frame::screenshot`]
+    /// during [`App::post_rendering`].
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn request_screenshot(&mut self) {
+        self.output.screenshot_requested = true;
+    }
+
+    /// Cancel a request made with [`Frame::request_screenshot`].
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn cancel_screenshot_request(&mut self) {
+        self.output.screenshot_requested = false;
+    }
+
+    /// During [`App::post_rendering`], use this to retrieve the pixel data that was requested during
+    /// [`App::update`] via [`Frame::request_screenshot`].
+    ///
+    /// Returns None if:
+    /// * Called in [`App::update`]
+    /// * [`Frame::request_screenshot`] wasn't called on this frame during [`App::update`]
+    /// * The rendering backend doesn't support this feature (yet). Currently implemented for wgpu and glow, but not with wasm as target.
+    /// * Retrieving the data was unsuccessful in some way.
+    ///
+    /// See also [`egui::ColorImage::region`]
+    ///
+    /// ## Example generating a capture of everything within a square of 100 pixels located at the top left of the app and saving it with the [`image`](crates.io/crates/image) crate:
+    /// ```
+    /// struct MyApp;
+    ///
+    /// impl eframe::App for MyApp {
+    ///     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+    ///         // In real code the app would render something here
+    ///         frame.request_screenshot();
+    ///         // Things that are added to the frame after the call to
+    ///         // request_screenshot() will still be included.
+    ///     }
+    ///
+    ///     fn post_rendering(&mut self, _window_size: [u32; 2], frame: &eframe::Frame) {
+    ///         if let Some(screenshot) = frame.screenshot() {
+    ///             let pixels_per_point = frame.info().native_pixels_per_point;
+    ///             let region = egui::Rect::from_two_pos(
+    ///                 egui::Pos2::ZERO,
+    ///                 egui::Pos2{ x: 100., y: 100. },
+    ///             );
+    ///             let top_left_corner = screenshot.region(&region, pixels_per_point);
+    ///             image::save_buffer(
+    ///                 "top_left.png",
+    ///                 top_left_corner.as_raw(),
+    ///                 top_left_corner.width() as u32,
+    ///                 top_left_corner.height() as u32,
+    ///                 image::ColorType::Rgba8,
+    ///             ).unwrap();
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn screenshot(&self) -> Option<egui::ColorImage> {
+        self.screenshot.take()
+    }
+
+    /// A place where you can store custom data in a way that persists when you restart the app.
+    pub fn storage_mut(&mut self) -> Option<&mut (dyn Storage + 'static)> {
+        self.storage.as_deref_mut()
+    }
+
+    /// A reference to the underlying [`glow`] (OpenGL) context.
+    ///
+    /// This can be used, for instance, to:
+    /// * Render things to offscreen buffers.
+    /// * Read the pixel buffer from the previous frame (`glow::Context::read_pixels`).
+    /// * Render things behind the egui windows.
+    ///
+    /// Note that all egui painting is deferred to after the call to [`App::update`]
+    /// ([`egui`] only collects [`egui::Shape`]s and then eframe paints them all in one go later on).
+    ///
+    /// To get a [`glow`] context you need to compile with the `glow` feature flag,
+    /// and run eframe using [`Renderer::Glow`].
+    #[cfg(feature = "glow")]
+    pub fn gl(&self) -> Option<&std::sync::Arc<glow::Context>> {
+        self.gl.as_ref()
+    }
+
+    /// The underlying WGPU render state.
+    ///
+    /// Only available when compiling with the `wgpu` feature and using [`Renderer::Wgpu`].
+    ///
+    /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
+    #[cfg(feature = "wgpu")]
+    pub fn wgpu_render_state(&self) -> Option<&egui_wgpu::RenderState> {
+        self.wgpu_render_state.as_ref()
+    }
+
+    /// Tell `eframe` to close the desktop window.
+    ///
+    /// The window will not close immediately, but at the end of the this frame.
+    ///
+    /// Calling this will likely result in the app quitting, unless
+    /// you have more code after the call to [`crate::run_native`].
+    #[cfg(not(target_arch = "wasm32"))]
+    #[doc(alias = "exit")]
+    #[doc(alias = "quit")]
+    pub fn close(&mut self) {
+        tracing::debug!("eframe::Frame::close called");
+        self.output.close = true;
+    }
+
+    /// Minimize or unminimize window. (native only)
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_minimized(&mut self, minimized: bool) {
+        self.output.minimized = Some(minimized);
+    }
+
+    /// Bring the window into focus (native only). Has no effect on Wayland, or if the window is minimized or invisible.
+    ///
+    /// This method puts the window on top of other applications and takes input focus away from them,
+    /// which, if unexpected, will disturb the user.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn focus(&mut self) {
+        self.output.focus = Some(true);
+    }
+
+    /// Maximize or unmaximize window. (native only)
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_maximized(&mut self, maximized: bool) {
+        self.output.maximized = Some(maximized);
+    }
+
+    /// Tell `eframe` to close the desktop window.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[deprecated = "Renamed `close`"]
+    pub fn quit(&mut self) {
+        self.close();
+    }
+
+    /// Set the desired inner size of the window (in egui points).
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_window_size(&mut self, size: egui::Vec2) {
+        self.output.window_size = Some(size);
+        self.info.window_info.size = size; // so that subsequent calls see the updated value
+    }
+
+    /// Set the desired title of the window.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_window_title(&mut self, title: &str) {
+        self.output.window_title = Some(title.to_owned());
+    }
+
+    /// Set whether to show window decorations (i.e. a frame around you app).
+    ///
+    /// If false it will be difficult to move and resize the app.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_decorations(&mut self, decorated: bool) {
+        self.output.decorated = Some(decorated);
+    }
+
+    /// Turn borderless fullscreen on/off (native only).
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_fullscreen(&mut self, fullscreen: bool) {
+        self.output.fullscreen = Some(fullscreen);
+        self.info.window_info.fullscreen = fullscreen; // so that subsequent calls see the updated value
+    }
+
+    /// set the position of the outer window.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_window_pos(&mut self, pos: egui::Pos2) {
+        self.output.window_pos = Some(pos);
+        self.info.window_info.position = Some(pos); // so that subsequent calls see the updated value
+    }
+
+    /// When called, the native window will follow the
+    /// movement of the cursor while the primary mouse button is down.
+    ///
+    /// Does not work on the web.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn drag_window(&mut self) {
+        self.output.drag_window = true;
+    }
+
+    /// Set the visibility of the window.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_visible(&mut self, visible: bool) {
+        self.output.visible = Some(visible);
+    }
+
+    /// On desktop: Set the window always on top.
+    ///
+    /// (Wayland desktop currently not supported)
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_always_on_top(&mut self, always_on_top: bool) {
+        self.output.always_on_top = Some(always_on_top);
+    }
+
+    /// On desktop: Set the window to be centered.
+    ///
+    /// (Wayland desktop currently not supported)
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_centered(&mut self) {
+        if let Some(monitor_size) = self.info.window_info.monitor_size {
+            let inner_size = self.info.window_info.size;
+            if monitor_size.x > 1.0 && monitor_size.y > 1.0 {
+                let x = (monitor_size.x - inner_size.x) / 2.0;
+                let y = (monitor_size.y - inner_size.y) / 2.0;
+                self.set_window_pos(egui::Pos2 { x, y });
+            }
+        }
+    }
+
+    /// for integrations only: call once per frame
+    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    pub(crate) fn take_app_output(&mut self) -> backend::AppOutput {
+        std::mem::take(&mut self.output)
+    }
+}
+
+/// Information about the web environment (if applicable).
+#[derive(Clone, Debug)]
+#[cfg(target_arch = "wasm32")]
+pub struct WebInfo {
+    /// The browser user agent.
+    pub user_agent: String,
+
+    /// Information about the URL.
+    pub location: Location,
+}
+
+/// Information about the application's main window, if available.
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Clone, Debug)]
+pub struct WindowInfo {
+    /// Coordinates of the window's outer top left corner, relative to the top left corner of the first display.
+    ///
+    /// Unit: egui points (logical pixels).
+    ///
+    /// `None` = unknown.
+    pub position: Option<egui::Pos2>,
+
+    /// Are we in fullscreen mode?
+    pub fullscreen: bool,
+
+    /// Are we minimized?
+    pub minimized: bool,
+
+    /// Are we maximized?
+    pub maximized: bool,
+
+    /// Is the window focused and able to receive input?
+    pub focused: bool,
+
+    /// Window inner size in egui points (logical pixels).
+    pub size: egui::Vec2,
+
+    /// Current monitor size in egui points (logical pixels)
+    pub monitor_size: Option<egui::Vec2>,
+}
+
+/// Information about the URL.
+///
+/// Everything has been percent decoded (`%20` -> ` ` etc).
+#[cfg(target_arch = "wasm32")]
+#[derive(Clone, Debug)]
+pub struct Location {
+    /// The full URL (`location.href`) without the hash.
+    ///
+    /// Example: `"http://www.example.com:80/index.html?foo=bar"`.
+    pub url: String,
+
+    /// `location.protocol`
+    ///
+    /// Example: `"http:"`.
+    pub protocol: String,
+
+    /// `location.host`
+    ///
+    /// Example: `"example.com:80"`.
+    pub host: String,
+
+    /// `location.hostname`
+    ///
+    /// Example: `"example.com"`.
+    pub hostname: String,
+
+    /// `location.port`
+    ///
+    /// Example: `"80"`.
+    pub port: String,
+
+    /// The "#fragment" part of "www.example.com/index.html?query#fragment".
+    ///
+    /// Note that the leading `#` is included in the string.
+    /// Also known as "hash-link" or "anchor".
+    pub hash: String,
+
+    /// The "query" part of "www.example.com/index.html?query#fragment".
+    ///
+    /// Note that the leading `?` is NOT included in the string.
+    ///
+    /// Use [`Self::query_map`] to get the parsed version of it.
+    pub query: String,
+
+    /// The parsed "query" part of "www.example.com/index.html?query#fragment".
+    ///
+    /// "foo=42&bar%20" is parsed as `{"foo": "42",  "bar ": ""}`
+    pub query_map: std::collections::BTreeMap<String, String>,
+
+    /// `location.origin`
+    ///
+    /// Example: `"http://www.example.com:80"`.
+    pub origin: String,
+}
+
+/// Information about the integration passed to the use app each frame.
+#[derive(Clone, Debug)]
+pub struct IntegrationInfo {
+    /// Information about the surrounding web environment.
+    #[cfg(target_arch = "wasm32")]
+    pub web_info: WebInfo,
+
+    /// Does the OS use dark or light mode?
+    ///
+    /// `None` means "don't know".
+    pub system_theme: Option<Theme>,
+
+    /// Seconds of cpu usage (in seconds) of UI code on the previous frame.
+    /// `None` if this is the first frame.
+    pub cpu_usage: Option<f32>,
+
+    /// The OS native pixels-per-point
+    pub native_pixels_per_point: Option<f32>,
+
+    /// The position and size of the native window.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub window_info: WindowInfo,
+}
+
+// ----------------------------------------------------------------------------
+
+/// A place where you can store custom data in a way that persists when you restart the app.
+///
+/// On the web this is backed by [local storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage).
+/// On desktop this is backed by the file system.
+///
+/// See [`CreationContext::storage`] and [`App::save`].
+pub trait Storage {
+    /// Get the value for the given key.
+    fn get_string(&self, key: &str) -> Option<String>;
+
+    /// Set the value for the given key.
+    fn set_string(&mut self, key: &str, value: String);
+
+    /// write-to-disk or similar
+    fn flush(&mut self);
+}
+
+/// Stores nothing.
+#[derive(Clone, Default)]
+pub(crate) struct DummyStorage {}
+
+impl Storage for DummyStorage {
+    fn get_string(&self, _key: &str) -> Option<String> {
+        None
+    }
+
+    fn set_string(&mut self, _key: &str, _value: String) {}
+
+    fn flush(&mut self) {}
+}
+
+/// Get and deserialize the [RON](https://github.com/ron-rs/ron) stored at the given key.
+#[cfg(feature = "ron")]
+pub fn get_value<T: serde::de::DeserializeOwned>(storage: &dyn Storage, key: &str) -> Option<T> {
+    storage
+        .get_string(key)
+        .and_then(|value| ron::from_str(&value).ok())
+}
+
+/// Serialize the given value as [RON](https://github.com/ron-rs/ron) and store with the given key.
+#[cfg(feature = "ron")]
+pub fn set_value<T: serde::Serialize>(storage: &mut dyn Storage, key: &str, value: &T) {
+    match ron::ser::to_string(value) {
+        Ok(string) => storage.set_string(key, string),
+        Err(err) => tracing::error!("eframe failed to encode data using ron: {}", err),
+    }
+}
+
+/// [`Storage`] key used for app
+pub const APP_KEY: &str = "app";
+
+// ----------------------------------------------------------------------------
+
+/// You only need to look here if you are writing a backend for `epi`.
+pub(crate) mod backend {
+    /// Action that can be taken by the user app.
+    #[derive(Clone, Debug, Default)]
+    #[must_use]
+    pub struct AppOutput {
+        /// Set to `true` to close the native window (which often quits the app).
+        #[cfg(not(target_arch = "wasm32"))]
+        pub close: bool,
+
+        /// Set to some size to resize the outer window (e.g. glium window) to this size.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub window_size: Option<egui::Vec2>,
+
+        /// Set to some string to rename the outer window (e.g. glium window) to this title.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub window_title: Option<String>,
+
+        /// Set to some bool to change window decorations.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub decorated: Option<bool>,
+
+        /// Set to some bool to change window fullscreen.
+        #[cfg(not(target_arch = "wasm32"))] // TODO: implement fullscreen on web
+        pub fullscreen: Option<bool>,
+
+        /// Set to true to drag window while primary mouse button is down.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub drag_window: bool,
+
+        /// Set to some position to move the outer window (e.g. glium window) to this position
+        #[cfg(not(target_arch = "wasm32"))]
+        pub window_pos: Option<egui::Pos2>,
+
+        /// Set to some bool to change window visibility.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub visible: Option<bool>,
+
+        /// Set to some bool to tell the window always on top.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub always_on_top: Option<bool>,
+
+        /// Set to some bool to minimize or unminimize window.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub minimized: Option<bool>,
+
+        /// Set to some bool to maximize or unmaximize window.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub maximized: Option<bool>,
+
+        /// Set to some bool to focus window.
+        #[cfg(not(target_arch = "wasm32"))]
+        pub focus: Option<bool>,
+
+        #[cfg(not(target_arch = "wasm32"))]
+        pub screenshot_requested: bool,
+    }
+}
diff --git a/egui/crates/eframe/src/lib.rs b/egui/crates/eframe/src/lib.rs
new file mode 100644
index 0000000..665f390
--- /dev/null
+++ b/egui/crates/eframe/src/lib.rs
@@ -0,0 +1,323 @@
+//! eframe - the [`egui`] framework crate
+//!
+//! If you are planning to write an app for web or native,
+//! and want to use [`egui`] for everything, then `eframe` is for you!
+//!
+//! To get started, see the [examples](https://github.com/emilk/egui/tree/master/examples).
+//! To learn how to set up `eframe` for web and native, go to <https://github.com/emilk/eframe_template/> and follow the instructions there!
+//!
+//! In short, you implement [`App`] (especially [`App::update`]) and then
+//! call [`crate::run_native`] from your `main.rs`, and/or call `eframe::start_web` from your `lib.rs`.
+//!
+//! ## Usage, native:
+//! ``` no_run
+//! use eframe::egui;
+//!
+//! fn main() {
+//!     let native_options = eframe::NativeOptions::default();
+//!     eframe::run_native("My egui App", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))));
+//! }
+//!
+//! #[derive(Default)]
+//! struct MyEguiApp {}
+//!
+//! impl MyEguiApp {
+//!     fn new(cc: &eframe::CreationContext<'_>) -> Self {
+//!         // Customize egui here with cc.egui_ctx.set_fonts and cc.egui_ctx.set_visuals.
+//!         // Restore app state using cc.storage (requires the "persistence" feature).
+//!         // Use the cc.gl (a glow::Context) to create graphics shaders and buffers that you can use
+//!         // for e.g. egui::PaintCallback.
+//!         Self::default()
+//!     }
+//! }
+//!
+//! impl eframe::App for MyEguiApp {
+//!    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+//!        egui::CentralPanel::default().show(ctx, |ui| {
+//!            ui.heading("Hello World!");
+//!        });
+//!    }
+//! }
+//! ```
+//!
+//! ## Usage, web:
+//! ``` no_run
+//! #[cfg(target_arch = "wasm32")]
+//! use wasm_bindgen::prelude::*;
+//!
+//! /// Call this once from the HTML.
+//! #[cfg(target_arch = "wasm32")]
+//! #[wasm_bindgen]
+//! pub async fn start(canvas_id: &str) -> Result<AppRunnerRef, eframe::wasm_bindgen::JsValue> {
+//!     let web_options = eframe::WebOptions::default();
+//!     eframe::start_web(canvas_id, web_options, Box::new(|cc| Box::new(MyEguiApp::new(cc)))).await
+//! }
+//! ```
+//!
+//! ## Simplified usage
+//! If your app is only for native, and you don't need advanced features like state persistence,
+//! then you can use the simpler function [`run_simple_native`].
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::needless_doctest_main)]
+
+// Re-export all useful libraries:
+pub use {egui, egui::emath, egui::epaint};
+
+#[cfg(feature = "glow")]
+pub use {egui_glow, glow};
+
+#[cfg(feature = "wgpu")]
+pub use {egui_wgpu, wgpu};
+
+mod epi;
+
+// Re-export everything in `epi` so `eframe` users don't have to care about what `epi` is:
+pub use epi::*;
+
+// ----------------------------------------------------------------------------
+// When compiling for web
+
+#[cfg(target_arch = "wasm32")]
+pub mod web;
+
+#[cfg(target_arch = "wasm32")]
+pub use wasm_bindgen;
+
+#[cfg(target_arch = "wasm32")]
+use web::AppRunnerRef;
+
+#[cfg(target_arch = "wasm32")]
+pub use web_sys;
+
+/// Install event listeners to register different input events
+/// and start running the given app.
+///
+/// ``` no_run
+/// #[cfg(target_arch = "wasm32")]
+/// use wasm_bindgen::prelude::*;
+///
+/// /// This is the entry-point for all the web-assembly.
+/// /// This is called from the HTML.
+/// /// It loads the app, installs some callbacks, then returns.
+/// /// It returns a handle to the running app that can be stopped calling `AppRunner::stop_web`.
+/// /// You can add more callbacks like this if you want to call in to your code.
+/// #[cfg(target_arch = "wasm32")]
+/// #[wasm_bindgen]
+/// pub struct WebHandle {
+///     handle: AppRunnerRef,
+/// }
+/// #[cfg(target_arch = "wasm32")]
+/// #[wasm_bindgen]
+/// pub async fn start(canvas_id: &str) -> Result<WebHandle, eframe::wasm_bindgen::JsValue> {
+///     let web_options = eframe::WebOptions::default();
+///     eframe::start_web(
+///         canvas_id,
+///         web_options,
+///         Box::new(|cc| Box::new(MyEguiApp::new(cc))),
+///     )
+///     .await
+///     .map(|handle| WebHandle { handle })
+/// }
+/// ```
+///
+/// # Errors
+/// Failing to initialize WebGL graphics.
+#[cfg(target_arch = "wasm32")]
+pub async fn start_web(
+    canvas_id: &str,
+    web_options: WebOptions,
+    app_creator: AppCreator,
+) -> std::result::Result<AppRunnerRef, wasm_bindgen::JsValue> {
+    let handle = web::start(canvas_id, web_options, app_creator).await?;
+
+    Ok(handle)
+}
+
+// ----------------------------------------------------------------------------
+// When compiling natively
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+mod native;
+
+/// This is how you start a native (desktop) app.
+///
+/// The first argument is name of your app, used for the title bar of the native window
+/// and the save location of persistence (see [`App::save`]).
+///
+/// Call from `fn main` like this:
+/// ``` no_run
+/// use eframe::egui;
+///
+/// fn main() -> eframe::Result<()> {
+///     let native_options = eframe::NativeOptions::default();
+///     eframe::run_native("MyApp", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))))
+/// }
+///
+/// #[derive(Default)]
+/// struct MyEguiApp {}
+///
+/// impl MyEguiApp {
+///     fn new(cc: &eframe::CreationContext<'_>) -> Self {
+///         // Customize egui here with cc.egui_ctx.set_fonts and cc.egui_ctx.set_visuals.
+///         // Restore app state using cc.storage (requires the "persistence" feature).
+///         // Use the cc.gl (a glow::Context) to create graphics shaders and buffers that you can use
+///         // for e.g. egui::PaintCallback.
+///         Self::default()
+///     }
+/// }
+///
+/// impl eframe::App for MyEguiApp {
+///    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+///        egui::CentralPanel::default().show(ctx, |ui| {
+///            ui.heading("Hello World!");
+///        });
+///    }
+/// }
+/// ```
+///
+/// # Errors
+/// This function can fail if we fail to set up a graphics context.
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[allow(clippy::needless_pass_by_value)]
+pub fn run_native(
+    app_name: &str,
+    native_options: NativeOptions,
+    app_creator: AppCreator,
+) -> Result<()> {
+    let renderer = native_options.renderer;
+
+    #[cfg(not(feature = "__screenshot"))]
+    assert!(
+        std::env::var("EFRAME_SCREENSHOT_TO").is_err(),
+        "EFRAME_SCREENSHOT_TO found without compiling with the '__screenshot' feature"
+    );
+
+    match renderer {
+        #[cfg(feature = "glow")]
+        Renderer::Glow => {
+            tracing::debug!("Using the glow renderer");
+            native::run::run_glow(app_name, native_options, app_creator)
+        }
+
+        #[cfg(feature = "wgpu")]
+        Renderer::Wgpu => {
+            tracing::debug!("Using the wgpu renderer");
+            native::run::run_wgpu(app_name, native_options, app_creator)
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// The simplest way to get started when writing a native app.
+///
+/// This does NOT support persistence. For that you need to use [`run_native`].
+///
+/// # Example
+/// ``` no_run
+/// fn main() -> eframe::Result<()> {
+///     // Our application state:
+///     let mut name = "Arthur".to_owned();
+///     let mut age = 42;
+///
+///     let options = eframe::NativeOptions::default();
+///     eframe::run_simple_native("My egui App", options, move |ctx, _frame| {
+///         egui::CentralPanel::default().show(ctx, |ui| {
+///             ui.heading("My egui Application");
+///             ui.horizontal(|ui| {
+///                 let name_label = ui.label("Your name: ");
+///                 ui.text_edit_singleline(&mut name)
+///                     .labelled_by(name_label.id);
+///             });
+///             ui.add(egui::Slider::new(&mut age, 0..=120).text("age"));
+///             if ui.button("Click each year").clicked() {
+///                 age += 1;
+///             }
+///             ui.label(format!("Hello '{}', age {}", name, age));
+///         });
+///     })
+/// }
+/// ```
+///
+/// # Errors
+/// This function can fail if we fail to set up a graphics context.
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub fn run_simple_native(
+    app_name: &str,
+    native_options: NativeOptions,
+    update_fun: impl FnMut(&egui::Context, &mut Frame) + 'static,
+) -> Result<()> {
+    struct SimpleApp<U> {
+        update_fun: U,
+    }
+    impl<U: FnMut(&egui::Context, &mut Frame)> App for SimpleApp<U> {
+        fn update(&mut self, ctx: &egui::Context, frame: &mut Frame) {
+            (self.update_fun)(ctx, frame);
+        }
+    }
+
+    run_native(
+        app_name,
+        native_options,
+        Box::new(|_cc| Box::new(SimpleApp { update_fun })),
+    )
+}
+
+// ----------------------------------------------------------------------------
+
+/// The different problems that can occur when trying to run `eframe`.
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[cfg(not(target_arch = "wasm32"))]
+    #[error("winit error: {0}")]
+    Winit(#[from] winit::error::OsError),
+
+    #[cfg(all(feature = "glow", not(target_arch = "wasm32")))]
+    #[error("glutin error: {0}")]
+    Glutin(#[from] glutin::error::Error),
+
+    #[cfg(all(feature = "glow", not(target_arch = "wasm32")))]
+    #[error("Found no glutin configs matching the template: {0:?}. error: {1:?}")]
+    NoGlutinConfigs(glutin::config::ConfigTemplate, Box<dyn std::error::Error>),
+
+    #[cfg(feature = "wgpu")]
+    #[error("WGPU error: {0}")]
+    Wgpu(#[from] egui_wgpu::WgpuError),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+// ---------------------------------------------------------------------------
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+mod profiling_scopes {
+    /// Profiling macro for feature "puffin"
+    macro_rules! profile_function {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        puffin::profile_function!($($arg)*);
+    };
+}
+    pub(crate) use profile_function;
+
+    /// Profiling macro for feature "puffin"
+    macro_rules! profile_scope {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        puffin::profile_scope!($($arg)*);
+    };
+}
+    pub(crate) use profile_scope;
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu"))]
+pub(crate) use profiling_scopes::*;
diff --git a/egui/crates/eframe/src/native/epi_integration.rs b/egui/crates/eframe/src/native/epi_integration.rs
new file mode 100644
index 0000000..d3f40c7
--- /dev/null
+++ b/egui/crates/eframe/src/native/epi_integration.rs
@@ -0,0 +1,595 @@
+use winit::event_loop::EventLoopWindowTarget;
+
+#[cfg(target_os = "macos")]
+use winit::platform::macos::WindowBuilderExtMacOS as _;
+
+#[cfg(feature = "accesskit")]
+use egui::accesskit;
+use egui::NumExt as _;
+#[cfg(feature = "accesskit")]
+use egui_winit::accesskit_winit;
+use egui_winit::{native_pixels_per_point, EventResponse, WindowSettings};
+
+use crate::{epi, Theme, WindowInfo};
+
+#[derive(Default)]
+pub struct WindowState {
+    // We cannot simply call `winit::Window::is_minimized/is_maximized`
+    // because that deadlocks on mac.
+    pub minimized: bool,
+    pub maximized: bool,
+}
+
+pub fn points_to_size(points: egui::Vec2) -> winit::dpi::LogicalSize<f64> {
+    winit::dpi::LogicalSize {
+        width: points.x as f64,
+        height: points.y as f64,
+    }
+}
+
+pub fn read_window_info(
+    window: &winit::window::Window,
+    pixels_per_point: f32,
+    window_state: &WindowState,
+) -> WindowInfo {
+    let position = window
+        .outer_position()
+        .ok()
+        .map(|pos| pos.to_logical::<f32>(pixels_per_point.into()))
+        .map(|pos| egui::Pos2 { x: pos.x, y: pos.y });
+
+    let monitor = window.current_monitor().is_some();
+    let monitor_size = if monitor {
+        let size = window
+            .current_monitor()
+            .unwrap()
+            .size()
+            .to_logical::<f32>(pixels_per_point.into());
+        Some(egui::vec2(size.width, size.height))
+    } else {
+        None
+    };
+
+    let size = window
+        .inner_size()
+        .to_logical::<f32>(pixels_per_point.into());
+
+    // NOTE: calling window.is_minimized() or window.is_maximized() deadlocks on Mac.
+
+    WindowInfo {
+        position,
+        fullscreen: window.fullscreen().is_some(),
+        minimized: window_state.minimized,
+        maximized: window_state.maximized,
+        focused: window.has_focus(),
+        size: egui::Vec2 {
+            x: size.width,
+            y: size.height,
+        },
+        monitor_size,
+    }
+}
+
+pub fn window_builder<E>(
+    event_loop: &EventLoopWindowTarget<E>,
+    title: &str,
+    native_options: &epi::NativeOptions,
+    window_settings: Option<WindowSettings>,
+) -> winit::window::WindowBuilder {
+    let epi::NativeOptions {
+        maximized,
+        decorated,
+        fullscreen,
+        #[cfg(target_os = "macos")]
+        fullsize_content,
+        drag_and_drop_support,
+        icon_data,
+        initial_window_pos,
+        initial_window_size,
+        min_window_size,
+        max_window_size,
+        resizable,
+        transparent,
+        centered,
+        active,
+        ..
+    } = native_options;
+
+    let window_icon = icon_data.clone().and_then(load_icon);
+
+    let mut window_builder = winit::window::WindowBuilder::new()
+        .with_title(title)
+        .with_decorations(*decorated)
+        .with_fullscreen(fullscreen.then(|| winit::window::Fullscreen::Borderless(None)))
+        .with_maximized(*maximized)
+        .with_resizable(*resizable)
+        .with_transparent(*transparent)
+        .with_window_icon(window_icon)
+        .with_active(*active)
+        // Keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
+        // We must also keep the window hidden until AccessKit is initialized.
+        .with_visible(false);
+
+    #[cfg(target_os = "macos")]
+    if *fullsize_content {
+        window_builder = window_builder
+            .with_title_hidden(true)
+            .with_titlebar_transparent(true)
+            .with_fullsize_content_view(true);
+    }
+
+    if let Some(min_size) = *min_window_size {
+        window_builder = window_builder.with_min_inner_size(points_to_size(min_size));
+    }
+    if let Some(max_size) = *max_window_size {
+        window_builder = window_builder.with_max_inner_size(points_to_size(max_size));
+    }
+
+    window_builder = window_builder_drag_and_drop(window_builder, *drag_and_drop_support);
+
+    let inner_size_points = if let Some(mut window_settings) = window_settings {
+        // Restore pos/size from previous session
+        window_settings.clamp_to_sane_values(largest_monitor_point_size(event_loop));
+        #[cfg(windows)]
+        window_settings.clamp_window_to_sane_position(event_loop);
+        window_builder = window_settings.initialize_window(window_builder);
+        window_settings.inner_size_points()
+    } else {
+        if let Some(pos) = *initial_window_pos {
+            window_builder = window_builder.with_position(winit::dpi::LogicalPosition {
+                x: pos.x as f64,
+                y: pos.y as f64,
+            });
+        }
+
+        if let Some(initial_window_size) = *initial_window_size {
+            let initial_window_size =
+                initial_window_size.at_most(largest_monitor_point_size(event_loop));
+            window_builder = window_builder.with_inner_size(points_to_size(initial_window_size));
+        }
+
+        *initial_window_size
+    };
+
+    if *centered {
+        if let Some(monitor) = event_loop.available_monitors().next() {
+            let monitor_size = monitor.size().to_logical::<f64>(monitor.scale_factor());
+            let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
+            if monitor_size.width > 0.0 && monitor_size.height > 0.0 {
+                let x = (monitor_size.width - inner_size.x as f64) / 2.0;
+                let y = (monitor_size.height - inner_size.y as f64) / 2.0;
+                window_builder = window_builder.with_position(winit::dpi::LogicalPosition { x, y });
+            }
+        }
+    }
+    window_builder
+}
+
+pub fn apply_native_options_to_window(
+    window: &winit::window::Window,
+    native_options: &crate::NativeOptions,
+) {
+    use winit::window::WindowLevel;
+    window.set_window_level(if native_options.always_on_top {
+        WindowLevel::AlwaysOnTop
+    } else {
+        WindowLevel::Normal
+    });
+}
+
+fn largest_monitor_point_size<E>(event_loop: &EventLoopWindowTarget<E>) -> egui::Vec2 {
+    let mut max_size = egui::Vec2::ZERO;
+
+    for monitor in event_loop.available_monitors() {
+        let size = monitor.size().to_logical::<f32>(monitor.scale_factor());
+        let size = egui::vec2(size.width, size.height);
+        max_size = max_size.max(size);
+    }
+
+    if max_size == egui::Vec2::ZERO {
+        egui::Vec2::splat(16000.0)
+    } else {
+        max_size
+    }
+}
+
+fn load_icon(icon_data: epi::IconData) -> Option<winit::window::Icon> {
+    winit::window::Icon::from_rgba(icon_data.rgba, icon_data.width, icon_data.height).ok()
+}
+
+#[cfg(target_os = "windows")]
+fn window_builder_drag_and_drop(
+    window_builder: winit::window::WindowBuilder,
+    enable: bool,
+) -> winit::window::WindowBuilder {
+    use winit::platform::windows::WindowBuilderExtWindows as _;
+    window_builder.with_drag_and_drop(enable)
+}
+
+#[cfg(not(target_os = "windows"))]
+fn window_builder_drag_and_drop(
+    window_builder: winit::window::WindowBuilder,
+    _enable: bool,
+) -> winit::window::WindowBuilder {
+    // drag and drop can only be disabled on windows
+    window_builder
+}
+
+pub fn handle_app_output(
+    window: &winit::window::Window,
+    current_pixels_per_point: f32,
+    app_output: epi::backend::AppOutput,
+    window_state: &mut WindowState,
+) {
+    let epi::backend::AppOutput {
+        close: _,
+        window_size,
+        window_title,
+        decorated,
+        fullscreen,
+        drag_window,
+        window_pos,
+        visible: _, // handled in post_present
+        always_on_top,
+        screenshot_requested: _, // handled by the rendering backend,
+        minimized,
+        maximized,
+        focus,
+    } = app_output;
+
+    if let Some(decorated) = decorated {
+        window.set_decorations(decorated);
+    }
+
+    if let Some(window_size) = window_size {
+        window.set_inner_size(
+            winit::dpi::PhysicalSize {
+                width: (current_pixels_per_point * window_size.x).round(),
+                height: (current_pixels_per_point * window_size.y).round(),
+            }
+            .to_logical::<f32>(native_pixels_per_point(window) as f64),
+        );
+    }
+
+    if let Some(fullscreen) = fullscreen {
+        window.set_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None)));
+    }
+
+    if let Some(window_title) = window_title {
+        window.set_title(&window_title);
+    }
+
+    if let Some(window_pos) = window_pos {
+        window.set_outer_position(winit::dpi::LogicalPosition {
+            x: window_pos.x as f64,
+            y: window_pos.y as f64,
+        });
+    }
+
+    if drag_window {
+        let _ = window.drag_window();
+    }
+
+    if let Some(always_on_top) = always_on_top {
+        use winit::window::WindowLevel;
+        window.set_window_level(if always_on_top {
+            WindowLevel::AlwaysOnTop
+        } else {
+            WindowLevel::Normal
+        });
+    }
+
+    if let Some(minimized) = minimized {
+        window.set_minimized(minimized);
+        window_state.minimized = minimized;
+    }
+
+    if let Some(maximized) = maximized {
+        window.set_maximized(maximized);
+        window_state.maximized = maximized;
+    }
+
+    if focus == Some(true) {
+        window.focus_window();
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// For loading/saving app state and/or egui memory to disk.
+pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
+    #[cfg(feature = "persistence")]
+    if let Some(storage) = super::file_storage::FileStorage::from_app_name(_app_name) {
+        return Some(Box::new(storage));
+    }
+    None
+}
+
+// ----------------------------------------------------------------------------
+
+/// Everything needed to make a winit-based integration for [`epi`].
+pub struct EpiIntegration {
+    pub frame: epi::Frame,
+    last_auto_save: std::time::Instant,
+    pub egui_ctx: egui::Context,
+    pending_full_output: egui::FullOutput,
+    egui_winit: egui_winit::State,
+    /// When set, it is time to close the native window.
+    close: bool,
+    can_drag_window: bool,
+    window_state: WindowState,
+    follow_system_theme: bool,
+}
+
+impl EpiIntegration {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new<E>(
+        event_loop: &EventLoopWindowTarget<E>,
+        max_texture_side: usize,
+        window: &winit::window::Window,
+        system_theme: Option<Theme>,
+        follow_system_theme: bool,
+        storage: Option<Box<dyn epi::Storage>>,
+        #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
+        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
+    ) -> Self {
+        let egui_ctx = egui::Context::default();
+
+        let memory = load_egui_memory(storage.as_deref()).unwrap_or_default();
+        egui_ctx.memory_mut(|mem| *mem = memory);
+
+        let native_pixels_per_point = window.scale_factor() as f32;
+
+        let window_state = WindowState {
+            minimized: window.is_minimized().unwrap_or(false),
+            maximized: window.is_maximized(),
+        };
+
+        let frame = epi::Frame {
+            info: epi::IntegrationInfo {
+                system_theme,
+                cpu_usage: None,
+                native_pixels_per_point: Some(native_pixels_per_point),
+                window_info: read_window_info(window, egui_ctx.pixels_per_point(), &window_state),
+            },
+            output: epi::backend::AppOutput {
+                visible: Some(true),
+                ..Default::default()
+            },
+            storage,
+            #[cfg(feature = "glow")]
+            gl,
+            #[cfg(feature = "wgpu")]
+            wgpu_render_state,
+            screenshot: std::cell::Cell::new(None),
+        };
+
+        let mut egui_winit = egui_winit::State::new(event_loop);
+        egui_winit.set_max_texture_side(max_texture_side);
+        egui_winit.set_pixels_per_point(native_pixels_per_point);
+
+        Self {
+            frame,
+            last_auto_save: std::time::Instant::now(),
+            egui_ctx,
+            egui_winit,
+            pending_full_output: Default::default(),
+            close: false,
+            can_drag_window: false,
+            window_state,
+            follow_system_theme,
+        }
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub fn init_accesskit<E: From<accesskit_winit::ActionRequestEvent> + Send>(
+        &mut self,
+        window: &winit::window::Window,
+        event_loop_proxy: winit::event_loop::EventLoopProxy<E>,
+    ) {
+        let egui_ctx = self.egui_ctx.clone();
+        self.egui_winit
+            .init_accesskit(window, event_loop_proxy, move || {
+                // This function is called when an accessibility client
+                // (e.g. screen reader) makes its first request. If we got here,
+                // we know that an accessibility tree is actually wanted.
+                egui_ctx.enable_accesskit();
+                // Enqueue a repaint so we'll receive a full tree update soon.
+                egui_ctx.request_repaint();
+                egui_ctx.accesskit_placeholder_tree_update()
+            });
+    }
+
+    pub fn warm_up(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
+        crate::profile_function!();
+        let saved_memory: egui::Memory = self.egui_ctx.memory(|mem| mem.clone());
+        self.egui_ctx
+            .memory_mut(|mem| mem.set_everything_is_visible(true));
+        let full_output = self.update(app, window);
+        self.pending_full_output.append(full_output); // Handle it next frame
+        self.egui_ctx.memory_mut(|mem| *mem = saved_memory); // We don't want to remember that windows were huge.
+        self.egui_ctx.clear_animations();
+    }
+
+    /// If `true`, it is time to close the native window.
+    pub fn should_close(&self) -> bool {
+        self.close
+    }
+
+    pub fn on_event(
+        &mut self,
+        app: &mut dyn epi::App,
+        event: &winit::event::WindowEvent<'_>,
+    ) -> EventResponse {
+        use winit::event::{ElementState, MouseButton, WindowEvent};
+
+        match event {
+            WindowEvent::CloseRequested => {
+                tracing::debug!("Received WindowEvent::CloseRequested");
+                self.close = app.on_close_event();
+                tracing::debug!("App::on_close_event returned {}", self.close);
+            }
+            WindowEvent::Destroyed => {
+                tracing::debug!("Received WindowEvent::Destroyed");
+                self.close = true;
+            }
+            WindowEvent::MouseInput {
+                button: MouseButton::Left,
+                state: ElementState::Pressed,
+                ..
+            } => self.can_drag_window = true,
+            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
+                self.frame.info.native_pixels_per_point = Some(*scale_factor as _);
+            }
+            WindowEvent::ThemeChanged(winit_theme) if self.follow_system_theme => {
+                let theme = theme_from_winit_theme(*winit_theme);
+                self.frame.info.system_theme = Some(theme);
+                self.egui_ctx.set_visuals(theme.egui_visuals());
+            }
+            _ => {}
+        }
+
+        self.egui_winit.on_event(&self.egui_ctx, event)
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub fn on_accesskit_action_request(&mut self, request: accesskit::ActionRequest) {
+        self.egui_winit.on_accesskit_action_request(request);
+    }
+
+    pub fn update(
+        &mut self,
+        app: &mut dyn epi::App,
+        window: &winit::window::Window,
+    ) -> egui::FullOutput {
+        let frame_start = std::time::Instant::now();
+
+        self.frame.info.window_info =
+            read_window_info(window, self.egui_ctx.pixels_per_point(), &self.window_state);
+        let raw_input = self.egui_winit.take_egui_input(window);
+
+        // Run user code:
+        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
+            crate::profile_scope!("App::update");
+            app.update(egui_ctx, &mut self.frame);
+        });
+
+        self.pending_full_output.append(full_output);
+        let full_output = std::mem::take(&mut self.pending_full_output);
+
+        {
+            let mut app_output = self.frame.take_app_output();
+            app_output.drag_window &= self.can_drag_window; // Necessary on Windows; see https://github.com/emilk/egui/pull/1108
+            self.can_drag_window = false;
+            if app_output.close {
+                self.close = app.on_close_event();
+                tracing::debug!("App::on_close_event returned {}", self.close);
+            }
+            self.frame.output.visible = app_output.visible; // this is handled by post_present
+            self.frame.output.screenshot_requested = app_output.screenshot_requested;
+            handle_app_output(
+                window,
+                self.egui_ctx.pixels_per_point(),
+                app_output,
+                &mut self.window_state,
+            );
+        }
+
+        let frame_time = frame_start.elapsed().as_secs_f64() as f32;
+        self.frame.info.cpu_usage = Some(frame_time);
+
+        full_output
+    }
+
+    pub fn post_rendering(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
+        let inner_size = window.inner_size();
+        let window_size_px = [inner_size.width, inner_size.height];
+
+        app.post_rendering(window_size_px, &self.frame);
+    }
+
+    pub fn post_present(&mut self, window: &winit::window::Window) {
+        if let Some(visible) = self.frame.output.visible.take() {
+            window.set_visible(visible);
+        }
+    }
+
+    pub fn handle_platform_output(
+        &mut self,
+        window: &winit::window::Window,
+        platform_output: egui::PlatformOutput,
+    ) {
+        self.egui_winit
+            .handle_platform_output(window, &self.egui_ctx, platform_output);
+    }
+
+    // ------------------------------------------------------------------------
+    // Persistence stuff:
+
+    pub fn maybe_autosave(&mut self, app: &mut dyn epi::App, window: &winit::window::Window) {
+        let now = std::time::Instant::now();
+        if now - self.last_auto_save > app.auto_save_interval() {
+            self.save(app, window);
+            self.last_auto_save = now;
+        }
+    }
+
+    pub fn save(&mut self, _app: &mut dyn epi::App, _window: &winit::window::Window) {
+        #[cfg(feature = "persistence")]
+        if let Some(storage) = self.frame.storage_mut() {
+            crate::profile_function!();
+
+            if _app.persist_native_window() {
+                crate::profile_scope!("native_window");
+                epi::set_value(
+                    storage,
+                    STORAGE_WINDOW_KEY,
+                    &WindowSettings::from_display(_window),
+                );
+            }
+            if _app.persist_egui_memory() {
+                crate::profile_scope!("egui_memory");
+                self.egui_ctx
+                    .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
+            }
+            {
+                crate::profile_scope!("App::save");
+                _app.save(storage);
+            }
+
+            crate::profile_scope!("Storage::flush");
+            storage.flush();
+        }
+    }
+}
+
+#[cfg(feature = "persistence")]
+const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
+
+#[cfg(feature = "persistence")]
+const STORAGE_WINDOW_KEY: &str = "window";
+
+pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Option<WindowSettings> {
+    #[cfg(feature = "persistence")]
+    {
+        epi::get_value(_storage?, STORAGE_WINDOW_KEY)
+    }
+    #[cfg(not(feature = "persistence"))]
+    None
+}
+
+pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<egui::Memory> {
+    #[cfg(feature = "persistence")]
+    {
+        epi::get_value(_storage?, STORAGE_EGUI_MEMORY_KEY)
+    }
+    #[cfg(not(feature = "persistence"))]
+    None
+}
+
+pub(crate) fn theme_from_winit_theme(theme: winit::window::Theme) -> Theme {
+    match theme {
+        winit::window::Theme::Dark => Theme::Dark,
+        winit::window::Theme::Light => Theme::Light,
+    }
+}
diff --git a/egui/crates/eframe/src/native/file_storage.rs b/egui/crates/eframe/src/native/file_storage.rs
new file mode 100644
index 0000000..331f40f
--- /dev/null
+++ b/egui/crates/eframe/src/native/file_storage.rs
@@ -0,0 +1,117 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+// ----------------------------------------------------------------------------
+
+/// A key-value store backed by a [RON](https://github.com/ron-rs/ron) file on disk.
+/// Used to restore egui state, glium window position/size and app state.
+pub struct FileStorage {
+    ron_filepath: PathBuf,
+    kv: HashMap<String, String>,
+    dirty: bool,
+    last_save_join_handle: Option<std::thread::JoinHandle<()>>,
+}
+
+impl Drop for FileStorage {
+    fn drop(&mut self) {
+        if let Some(join_handle) = self.last_save_join_handle.take() {
+            join_handle.join().ok();
+        }
+    }
+}
+
+impl FileStorage {
+    /// Store the state in this .ron file.
+    pub fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
+        let ron_filepath: PathBuf = ron_filepath.into();
+        tracing::debug!("Loading app state from {:?}…", ron_filepath);
+        Self {
+            kv: read_ron(&ron_filepath).unwrap_or_default(),
+            ron_filepath,
+            dirty: false,
+            last_save_join_handle: None,
+        }
+    }
+
+    /// Find a good place to put the files that the OS likes.
+    pub fn from_app_name(app_name: &str) -> Option<Self> {
+        if let Some(proj_dirs) = directories_next::ProjectDirs::from("", "", app_name) {
+            let data_dir = proj_dirs.data_dir().to_path_buf();
+            if let Err(err) = std::fs::create_dir_all(&data_dir) {
+                tracing::warn!(
+                    "Saving disabled: Failed to create app path at {:?}: {}",
+                    data_dir,
+                    err
+                );
+                None
+            } else {
+                Some(Self::from_ron_filepath(data_dir.join("app.ron")))
+            }
+        } else {
+            tracing::warn!("Saving disabled: Failed to find path to data_dir.");
+            None
+        }
+    }
+}
+
+impl crate::Storage for FileStorage {
+    fn get_string(&self, key: &str) -> Option<String> {
+        self.kv.get(key).cloned()
+    }
+
+    fn set_string(&mut self, key: &str, value: String) {
+        if self.kv.get(key) != Some(&value) {
+            self.kv.insert(key.to_owned(), value);
+            self.dirty = true;
+        }
+    }
+
+    fn flush(&mut self) {
+        if self.dirty {
+            self.dirty = false;
+
+            let file_path = self.ron_filepath.clone();
+            let kv = self.kv.clone();
+
+            if let Some(join_handle) = self.last_save_join_handle.take() {
+                // wait for previous save to complete.
+                join_handle.join().ok();
+            }
+
+            let join_handle = std::thread::spawn(move || {
+                let file = std::fs::File::create(&file_path).unwrap();
+                let config = Default::default();
+                ron::ser::to_writer_pretty(file, &kv, config).unwrap();
+                tracing::trace!("Persisted to {:?}", file_path);
+            });
+
+            self.last_save_join_handle = Some(join_handle);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn read_ron<T>(ron_path: impl AsRef<Path>) -> Option<T>
+where
+    T: serde::de::DeserializeOwned,
+{
+    match std::fs::File::open(ron_path) {
+        Ok(file) => {
+            let reader = std::io::BufReader::new(file);
+            match ron::de::from_reader(reader) {
+                Ok(value) => Some(value),
+                Err(err) => {
+                    tracing::warn!("Failed to parse RON: {}", err);
+                    None
+                }
+            }
+        }
+        Err(_err) => {
+            // File probably doesn't exist. That's fine.
+            None
+        }
+    }
+}
diff --git a/egui/crates/eframe/src/native/mod.rs b/egui/crates/eframe/src/native/mod.rs
new file mode 100644
index 0000000..3718d60
--- /dev/null
+++ b/egui/crates/eframe/src/native/mod.rs
@@ -0,0 +1,6 @@
+mod epi_integration;
+pub mod run;
+
+/// File storage which can be used by native backends.
+#[cfg(feature = "persistence")]
+pub mod file_storage;
diff --git a/egui/crates/eframe/src/native/run.rs b/egui/crates/eframe/src/native/run.rs
new file mode 100644
index 0000000..e53ecec
--- /dev/null
+++ b/egui/crates/eframe/src/native/run.rs
@@ -0,0 +1,1462 @@
+//! Note that this file contains two similar paths - one for [`glow`], one for [`wgpu`].
+//! When making changes to one you often also want to apply it to the other.
+
+use std::time::{Duration, Instant};
+
+use winit::event_loop::{
+    ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy, EventLoopWindowTarget,
+};
+
+#[cfg(feature = "accesskit")]
+use egui_winit::accesskit_winit;
+use egui_winit::winit;
+
+use crate::{epi, Result};
+
+use super::epi_integration::{self, EpiIntegration};
+
+// ----------------------------------------------------------------------------
+
+#[derive(Debug)]
+pub enum UserEvent {
+    RequestRepaint,
+    #[cfg(feature = "accesskit")]
+    AccessKitActionRequest(accesskit_winit::ActionRequestEvent),
+}
+
+#[cfg(feature = "accesskit")]
+impl From<accesskit_winit::ActionRequestEvent> for UserEvent {
+    fn from(inner: accesskit_winit::ActionRequestEvent) -> Self {
+        Self::AccessKitActionRequest(inner)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub use epi::NativeOptions;
+
+#[derive(Debug)]
+enum EventResult {
+    Wait,
+
+    /// Causes a synchronous repaint inside the event handler. This should only
+    /// be used in special situations if the window must be repainted while
+    /// handling a specific event. This occurs on Windows when handling resizes.
+    ///
+    /// `RepaintNow` creates a new frame synchronously, and should therefore
+    /// only be used for extremely urgent repaints.
+    RepaintNow,
+
+    /// Queues a repaint for once the event loop handles its next redraw. Exists
+    /// so that multiple input events can be handled in one frame. Does not
+    /// cause any delay like `RepaintNow`.
+    RepaintNext,
+
+    RepaintAt(Instant),
+
+    Exit,
+}
+
+trait WinitApp {
+    fn is_focused(&self) -> bool;
+
+    fn integration(&self) -> Option<&EpiIntegration>;
+
+    fn window(&self) -> Option<&winit::window::Window>;
+
+    fn save_and_destroy(&mut self);
+
+    fn paint(&mut self) -> EventResult;
+
+    fn on_event(
+        &mut self,
+        event_loop: &EventLoopWindowTarget<UserEvent>,
+        event: &winit::event::Event<'_, UserEvent>,
+    ) -> Result<EventResult>;
+}
+
+fn create_event_loop_builder(
+    native_options: &mut epi::NativeOptions,
+) -> EventLoopBuilder<UserEvent> {
+    let mut event_loop_builder = winit::event_loop::EventLoopBuilder::with_user_event();
+
+    if let Some(hook) = std::mem::take(&mut native_options.event_loop_builder) {
+        hook(&mut event_loop_builder);
+    }
+
+    event_loop_builder
+}
+
+/// Access a thread-local event loop.
+///
+/// We reuse the event-loop so we can support closing and opening an eframe window
+/// multiple times. This is just a limitation of winit.
+fn with_event_loop<R>(
+    mut native_options: epi::NativeOptions,
+    f: impl FnOnce(&mut EventLoop<UserEvent>, NativeOptions) -> R,
+) -> R {
+    use std::cell::RefCell;
+    thread_local!(static EVENT_LOOP: RefCell<Option<EventLoop<UserEvent>>> = RefCell::new(None));
+
+    EVENT_LOOP.with(|event_loop| {
+        // Since we want to reference NativeOptions when creating the EventLoop we can't
+        // do that as part of the lazy thread local storage initialization and so we instead
+        // create the event loop lazily here
+        let mut event_loop = event_loop.borrow_mut();
+        let event_loop = event_loop
+            .get_or_insert_with(|| create_event_loop_builder(&mut native_options).build());
+        f(event_loop, native_options)
+    })
+}
+
+fn run_and_return(
+    event_loop: &mut EventLoop<UserEvent>,
+    mut winit_app: impl WinitApp,
+) -> Result<()> {
+    use winit::platform::run_return::EventLoopExtRunReturn as _;
+
+    tracing::debug!("Entering the winit event loop (run_return)…");
+
+    let mut next_repaint_time = Instant::now();
+
+    let mut returned_result = Ok(());
+
+    event_loop.run_return(|event, event_loop, control_flow| {
+        let event_result = match &event {
+            winit::event::Event::LoopDestroyed => {
+                // On Mac, Cmd-Q we get here and then `run_return` doesn't return (despite its name),
+                // so we need to save state now:
+                tracing::debug!("Received Event::LoopDestroyed - saving app state…");
+                winit_app.save_and_destroy();
+                *control_flow = ControlFlow::Exit;
+                return;
+            }
+
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+
+            winit::event::Event::UserEvent(UserEvent::RequestRepaint)
+            | winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => EventResult::RepaintNext,
+
+            winit::event::Event::WindowEvent { window_id, .. }
+                if winit_app.window().is_none()
+                    || *window_id != winit_app.window().unwrap().id() =>
+            {
+                // This can happen if we close a window, and then reopen a new one,
+                // or if we have multiple windows open.
+                EventResult::Wait
+            }
+
+            event => match winit_app.on_event(event_loop, event) {
+                Ok(event_result) => event_result,
+                Err(err) => {
+                    tracing::error!("Exiting because of error: {err:?} on event {event:?}");
+                    returned_result = Err(err);
+                    EventResult::Exit
+                }
+            },
+        };
+
+        match event_result {
+            EventResult::Wait => {}
+            EventResult::RepaintNow => {
+                tracing::trace!("Repaint caused by winit::Event: {:?}", event);
+                if cfg!(windows) {
+                    // Fix flickering on Windows, see https://github.com/emilk/egui/pull/2280
+                    next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                    winit_app.paint();
+                } else {
+                    // Fix for https://github.com/emilk/egui/issues/2425
+                    next_repaint_time = Instant::now();
+                }
+            }
+            EventResult::RepaintNext => {
+                tracing::trace!("Repaint caused by winit::Event: {:?}", event);
+                next_repaint_time = Instant::now();
+            }
+            EventResult::RepaintAt(repaint_time) => {
+                next_repaint_time = next_repaint_time.min(repaint_time);
+            }
+            EventResult::Exit => {
+                tracing::debug!("Asking to exit event loop…");
+                winit_app.save_and_destroy();
+                *control_flow = ControlFlow::Exit;
+                return;
+            }
+        }
+
+        *control_flow = match next_repaint_time.checked_duration_since(Instant::now()) {
+            None => {
+                if let Some(window) = winit_app.window() {
+                    window.request_redraw();
+                }
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                ControlFlow::Poll
+            }
+            Some(time_until_next_repaint) => {
+                ControlFlow::WaitUntil(Instant::now() + time_until_next_repaint)
+            }
+        }
+    });
+
+    tracing::debug!("eframe window closed");
+
+    drop(winit_app);
+
+    // On Windows this clears out events so that we can later create another window.
+    // See https://github.com/emilk/egui/pull/1889 for details.
+    event_loop.run_return(|_, _, control_flow| {
+        control_flow.set_exit();
+    });
+
+    returned_result
+}
+
+fn run_and_exit(event_loop: EventLoop<UserEvent>, mut winit_app: impl WinitApp + 'static) -> ! {
+    tracing::debug!("Entering the winit event loop (run)…");
+
+    let mut next_repaint_time = Instant::now();
+
+    event_loop.run(move |event, event_loop, control_flow| {
+        let event_result = match event {
+            winit::event::Event::LoopDestroyed => {
+                tracing::debug!("Received Event::LoopDestroyed");
+                EventResult::Exit
+            }
+
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => {
+                next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                winit_app.paint()
+            }
+
+            winit::event::Event::UserEvent(UserEvent::RequestRepaint)
+            | winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => EventResult::RepaintNext,
+
+            event => match winit_app.on_event(event_loop, &event) {
+                Ok(event_result) => event_result,
+                Err(err) => {
+                    panic!("eframe encountered a fatal error: {err}");
+                }
+            },
+        };
+
+        match event_result {
+            EventResult::Wait => {}
+            EventResult::RepaintNow => {
+                if cfg!(windows) {
+                    // Fix flickering on Windows, see https://github.com/emilk/egui/pull/2280
+                    next_repaint_time = Instant::now() + Duration::from_secs(1_000_000_000);
+                    winit_app.paint();
+                } else {
+                    // Fix for https://github.com/emilk/egui/issues/2425
+                    next_repaint_time = Instant::now();
+                }
+            }
+            EventResult::RepaintNext => {
+                next_repaint_time = Instant::now();
+            }
+            EventResult::RepaintAt(repaint_time) => {
+                next_repaint_time = next_repaint_time.min(repaint_time);
+            }
+            EventResult::Exit => {
+                tracing::debug!("Quitting - saving app state…");
+                winit_app.save_and_destroy();
+                #[allow(clippy::exit)]
+                std::process::exit(0);
+            }
+        }
+
+        *control_flow = match next_repaint_time.checked_duration_since(Instant::now()) {
+            None => {
+                if let Some(window) = winit_app.window() {
+                    window.request_redraw();
+                }
+                ControlFlow::Poll
+            }
+            Some(time_until_next_repaint) => {
+                ControlFlow::WaitUntil(Instant::now() + time_until_next_repaint)
+            }
+        }
+    })
+}
+
+// ----------------------------------------------------------------------------
+/// Run an egui app
+#[cfg(feature = "glow")]
+mod glow_integration {
+    use std::sync::Arc;
+
+    use egui::NumExt as _;
+    use glutin::{
+        display::GetGlDisplay,
+        prelude::{GlDisplay, NotCurrentGlContextSurfaceAccessor, PossiblyCurrentGlContext},
+        surface::GlSurface,
+    };
+    use raw_window_handle::HasRawWindowHandle;
+
+    use super::*;
+
+    // Note: that the current Glutin API design tightly couples the GL context with
+    // the Window which means it's not practically possible to just destroy the
+    // window and re-create a new window while continuing to use the same GL context.
+    //
+    // For now this means it's not possible to support Android as well as we can with
+    // wgpu because we're basically forced to destroy and recreate _everything_ when
+    // the application suspends and resumes.
+    //
+    // There is work in progress to improve the Glutin API so it has a separate Surface
+    // API that would allow us to just destroy a Window/Surface when suspending, see:
+    // https://github.com/rust-windowing/glutin/pull/1435
+    //
+
+    /// State that is initialized when the application is first starts running via
+    /// a Resumed event. On Android this ensures that any graphics state is only
+    /// initialized once the application has an associated `SurfaceView`.
+    struct GlowWinitRunning {
+        gl: Arc<glow::Context>,
+        painter: egui_glow::Painter,
+        integration: epi_integration::EpiIntegration,
+        app: Box<dyn epi::App>,
+        // Conceptually this will be split out eventually so that the rest of the state
+        // can be persistent.
+        gl_window: GlutinWindowContext,
+    }
+
+    /// This struct will contain both persistent and temporary glutin state.
+    ///
+    /// Platform Quirks:
+    /// * Microsoft Windows: requires that we create a window before opengl context.
+    /// * Android: window and surface should be destroyed when we receive a suspend event. recreate on resume event.
+    ///
+    /// winit guarantees that we will get a Resumed event on startup on all platforms.
+    /// * Before Resumed event: `gl_config`, `gl_context` can be created at any time. on windows, a window must be created to get `gl_context`.
+    /// * Resumed: `gl_surface` will be created here. `window` will be re-created here for android.
+    /// * Suspended: on android, we drop window + surface.  on other platforms, we don't get Suspended event.
+    ///
+    /// The setup is divided between the `new` fn and `on_resume` fn. we can just assume that `on_resume` is a continuation of
+    /// `new` fn on all platforms. only on android, do we get multiple resumed events because app can be suspended.
+    struct GlutinWindowContext {
+        builder: winit::window::WindowBuilder,
+        swap_interval: glutin::surface::SwapInterval,
+        gl_config: glutin::config::Config,
+        current_gl_context: Option<glutin::context::PossiblyCurrentContext>,
+        gl_surface: Option<glutin::surface::Surface<glutin::surface::WindowSurface>>,
+        not_current_gl_context: Option<glutin::context::NotCurrentContext>,
+        window: Option<winit::window::Window>,
+    }
+
+    impl GlutinWindowContext {
+        /// There is a lot of complexity with opengl creation, so prefer extensive logging to get all the help we can to debug issues.
+        ///
+        #[allow(unsafe_code)]
+        unsafe fn new(
+            winit_window_builder: winit::window::WindowBuilder,
+            native_options: &epi::NativeOptions,
+            event_loop: &EventLoopWindowTarget<UserEvent>,
+        ) -> Result<Self> {
+            use glutin::prelude::*;
+            // convert native options to glutin options
+            let hardware_acceleration = match native_options.hardware_acceleration {
+                crate::HardwareAcceleration::Required => Some(true),
+                crate::HardwareAcceleration::Preferred => None,
+                crate::HardwareAcceleration::Off => Some(false),
+            };
+            let swap_interval = if native_options.vsync {
+                glutin::surface::SwapInterval::Wait(std::num::NonZeroU32::new(1).unwrap())
+            } else {
+                glutin::surface::SwapInterval::DontWait
+            };
+            /*  opengl setup flow goes like this:
+                1. we create a configuration for opengl "Display" / "Config" creation
+                2. choose between special extensions like glx or egl or wgl and use them to create config/display
+                3. opengl context configuration
+                4. opengl context creation
+            */
+            // start building config for gl display
+            let config_template_builder = glutin::config::ConfigTemplateBuilder::new()
+                .prefer_hardware_accelerated(hardware_acceleration)
+                .with_depth_size(native_options.depth_buffer)
+                .with_stencil_size(native_options.stencil_buffer)
+                .with_transparency(native_options.transparent);
+            // we don't know if multi sampling option is set. so, check if its more than 0.
+            let config_template_builder = if native_options.multisampling > 0 {
+                config_template_builder.with_multisampling(
+                    native_options
+                        .multisampling
+                        .try_into()
+                        .expect("failed to fit multisamples option of native_options into u8"),
+                )
+            } else {
+                config_template_builder
+            };
+
+            tracing::debug!(
+                "trying to create glutin Display with config: {:?}",
+                &config_template_builder
+            );
+            // create gl display. this may probably create a window too on most platforms. definitely on `MS windows`. never on android.
+            let (window, gl_config) = glutin_winit::DisplayBuilder::new()
+                // we might want to expose this option to users in the future. maybe using an env var or using native_options.
+                .with_preference(glutin_winit::ApiPrefence::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150
+                .with_window_builder(Some(winit_window_builder.clone()))
+                .build(
+                    event_loop,
+                    config_template_builder.clone(),
+                    |mut config_iterator| {
+                        let config = config_iterator.next().expect(
+                            "failed to find a matching configuration for creating glutin config",
+                        );
+                        tracing::debug!(
+                            "using the first config from config picker closure. config: {:?}",
+                            &config
+                        );
+                        config
+                    },
+                )
+                .map_err(|e| crate::Error::NoGlutinConfigs(config_template_builder.build(), e))?;
+
+            let gl_display = gl_config.display();
+            tracing::debug!(
+                "successfully created GL Display with version: {} and supported features: {:?}",
+                gl_display.version_string(),
+                gl_display.supported_features()
+            );
+            let raw_window_handle = window.as_ref().map(|w| w.raw_window_handle());
+            tracing::debug!(
+                "creating gl context using raw window handle: {:?}",
+                raw_window_handle
+            );
+
+            // create gl context. if core context cannot be created, try gl es context as fallback.
+            let context_attributes =
+                glutin::context::ContextAttributesBuilder::new().build(raw_window_handle);
+            let fallback_context_attributes = glutin::context::ContextAttributesBuilder::new()
+                .with_context_api(glutin::context::ContextApi::Gles(None))
+                .build(raw_window_handle);
+            let gl_context = match gl_config
+                .display()
+                .create_context(&gl_config, &context_attributes)
+            {
+                Ok(it) => it,
+                Err(err) => {
+                    tracing::warn!("failed to create context using default context attributes {context_attributes:?} due to error: {err}");
+                    tracing::debug!("retrying with fallback context attributes: {fallback_context_attributes:?}");
+                    gl_config
+                        .display()
+                        .create_context(&gl_config, &fallback_context_attributes)?
+                }
+            };
+            let not_current_gl_context = Some(gl_context);
+
+            // the fun part with opengl gl is that we never know whether there is an error. the context creation might have failed, but
+            // it could keep working until we try to make surface current or swap buffers or something else. future glutin improvements might
+            // help us start from scratch again if we fail context creation and go back to preferEgl or try with different config etc..
+            // https://github.com/emilk/egui/pull/2541#issuecomment-1370767582
+            Ok(GlutinWindowContext {
+                builder: winit_window_builder,
+                swap_interval,
+                gl_config,
+                current_gl_context: None,
+                window,
+                gl_surface: None,
+                not_current_gl_context,
+            })
+        }
+
+        /// This will be run after `new`. on android, it might be called multiple times over the course of the app's lifetime.
+        /// roughly,
+        /// 1. check if window already exists. otherwise, create one now.
+        /// 2. create attributes for surface creation.
+        /// 3. create surface.
+        /// 4. make surface and context current.
+        ///
+        /// we presently assume that we will
+        #[allow(unsafe_code)]
+        fn on_resume(&mut self, event_loop: &EventLoopWindowTarget<UserEvent>) -> Result<()> {
+            if self.gl_surface.is_some() {
+                tracing::warn!(
+                    "on_resume called even thought we already have a surface. early return"
+                );
+                return Ok(());
+            }
+            tracing::debug!("running on_resume fn.");
+            // make sure we have a window or create one.
+            let window = self.window.take().unwrap_or_else(|| {
+                tracing::debug!("window doesn't exist yet. creating one now with finalize_window");
+                glutin_winit::finalize_window(event_loop, self.builder.clone(), &self.gl_config)
+                    .expect("failed to finalize glutin window")
+            });
+            // surface attributes
+            let (width, height): (u32, u32) = window.inner_size().into();
+            let width = std::num::NonZeroU32::new(width.at_least(1)).unwrap();
+            let height = std::num::NonZeroU32::new(height.at_least(1)).unwrap();
+            let surface_attributes =
+                glutin::surface::SurfaceAttributesBuilder::<glutin::surface::WindowSurface>::new()
+                    .build(window.raw_window_handle(), width, height);
+            tracing::debug!(
+                "creating surface with attributes: {:?}",
+                &surface_attributes
+            );
+            // create surface
+            let gl_surface = unsafe {
+                self.gl_config
+                    .display()
+                    .create_window_surface(&self.gl_config, &surface_attributes)?
+            };
+            tracing::debug!("surface created successfully: {gl_surface:?}.making context current");
+            // make surface and context current.
+            let not_current_gl_context = self
+                .not_current_gl_context
+                .take()
+                .expect("failed to get not current context after resume event. impossible!");
+            let current_gl_context = not_current_gl_context.make_current(&gl_surface)?;
+            // try setting swap interval. but its not absolutely necessary, so don't panic on failure.
+            tracing::debug!("made context current. setting swap interval for surface");
+            if let Err(e) = gl_surface.set_swap_interval(&current_gl_context, self.swap_interval) {
+                tracing::error!("failed to set swap interval due to error: {e:?}");
+            }
+            // we will reach this point only once in most platforms except android.
+            // create window/surface/make context current once and just use them forever.
+            self.gl_surface = Some(gl_surface);
+            self.current_gl_context = Some(current_gl_context);
+            self.window = Some(window);
+            Ok(())
+        }
+
+        /// only applies for android. but we basically drop surface + window and make context not current
+        fn on_suspend(&mut self) -> Result<()> {
+            tracing::debug!("received suspend event. dropping window and surface");
+            self.gl_surface.take();
+            self.window.take();
+            if let Some(current) = self.current_gl_context.take() {
+                tracing::debug!("context is current, so making it non-current");
+                self.not_current_gl_context = Some(current.make_not_current()?);
+            } else {
+                tracing::debug!(
+                    "context is already not current??? could be duplicate suspend event"
+                );
+            }
+            Ok(())
+        }
+
+        fn window(&self) -> &winit::window::Window {
+            self.window.as_ref().expect("winit window doesn't exist")
+        }
+
+        fn resize(&self, physical_size: winit::dpi::PhysicalSize<u32>) {
+            let width = std::num::NonZeroU32::new(physical_size.width.at_least(1)).unwrap();
+            let height = std::num::NonZeroU32::new(physical_size.height.at_least(1)).unwrap();
+            self.gl_surface
+                .as_ref()
+                .expect("failed to get surface to resize")
+                .resize(
+                    self.current_gl_context
+                        .as_ref()
+                        .expect("failed to get current context to resize surface"),
+                    width,
+                    height,
+                );
+        }
+
+        fn swap_buffers(&self) -> glutin::error::Result<()> {
+            self.gl_surface
+                .as_ref()
+                .expect("failed to get surface to swap buffers")
+                .swap_buffers(
+                    self.current_gl_context
+                        .as_ref()
+                        .expect("failed to get current context to swap buffers"),
+                )
+        }
+
+        fn get_proc_address(&self, addr: &std::ffi::CStr) -> *const std::ffi::c_void {
+            self.gl_config.display().get_proc_address(addr)
+        }
+    }
+
+    struct GlowWinitApp {
+        repaint_proxy: Arc<egui::mutex::Mutex<EventLoopProxy<UserEvent>>>,
+        app_name: String,
+        native_options: epi::NativeOptions,
+        running: Option<GlowWinitRunning>,
+
+        // Note that since this `AppCreator` is FnOnce we are currently unable to support
+        // re-initializing the `GlowWinitRunning` state on Android if the application
+        // suspends and resumes.
+        app_creator: Option<epi::AppCreator>,
+        is_focused: bool,
+
+        frame_nr: u64,
+    }
+
+    impl GlowWinitApp {
+        fn new(
+            event_loop: &EventLoop<UserEvent>,
+            app_name: &str,
+            native_options: epi::NativeOptions,
+            app_creator: epi::AppCreator,
+        ) -> Self {
+            Self {
+                repaint_proxy: Arc::new(egui::mutex::Mutex::new(event_loop.create_proxy())),
+                app_name: app_name.to_owned(),
+                native_options,
+                running: None,
+                app_creator: Some(app_creator),
+                is_focused: true,
+                frame_nr: 0,
+            }
+        }
+
+        #[allow(unsafe_code)]
+        fn create_glutin_windowed_context(
+            event_loop: &EventLoopWindowTarget<UserEvent>,
+            storage: Option<&dyn epi::Storage>,
+            title: &str,
+            native_options: &NativeOptions,
+        ) -> Result<(GlutinWindowContext, glow::Context)> {
+            crate::profile_function!();
+
+            let window_settings = epi_integration::load_window_settings(storage);
+
+            let winit_window_builder =
+                epi_integration::window_builder(event_loop, title, native_options, window_settings);
+            let mut glutin_window_context = unsafe {
+                GlutinWindowContext::new(winit_window_builder, native_options, event_loop)?
+            };
+            glutin_window_context.on_resume(event_loop)?;
+
+            if let Some(window) = &glutin_window_context.window {
+                epi_integration::apply_native_options_to_window(window, native_options);
+            }
+
+            let gl = unsafe {
+                glow::Context::from_loader_function(|s| {
+                    let s = std::ffi::CString::new(s)
+                        .expect("failed to construct C string from string for gl proc address");
+
+                    glutin_window_context.get_proc_address(&s)
+                })
+            };
+
+            Ok((glutin_window_context, gl))
+        }
+
+        fn init_run_state(&mut self, event_loop: &EventLoopWindowTarget<UserEvent>) -> Result<()> {
+            let storage = epi_integration::create_storage(&self.app_name);
+
+            let (gl_window, gl) = Self::create_glutin_windowed_context(
+                event_loop,
+                storage.as_deref(),
+                &self.app_name,
+                &self.native_options,
+            )?;
+            let gl = Arc::new(gl);
+
+            let painter =
+                egui_glow::Painter::new(gl.clone(), "", self.native_options.shader_version)
+                    .unwrap_or_else(|error| panic!("some OpenGL error occurred {}\n", error));
+
+            let system_theme = system_theme(gl_window.window(), &self.native_options);
+            let mut integration = epi_integration::EpiIntegration::new(
+                event_loop,
+                painter.max_texture_side(),
+                gl_window.window(),
+                system_theme,
+                self.native_options.follow_system_theme,
+                storage,
+                Some(gl.clone()),
+                #[cfg(feature = "wgpu")]
+                None,
+            );
+            #[cfg(feature = "accesskit")]
+            {
+                integration.init_accesskit(gl_window.window(), self.repaint_proxy.lock().clone());
+            }
+            let theme = system_theme.unwrap_or(self.native_options.default_theme);
+            integration.egui_ctx.set_visuals(theme.egui_visuals());
+
+            gl_window.window().set_ime_allowed(true);
+            if self.native_options.mouse_passthrough {
+                gl_window.window().set_cursor_hittest(false).unwrap();
+            }
+
+            {
+                let event_loop_proxy = self.repaint_proxy.clone();
+                integration.egui_ctx.set_request_repaint_callback(move || {
+                    event_loop_proxy
+                        .lock()
+                        .send_event(UserEvent::RequestRepaint)
+                        .ok();
+                });
+            }
+
+            let app_creator = std::mem::take(&mut self.app_creator)
+                .expect("Single-use AppCreator has unexpectedly already been taken");
+            let mut app = app_creator(&epi::CreationContext {
+                egui_ctx: integration.egui_ctx.clone(),
+                integration_info: integration.frame.info(),
+                storage: integration.frame.storage(),
+                gl: Some(gl.clone()),
+                #[cfg(feature = "wgpu")]
+                wgpu_render_state: None,
+            });
+
+            if app.warm_up_enabled() {
+                integration.warm_up(app.as_mut(), gl_window.window());
+            }
+
+            self.running = Some(GlowWinitRunning {
+                gl_window,
+                gl,
+                painter,
+                integration,
+                app,
+            });
+
+            Ok(())
+        }
+    }
+
+    impl WinitApp for GlowWinitApp {
+        fn is_focused(&self) -> bool {
+            self.is_focused
+        }
+
+        fn integration(&self) -> Option<&EpiIntegration> {
+            self.running.as_ref().map(|r| &r.integration)
+        }
+
+        fn window(&self) -> Option<&winit::window::Window> {
+            self.running.as_ref().map(|r| r.gl_window.window())
+        }
+
+        fn save_and_destroy(&mut self) {
+            if let Some(mut running) = self.running.take() {
+                running
+                    .integration
+                    .save(running.app.as_mut(), running.gl_window.window());
+                running.app.on_exit(Some(&running.gl));
+                running.painter.destroy();
+            }
+        }
+
+        fn paint(&mut self) -> EventResult {
+            if let Some(running) = &mut self.running {
+                #[cfg(feature = "puffin")]
+                puffin::GlobalProfiler::lock().new_frame();
+                crate::profile_scope!("frame");
+
+                let GlowWinitRunning {
+                    gl_window,
+                    gl,
+                    app,
+                    integration,
+                    painter,
+                } = running;
+
+                let window = gl_window.window();
+
+                let screen_size_in_pixels: [u32; 2] = window.inner_size().into();
+
+                egui_glow::painter::clear(
+                    gl,
+                    screen_size_in_pixels,
+                    app.clear_color(&integration.egui_ctx.style().visuals),
+                );
+
+                let egui::FullOutput {
+                    platform_output,
+                    repaint_after,
+                    textures_delta,
+                    shapes,
+                } = integration.update(app.as_mut(), window);
+
+                integration.handle_platform_output(window, platform_output);
+
+                let clipped_primitives = {
+                    crate::profile_scope!("tessellate");
+                    integration.egui_ctx.tessellate(shapes)
+                };
+
+                painter.paint_and_update_textures(
+                    screen_size_in_pixels,
+                    integration.egui_ctx.pixels_per_point(),
+                    &clipped_primitives,
+                    &textures_delta,
+                );
+
+                let screenshot_requested = &mut integration.frame.output.screenshot_requested;
+
+                if *screenshot_requested {
+                    *screenshot_requested = false;
+                    let screenshot = painter.read_screen_rgba(screen_size_in_pixels);
+                    integration.frame.screenshot.set(Some(screenshot));
+                }
+
+                integration.post_rendering(app.as_mut(), window);
+
+                {
+                    crate::profile_scope!("swap_buffers");
+                    gl_window.swap_buffers().unwrap();
+                }
+
+                integration.post_present(window);
+
+                #[cfg(feature = "__screenshot")]
+                // give it time to settle:
+                if self.frame_nr == 2 {
+                    if let Ok(path) = std::env::var("EFRAME_SCREENSHOT_TO") {
+                        assert!(
+                            path.ends_with(".png"),
+                            "Expected EFRAME_SCREENSHOT_TO to end with '.png', got {path:?}"
+                        );
+                        let screenshot = painter.read_screen_rgba(screen_size_in_pixels);
+                        image::save_buffer(
+                            &path,
+                            screenshot.as_raw(),
+                            screenshot.width() as u32,
+                            screenshot.height() as u32,
+                            image::ColorType::Rgba8,
+                        )
+                        .unwrap_or_else(|err| {
+                            panic!("Failed to save screenshot to {path:?}: {err}");
+                        });
+                        eprintln!("Screenshot saved to {path:?}.");
+                        std::process::exit(0);
+                    }
+                }
+
+                let control_flow = if integration.should_close() {
+                    EventResult::Exit
+                } else if repaint_after.is_zero() {
+                    EventResult::RepaintNext
+                } else if let Some(repaint_after_instant) =
+                    std::time::Instant::now().checked_add(repaint_after)
+                {
+                    // if repaint_after is something huge and can't be added to Instant,
+                    // we will use `ControlFlow::Wait` instead.
+                    // technically, this might lead to some weird corner cases where the user *WANTS*
+                    // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
+                    // egui backend impl i guess.
+                    EventResult::RepaintAt(repaint_after_instant)
+                } else {
+                    EventResult::Wait
+                };
+
+                integration.maybe_autosave(app.as_mut(), window);
+
+                if !self.is_focused {
+                    // On Mac, a minimized Window uses up all CPU: https://github.com/emilk/egui/issues/325
+                    // We can't know if we are minimized: https://github.com/rust-windowing/winit/issues/208
+                    // But we know if we are focused (in foreground). When minimized, we are not focused.
+                    // However, a user may want an egui with an animation in the background,
+                    // so we still need to repaint quite fast.
+                    crate::profile_scope!("bg_sleep");
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+
+                self.frame_nr += 1;
+
+                control_flow
+            } else {
+                EventResult::Wait
+            }
+        }
+
+        fn on_event(
+            &mut self,
+            event_loop: &EventLoopWindowTarget<UserEvent>,
+            event: &winit::event::Event<'_, UserEvent>,
+        ) -> Result<EventResult> {
+            Ok(match event {
+                winit::event::Event::Resumed => {
+                    // first resume event.
+                    // we can actually move this outside of event loop.
+                    // and just run the on_resume fn of gl_window
+                    if self.running.is_none() {
+                        self.init_run_state(event_loop)?;
+                    } else {
+                        // not the first resume event. create whatever you need.
+                        self.running
+                            .as_mut()
+                            .unwrap()
+                            .gl_window
+                            .on_resume(event_loop)?;
+                    }
+                    EventResult::RepaintNow
+                }
+                winit::event::Event::Suspended => {
+                    self.running.as_mut().unwrap().gl_window.on_suspend()?;
+
+                    EventResult::Wait
+                }
+
+                winit::event::Event::WindowEvent { event, .. } => {
+                    if let Some(running) = &mut self.running {
+                        // On Windows, if a window is resized by the user, it should repaint synchronously, inside the
+                        // event handler.
+                        //
+                        // If this is not done, the compositor will assume that the window does not want to redraw,
+                        // and continue ahead.
+                        //
+                        // In eframe's case, that causes the window to rapidly flicker, as it struggles to deliver
+                        // new frames to the compositor in time.
+                        //
+                        // The flickering is technically glutin or glow's fault, but we should be responding properly
+                        // to resizes anyway, as doing so avoids dropping frames.
+                        //
+                        // See: https://github.com/emilk/egui/issues/903
+                        let mut repaint_asap = false;
+
+                        match &event {
+                            winit::event::WindowEvent::Focused(new_focused) => {
+                                self.is_focused = *new_focused;
+                            }
+                            winit::event::WindowEvent::Resized(physical_size) => {
+                                repaint_asap = true;
+
+                                // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
+                                // See: https://github.com/rust-windowing/winit/issues/208
+                                // This solves an issue where the app would panic when minimizing on Windows.
+                                if physical_size.width > 0 && physical_size.height > 0 {
+                                    running.gl_window.resize(*physical_size);
+                                }
+                            }
+                            winit::event::WindowEvent::ScaleFactorChanged {
+                                new_inner_size,
+                                ..
+                            } => {
+                                repaint_asap = true;
+                                running.gl_window.resize(**new_inner_size);
+                            }
+                            winit::event::WindowEvent::CloseRequested
+                                if running.integration.should_close() =>
+                            {
+                                tracing::debug!("Received WindowEvent::CloseRequested");
+                                return Ok(EventResult::Exit);
+                            }
+                            _ => {}
+                        }
+
+                        let event_response =
+                            running.integration.on_event(running.app.as_mut(), event);
+
+                        if running.integration.should_close() {
+                            EventResult::Exit
+                        } else if event_response.repaint {
+                            if repaint_asap {
+                                EventResult::RepaintNow
+                            } else {
+                                EventResult::RepaintNext
+                            }
+                        } else {
+                            EventResult::Wait
+                        }
+                    } else {
+                        EventResult::Wait
+                    }
+                }
+                #[cfg(feature = "accesskit")]
+                winit::event::Event::UserEvent(UserEvent::AccessKitActionRequest(
+                    accesskit_winit::ActionRequestEvent { request, .. },
+                )) => {
+                    if let Some(running) = &mut self.running {
+                        running
+                            .integration
+                            .on_accesskit_action_request(request.clone());
+                        // As a form of user input, accessibility actions should
+                        // lead to a repaint.
+                        EventResult::RepaintNext
+                    } else {
+                        EventResult::Wait
+                    }
+                }
+                _ => EventResult::Wait,
+            })
+        }
+    }
+
+    pub fn run_glow(
+        app_name: &str,
+        mut native_options: epi::NativeOptions,
+        app_creator: epi::AppCreator,
+    ) -> Result<()> {
+        if native_options.run_and_return {
+            with_event_loop(native_options, |event_loop, native_options| {
+                let glow_eframe =
+                    GlowWinitApp::new(event_loop, app_name, native_options, app_creator);
+                run_and_return(event_loop, glow_eframe)
+            })
+        } else {
+            let event_loop = create_event_loop_builder(&mut native_options).build();
+            let glow_eframe = GlowWinitApp::new(&event_loop, app_name, native_options, app_creator);
+            run_and_exit(event_loop, glow_eframe);
+        }
+    }
+}
+
+#[cfg(feature = "glow")]
+pub use glow_integration::run_glow;
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "wgpu")]
+mod wgpu_integration {
+    use std::sync::Arc;
+
+    use super::*;
+
+    /// State that is initialized when the application is first starts running via
+    /// a Resumed event. On Android this ensures that any graphics state is only
+    /// initialized once the application has an associated `SurfaceView`.
+    struct WgpuWinitRunning {
+        painter: egui_wgpu::winit::Painter,
+        integration: epi_integration::EpiIntegration,
+        app: Box<dyn epi::App>,
+    }
+
+    struct WgpuWinitApp {
+        repaint_proxy: Arc<std::sync::Mutex<EventLoopProxy<UserEvent>>>,
+        app_name: String,
+        native_options: epi::NativeOptions,
+        app_creator: Option<epi::AppCreator>,
+        running: Option<WgpuWinitRunning>,
+
+        /// Window surface state that's initialized when the app starts running via a Resumed event
+        /// and on Android will also be destroyed if the application is paused.
+        window: Option<winit::window::Window>,
+        is_focused: bool,
+    }
+
+    impl WgpuWinitApp {
+        fn new(
+            event_loop: &EventLoop<UserEvent>,
+            app_name: &str,
+            native_options: epi::NativeOptions,
+            app_creator: epi::AppCreator,
+        ) -> Self {
+            #[cfg(feature = "__screenshot")]
+            assert!(
+                std::env::var("EFRAME_SCREENSHOT_TO").is_err(),
+                "EFRAME_SCREENSHOT_TO not yet implemented for wgpu backend"
+            );
+
+            Self {
+                repaint_proxy: Arc::new(std::sync::Mutex::new(event_loop.create_proxy())),
+                app_name: app_name.to_owned(),
+                native_options,
+                running: None,
+                window: None,
+                app_creator: Some(app_creator),
+                is_focused: true,
+            }
+        }
+
+        fn create_window(
+            event_loop: &EventLoopWindowTarget<UserEvent>,
+            storage: Option<&dyn epi::Storage>,
+            title: &str,
+            native_options: &NativeOptions,
+        ) -> std::result::Result<winit::window::Window, winit::error::OsError> {
+            let window_settings = epi_integration::load_window_settings(storage);
+            let window_builder =
+                epi_integration::window_builder(event_loop, title, native_options, window_settings);
+            let window = window_builder.build(event_loop)?;
+            epi_integration::apply_native_options_to_window(&window, native_options);
+            Ok(window)
+        }
+
+        #[allow(unsafe_code)]
+        fn set_window(
+            &mut self,
+            window: winit::window::Window,
+        ) -> std::result::Result<(), egui_wgpu::WgpuError> {
+            self.window = Some(window);
+            if let Some(running) = &mut self.running {
+                unsafe {
+                    pollster::block_on(running.painter.set_window(self.window.as_ref()))?;
+                }
+            }
+            Ok(())
+        }
+
+        #[allow(unsafe_code)]
+        #[cfg(target_os = "android")]
+        fn drop_window(&mut self) -> std::result::Result<(), egui_wgpu::WgpuError> {
+            self.window = None;
+            if let Some(running) = &mut self.running {
+                unsafe {
+                    pollster::block_on(running.painter.set_window(None))?;
+                }
+            }
+            Ok(())
+        }
+
+        fn init_run_state(
+            &mut self,
+            event_loop: &EventLoopWindowTarget<UserEvent>,
+            storage: Option<Box<dyn epi::Storage>>,
+            window: winit::window::Window,
+        ) -> std::result::Result<(), egui_wgpu::WgpuError> {
+            #[allow(unsafe_code, unused_mut, unused_unsafe)]
+            let painter = unsafe {
+                let mut painter = egui_wgpu::winit::Painter::new(
+                    self.native_options.wgpu_options.clone(),
+                    self.native_options.multisampling.max(1) as _,
+                    self.native_options.depth_buffer,
+                    self.native_options.transparent,
+                );
+                pollster::block_on(painter.set_window(Some(&window)))?;
+                painter
+            };
+
+            let wgpu_render_state = painter.render_state();
+
+            let system_theme = system_theme(&window, &self.native_options);
+            let mut integration = epi_integration::EpiIntegration::new(
+                event_loop,
+                painter.max_texture_side().unwrap_or(2048),
+                &window,
+                system_theme,
+                self.native_options.follow_system_theme,
+                storage,
+                #[cfg(feature = "glow")]
+                None,
+                wgpu_render_state.clone(),
+            );
+            #[cfg(feature = "accesskit")]
+            {
+                integration.init_accesskit(&window, self.repaint_proxy.lock().unwrap().clone());
+            }
+            let theme = system_theme.unwrap_or(self.native_options.default_theme);
+            integration.egui_ctx.set_visuals(theme.egui_visuals());
+
+            window.set_ime_allowed(true);
+
+            {
+                let event_loop_proxy = self.repaint_proxy.clone();
+                integration.egui_ctx.set_request_repaint_callback(move || {
+                    event_loop_proxy
+                        .lock()
+                        .unwrap()
+                        .send_event(UserEvent::RequestRepaint)
+                        .ok();
+                });
+            }
+
+            let app_creator = std::mem::take(&mut self.app_creator)
+                .expect("Single-use AppCreator has unexpectedly already been taken");
+            let mut app = app_creator(&epi::CreationContext {
+                egui_ctx: integration.egui_ctx.clone(),
+                integration_info: integration.frame.info(),
+                storage: integration.frame.storage(),
+                #[cfg(feature = "glow")]
+                gl: None,
+                wgpu_render_state,
+            });
+
+            if app.warm_up_enabled() {
+                integration.warm_up(app.as_mut(), &window);
+            }
+
+            self.running = Some(WgpuWinitRunning {
+                painter,
+                integration,
+                app,
+            });
+            self.window = Some(window);
+
+            Ok(())
+        }
+    }
+
+    impl WinitApp for WgpuWinitApp {
+        fn is_focused(&self) -> bool {
+            self.is_focused
+        }
+
+        fn integration(&self) -> Option<&EpiIntegration> {
+            self.running.as_ref().map(|r| &r.integration)
+        }
+
+        fn window(&self) -> Option<&winit::window::Window> {
+            self.window.as_ref()
+        }
+
+        fn save_and_destroy(&mut self) {
+            if let Some(mut running) = self.running.take() {
+                if let Some(window) = &self.window {
+                    running.integration.save(running.app.as_mut(), window);
+                }
+
+                #[cfg(feature = "glow")]
+                running.app.on_exit(None);
+
+                #[cfg(not(feature = "glow"))]
+                running.app.on_exit();
+
+                running.painter.destroy();
+            }
+        }
+
+        fn paint(&mut self) -> EventResult {
+            if let (Some(running), Some(window)) = (&mut self.running, &self.window) {
+                #[cfg(feature = "puffin")]
+                puffin::GlobalProfiler::lock().new_frame();
+                crate::profile_scope!("frame");
+
+                let WgpuWinitRunning {
+                    app,
+                    integration,
+                    painter,
+                } = running;
+
+                let egui::FullOutput {
+                    platform_output,
+                    repaint_after,
+                    textures_delta,
+                    shapes,
+                } = integration.update(app.as_mut(), window);
+
+                integration.handle_platform_output(window, platform_output);
+
+                let clipped_primitives = {
+                    crate::profile_scope!("tessellate");
+                    integration.egui_ctx.tessellate(shapes)
+                };
+
+                let screenshot_requested = &mut integration.frame.output.screenshot_requested;
+
+                let screenshot = painter.paint_and_update_textures(
+                    integration.egui_ctx.pixels_per_point(),
+                    app.clear_color(&integration.egui_ctx.style().visuals),
+                    &clipped_primitives,
+                    &textures_delta,
+                    *screenshot_requested,
+                );
+                *screenshot_requested = false;
+                integration.frame.screenshot.set(screenshot);
+
+                integration.post_rendering(app.as_mut(), window);
+                integration.post_present(window);
+
+                let control_flow = if integration.should_close() {
+                    EventResult::Exit
+                } else if repaint_after.is_zero() {
+                    EventResult::RepaintNext
+                } else if let Some(repaint_after_instant) =
+                    std::time::Instant::now().checked_add(repaint_after)
+                {
+                    // if repaint_after is something huge and can't be added to Instant,
+                    // we will use `ControlFlow::Wait` instead.
+                    // technically, this might lead to some weird corner cases where the user *WANTS*
+                    // winit to use `WaitUntil(MAX_INSTANT)` explicitly. they can roll their own
+                    // egui backend impl i guess.
+                    EventResult::RepaintAt(repaint_after_instant)
+                } else {
+                    EventResult::Wait
+                };
+
+                integration.maybe_autosave(app.as_mut(), window);
+
+                if !self.is_focused {
+                    // On Mac, a minimized Window uses up all CPU: https://github.com/emilk/egui/issues/325
+                    // We can't know if we are minimized: https://github.com/rust-windowing/winit/issues/208
+                    // But we know if we are focused (in foreground). When minimized, we are not focused.
+                    // However, a user may want an egui with an animation in the background,
+                    // so we still need to repaint quite fast.
+                    crate::profile_scope!("bg_sleep");
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+
+                control_flow
+            } else {
+                EventResult::Wait
+            }
+        }
+
+        fn on_event(
+            &mut self,
+            event_loop: &EventLoopWindowTarget<UserEvent>,
+            event: &winit::event::Event<'_, UserEvent>,
+        ) -> Result<EventResult> {
+            Ok(match event {
+                winit::event::Event::Resumed => {
+                    if let Some(running) = &self.running {
+                        if self.window.is_none() {
+                            let window = Self::create_window(
+                                event_loop,
+                                running.integration.frame.storage(),
+                                &self.app_name,
+                                &self.native_options,
+                            )?;
+                            self.set_window(window)?;
+                        }
+                    } else {
+                        let storage = epi_integration::create_storage(&self.app_name);
+                        let window = Self::create_window(
+                            event_loop,
+                            storage.as_deref(),
+                            &self.app_name,
+                            &self.native_options,
+                        )?;
+                        self.init_run_state(event_loop, storage, window)?;
+                    }
+                    EventResult::RepaintNow
+                }
+                winit::event::Event::Suspended => {
+                    #[cfg(target_os = "android")]
+                    self.drop_window()?;
+                    EventResult::Wait
+                }
+
+                winit::event::Event::WindowEvent { event, .. } => {
+                    if let Some(running) = &mut self.running {
+                        // On Windows, if a window is resized by the user, it should repaint synchronously, inside the
+                        // event handler.
+                        //
+                        // If this is not done, the compositor will assume that the window does not want to redraw,
+                        // and continue ahead.
+                        //
+                        // In eframe's case, that causes the window to rapidly flicker, as it struggles to deliver
+                        // new frames to the compositor in time.
+                        //
+                        // The flickering is technically glutin or glow's fault, but we should be responding properly
+                        // to resizes anyway, as doing so avoids dropping frames.
+                        //
+                        // See: https://github.com/emilk/egui/issues/903
+                        let mut repaint_asap = false;
+
+                        match &event {
+                            winit::event::WindowEvent::Focused(new_focused) => {
+                                self.is_focused = *new_focused;
+                            }
+                            winit::event::WindowEvent::Resized(physical_size) => {
+                                repaint_asap = true;
+
+                                // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
+                                // See: https://github.com/rust-windowing/winit/issues/208
+                                // This solves an issue where the app would panic when minimizing on Windows.
+                                if physical_size.width > 0 && physical_size.height > 0 {
+                                    running.painter.on_window_resized(
+                                        physical_size.width,
+                                        physical_size.height,
+                                    );
+                                }
+                            }
+                            winit::event::WindowEvent::ScaleFactorChanged {
+                                new_inner_size,
+                                ..
+                            } => {
+                                repaint_asap = true;
+                                running
+                                    .painter
+                                    .on_window_resized(new_inner_size.width, new_inner_size.height);
+                            }
+                            winit::event::WindowEvent::CloseRequested
+                                if running.integration.should_close() =>
+                            {
+                                tracing::debug!("Received WindowEvent::CloseRequested");
+                                return Ok(EventResult::Exit);
+                            }
+                            _ => {}
+                        };
+
+                        let event_response =
+                            running.integration.on_event(running.app.as_mut(), event);
+                        if running.integration.should_close() {
+                            EventResult::Exit
+                        } else if event_response.repaint {
+                            if repaint_asap {
+                                EventResult::RepaintNow
+                            } else {
+                                EventResult::RepaintNext
+                            }
+                        } else {
+                            EventResult::Wait
+                        }
+                    } else {
+                        EventResult::Wait
+                    }
+                }
+                #[cfg(feature = "accesskit")]
+                winit::event::Event::UserEvent(UserEvent::AccessKitActionRequest(
+                    accesskit_winit::ActionRequestEvent { request, .. },
+                )) => {
+                    if let Some(running) = &mut self.running {
+                        running
+                            .integration
+                            .on_accesskit_action_request(request.clone());
+                        // As a form of user input, accessibility actions should
+                        // lead to a repaint.
+                        EventResult::RepaintNext
+                    } else {
+                        EventResult::Wait
+                    }
+                }
+                _ => EventResult::Wait,
+            })
+        }
+    }
+
+    pub fn run_wgpu(
+        app_name: &str,
+        mut native_options: epi::NativeOptions,
+        app_creator: epi::AppCreator,
+    ) -> Result<()> {
+        if native_options.run_and_return {
+            with_event_loop(native_options, |event_loop, native_options| {
+                let wgpu_eframe =
+                    WgpuWinitApp::new(event_loop, app_name, native_options, app_creator);
+                run_and_return(event_loop, wgpu_eframe)
+            })
+        } else {
+            let event_loop = create_event_loop_builder(&mut native_options).build();
+            let wgpu_eframe = WgpuWinitApp::new(&event_loop, app_name, native_options, app_creator);
+            run_and_exit(event_loop, wgpu_eframe);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "wgpu")]
+pub use wgpu_integration::run_wgpu;
+
+#[cfg(any(target_os = "windows", target_os = "macos"))]
+fn system_theme(window: &winit::window::Window, options: &NativeOptions) -> Option<crate::Theme> {
+    if options.follow_system_theme {
+        window
+            .theme()
+            .map(super::epi_integration::theme_from_winit_theme)
+    } else {
+        None
+    }
+}
+
+// Winit only reads the system theme on macOS and Windows.
+// On Linux we have to fall back on dark-light (if enabled).
+// See: https://github.com/rust-windowing/winit/issues/1549
+#[cfg(not(any(target_os = "windows", target_os = "macos")))]
+fn system_theme(_window: &winit::window::Window, options: &NativeOptions) -> Option<crate::Theme> {
+    options.system_theme()
+}
diff --git a/egui/crates/eframe/src/web/backend.rs b/egui/crates/eframe/src/web/backend.rs
new file mode 100644
index 0000000..3835dfb
--- /dev/null
+++ b/egui/crates/eframe/src/web/backend.rs
@@ -0,0 +1,598 @@
+use egui::{
+    mutex::{Mutex, MutexGuard},
+    TexturesDelta,
+};
+
+use crate::{epi, App};
+
+use super::{web_painter::WebPainter, *};
+
+// ----------------------------------------------------------------------------
+
+/// Data gathered between frames.
+#[derive(Default)]
+pub struct WebInput {
+    /// Required because we don't get a position on touched
+    pub latest_touch_pos: Option<egui::Pos2>,
+
+    /// Required to maintain a stable touch position for multi-touch gestures.
+    pub latest_touch_pos_id: Option<egui::TouchId>,
+
+    pub raw: egui::RawInput,
+}
+
+impl WebInput {
+    pub fn new_frame(&mut self, canvas_size: egui::Vec2) -> egui::RawInput {
+        egui::RawInput {
+            screen_rect: Some(egui::Rect::from_min_size(Default::default(), canvas_size)),
+            pixels_per_point: Some(native_pixels_per_point()), // We ALWAYS use the native pixels-per-point
+            time: Some(now_sec()),
+            ..self.raw.take()
+        }
+    }
+
+    pub fn on_web_page_focus_change(&mut self, has_focus: bool) {
+        self.raw.modifiers = egui::Modifiers::default();
+        self.raw.has_focus = has_focus;
+        self.latest_touch_pos = None;
+        self.latest_touch_pos_id = None;
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+use std::sync::atomic::Ordering::SeqCst;
+
+/// Stores when to do the next repaint.
+pub struct NeedRepaint(Mutex<f64>);
+
+impl Default for NeedRepaint {
+    fn default() -> Self {
+        Self(Mutex::new(f64::NEG_INFINITY)) // start with a repaint
+    }
+}
+
+impl NeedRepaint {
+    /// Returns the time (in [`now_sec`] scale) when
+    /// we should next repaint.
+    pub fn when_to_repaint(&self) -> f64 {
+        *self.0.lock()
+    }
+
+    /// Unschedule repainting.
+    pub fn clear(&self) {
+        *self.0.lock() = f64::INFINITY;
+    }
+
+    pub fn repaint_after(&self, num_seconds: f64) {
+        let mut repaint_time = self.0.lock();
+        *repaint_time = repaint_time.min(now_sec() + num_seconds);
+    }
+
+    pub fn repaint_asap(&self) {
+        *self.0.lock() = f64::NEG_INFINITY;
+    }
+}
+
+pub struct IsDestroyed(std::sync::atomic::AtomicBool);
+
+impl Default for IsDestroyed {
+    fn default() -> Self {
+        Self(false.into())
+    }
+}
+
+impl IsDestroyed {
+    pub fn fetch(&self) -> bool {
+        self.0.load(SeqCst)
+    }
+
+    pub fn set_true(&self) {
+        self.0.store(true, SeqCst);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn user_agent() -> Option<String> {
+    web_sys::window()?.navigator().user_agent().ok()
+}
+
+fn web_location() -> epi::Location {
+    let location = web_sys::window().unwrap().location();
+
+    let hash = percent_decode(&location.hash().unwrap_or_default());
+
+    let query = location
+        .search()
+        .unwrap_or_default()
+        .strip_prefix('?')
+        .map(percent_decode)
+        .unwrap_or_default();
+
+    let query_map = parse_query_map(&query)
+        .iter()
+        .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+        .collect();
+
+    epi::Location {
+        url: percent_decode(&location.href().unwrap_or_default()),
+        protocol: percent_decode(&location.protocol().unwrap_or_default()),
+        host: percent_decode(&location.host().unwrap_or_default()),
+        hostname: percent_decode(&location.hostname().unwrap_or_default()),
+        port: percent_decode(&location.port().unwrap_or_default()),
+        hash,
+        query,
+        query_map,
+        origin: percent_decode(&location.origin().unwrap_or_default()),
+    }
+}
+
+fn parse_query_map(query: &str) -> BTreeMap<&str, &str> {
+    query
+        .split('&')
+        .filter_map(|pair| {
+            if pair.is_empty() {
+                None
+            } else {
+                Some(if let Some((key, value)) = pair.split_once('=') {
+                    (key, value)
+                } else {
+                    (pair, "")
+                })
+            }
+        })
+        .collect()
+}
+
+#[test]
+fn test_parse_query() {
+    assert_eq!(parse_query_map(""), BTreeMap::default());
+    assert_eq!(parse_query_map("foo"), BTreeMap::from_iter([("foo", "")]));
+    assert_eq!(
+        parse_query_map("foo=bar"),
+        BTreeMap::from_iter([("foo", "bar")])
+    );
+    assert_eq!(
+        parse_query_map("foo=bar&baz=42"),
+        BTreeMap::from_iter([("foo", "bar"), ("baz", "42")])
+    );
+    assert_eq!(
+        parse_query_map("foo&baz=42"),
+        BTreeMap::from_iter([("foo", ""), ("baz", "42")])
+    );
+    assert_eq!(
+        parse_query_map("foo&baz&&"),
+        BTreeMap::from_iter([("foo", ""), ("baz", "")])
+    );
+}
+
+// ----------------------------------------------------------------------------
+
+pub struct AppRunner {
+    pub(crate) frame: epi::Frame,
+    egui_ctx: egui::Context,
+    painter: ActiveWebPainter,
+    pub(crate) input: WebInput,
+    app: Box<dyn epi::App>,
+    pub(crate) needs_repaint: std::sync::Arc<NeedRepaint>,
+    pub(crate) is_destroyed: std::sync::Arc<IsDestroyed>,
+    last_save_time: f64,
+    screen_reader: super::screen_reader::ScreenReader,
+    pub(crate) text_cursor_pos: Option<egui::Pos2>,
+    pub(crate) mutable_text_under_cursor: bool,
+    textures_delta: TexturesDelta,
+    pub events_to_unsubscribe: Vec<EventToUnsubscribe>,
+}
+
+impl Drop for AppRunner {
+    fn drop(&mut self) {
+        tracing::debug!("AppRunner has fully dropped");
+    }
+}
+
+impl AppRunner {
+    /// # Errors
+    /// Failure to initialize WebGL renderer.
+    pub async fn new(
+        canvas_id: &str,
+        web_options: crate::WebOptions,
+        app_creator: epi::AppCreator,
+    ) -> Result<Self, String> {
+        let painter = ActiveWebPainter::new(canvas_id, &web_options).await?;
+
+        let system_theme = if web_options.follow_system_theme {
+            super::system_theme()
+        } else {
+            None
+        };
+
+        let info = epi::IntegrationInfo {
+            web_info: epi::WebInfo {
+                user_agent: user_agent().unwrap_or_default(),
+                location: web_location(),
+            },
+            system_theme,
+            cpu_usage: None,
+            native_pixels_per_point: Some(native_pixels_per_point()),
+        };
+        let storage = LocalStorage::default();
+
+        let egui_ctx = egui::Context::default();
+        egui_ctx.set_os(egui::os::OperatingSystem::from_user_agent(
+            &user_agent().unwrap_or_default(),
+        ));
+        load_memory(&egui_ctx);
+
+        let theme = system_theme.unwrap_or(web_options.default_theme);
+        egui_ctx.set_visuals(theme.egui_visuals());
+
+        let app = app_creator(&epi::CreationContext {
+            egui_ctx: egui_ctx.clone(),
+            integration_info: info.clone(),
+            storage: Some(&storage),
+
+            #[cfg(feature = "glow")]
+            gl: Some(painter.gl().clone()),
+
+            #[cfg(all(feature = "wgpu", not(feature = "glow")))]
+            wgpu_render_state: painter.render_state(),
+            #[cfg(all(feature = "wgpu", feature = "glow"))]
+            wgpu_render_state: None,
+        });
+
+        let frame = epi::Frame {
+            info,
+            output: Default::default(),
+            storage: Some(Box::new(storage)),
+
+            #[cfg(feature = "glow")]
+            gl: Some(painter.gl().clone()),
+
+            #[cfg(all(feature = "wgpu", not(feature = "glow")))]
+            wgpu_render_state: painter.render_state(),
+            #[cfg(all(feature = "wgpu", feature = "glow"))]
+            wgpu_render_state: None,
+        };
+
+        let needs_repaint: std::sync::Arc<NeedRepaint> = Default::default();
+        {
+            let needs_repaint = needs_repaint.clone();
+            egui_ctx.set_request_repaint_callback(move || {
+                needs_repaint.repaint_asap();
+            });
+        }
+
+        let mut runner = Self {
+            frame,
+            egui_ctx,
+            painter,
+            input: Default::default(),
+            app,
+            needs_repaint,
+            is_destroyed: Default::default(),
+            last_save_time: now_sec(),
+            screen_reader: Default::default(),
+            text_cursor_pos: None,
+            mutable_text_under_cursor: false,
+            textures_delta: Default::default(),
+            events_to_unsubscribe: Default::default(),
+        };
+
+        runner.input.raw.max_texture_side = Some(runner.painter.max_texture_side());
+
+        Ok(runner)
+    }
+
+    pub fn egui_ctx(&self) -> &egui::Context {
+        &self.egui_ctx
+    }
+
+    /// Get mutable access to the concrete [`App`] we enclose.
+    ///
+    /// This will panic if your app does not implement [`App::as_any_mut`].
+    pub fn app_mut<ConcreteApp: 'static + App>(&mut self) -> &mut ConcreteApp {
+        self.app
+            .as_any_mut()
+            .expect("Your app must implement `as_any_mut`, but it doesn't")
+            .downcast_mut::<ConcreteApp>()
+            .unwrap()
+    }
+
+    pub fn auto_save(&mut self) {
+        let now = now_sec();
+        let time_since_last_save = now - self.last_save_time;
+
+        if time_since_last_save > self.app.auto_save_interval().as_secs_f64() {
+            if self.app.persist_egui_memory() {
+                save_memory(&self.egui_ctx);
+            }
+            if let Some(storage) = self.frame.storage_mut() {
+                self.app.save(storage);
+            }
+            self.last_save_time = now;
+        }
+    }
+
+    pub fn canvas_id(&self) -> &str {
+        self.painter.canvas_id()
+    }
+
+    pub fn warm_up(&mut self) -> Result<(), JsValue> {
+        if self.app.warm_up_enabled() {
+            let saved_memory: egui::Memory = self.egui_ctx.memory(|m| m.clone());
+            self.egui_ctx
+                .memory_mut(|m| m.set_everything_is_visible(true));
+            self.logic()?;
+            self.egui_ctx.memory_mut(|m| *m = saved_memory); // We don't want to remember that windows were huge.
+            self.egui_ctx.clear_animations();
+        }
+        Ok(())
+    }
+
+    pub fn destroy(&mut self) -> Result<(), JsValue> {
+        let is_destroyed_already = self.is_destroyed.fetch();
+
+        if is_destroyed_already {
+            tracing::warn!("App was destroyed already");
+            Ok(())
+        } else {
+            tracing::debug!("Destroying");
+            for x in self.events_to_unsubscribe.drain(..) {
+                x.unsubscribe()?;
+            }
+
+            self.painter.destroy();
+            self.is_destroyed.set_true();
+            Ok(())
+        }
+    }
+
+    /// Returns how long to wait until the next repaint.
+    ///
+    /// Call [`Self::paint`] later to paint
+    pub fn logic(&mut self) -> Result<(std::time::Duration, Vec<egui::ClippedPrimitive>), JsValue> {
+        let frame_start = now_sec();
+
+        resize_canvas_to_screen_size(self.canvas_id(), self.app.max_size_points());
+        let canvas_size = canvas_size_in_points(self.canvas_id());
+        let raw_input = self.input.new_frame(canvas_size);
+
+        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
+            self.app.update(egui_ctx, &mut self.frame);
+        });
+        let egui::FullOutput {
+            platform_output,
+            repaint_after,
+            textures_delta,
+            shapes,
+        } = full_output;
+
+        self.handle_platform_output(platform_output);
+        self.textures_delta.append(textures_delta);
+        let clipped_primitives = self.egui_ctx.tessellate(shapes);
+
+        {
+            let app_output = self.frame.take_app_output();
+            let epi::backend::AppOutput {} = app_output;
+        }
+
+        self.frame.info.cpu_usage = Some((now_sec() - frame_start) as f32);
+        Ok((repaint_after, clipped_primitives))
+    }
+
+    /// Paint the results of the last call to [`Self::logic`].
+    pub fn paint(&mut self, clipped_primitives: &[egui::ClippedPrimitive]) -> Result<(), JsValue> {
+        let textures_delta = std::mem::take(&mut self.textures_delta);
+
+        self.painter.paint_and_update_textures(
+            self.app.clear_color(&self.egui_ctx.style().visuals),
+            clipped_primitives,
+            self.egui_ctx.pixels_per_point(),
+            &textures_delta,
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_platform_output(&mut self, platform_output: egui::PlatformOutput) {
+        if self.egui_ctx.options(|o| o.screen_reader) {
+            self.screen_reader
+                .speak(&platform_output.events_description());
+        }
+
+        let egui::PlatformOutput {
+            cursor_icon,
+            open_url,
+            copied_text,
+            events: _, // already handled
+            mutable_text_under_cursor,
+            text_cursor_pos,
+            #[cfg(feature = "accesskit")]
+                accesskit_update: _, // not currently implemented
+        } = platform_output;
+
+        set_cursor_icon(cursor_icon);
+        if let Some(open) = open_url {
+            super::open_url(&open.url, open.new_tab);
+        }
+
+        #[cfg(web_sys_unstable_apis)]
+        if !copied_text.is_empty() {
+            set_clipboard_text(&copied_text);
+        }
+
+        #[cfg(not(web_sys_unstable_apis))]
+        let _ = copied_text;
+
+        self.mutable_text_under_cursor = mutable_text_under_cursor;
+
+        if self.text_cursor_pos != text_cursor_pos {
+            text_agent::move_text_cursor(text_cursor_pos, self.canvas_id());
+            self.text_cursor_pos = text_cursor_pos;
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub type AppRunnerRef = Arc<Mutex<AppRunner>>;
+
+pub struct TargetEvent {
+    target: EventTarget,
+    event_name: String,
+    closure: Closure<dyn FnMut(web_sys::Event)>,
+}
+
+pub struct IntervalHandle {
+    pub handle: i32,
+    pub closure: Closure<dyn FnMut()>,
+}
+
+pub enum EventToUnsubscribe {
+    TargetEvent(TargetEvent),
+    #[allow(dead_code)]
+    IntervalHandle(IntervalHandle),
+}
+
+impl EventToUnsubscribe {
+    pub fn unsubscribe(self) -> Result<(), JsValue> {
+        match self {
+            EventToUnsubscribe::TargetEvent(handle) => {
+                handle.target.remove_event_listener_with_callback(
+                    handle.event_name.as_str(),
+                    handle.closure.as_ref().unchecked_ref(),
+                )?;
+                Ok(())
+            }
+            EventToUnsubscribe::IntervalHandle(handle) => {
+                let window = web_sys::window().unwrap();
+                window.clear_interval_with_handle(handle.handle);
+                Ok(())
+            }
+        }
+    }
+}
+
+pub struct AppRunnerContainer {
+    pub runner: AppRunnerRef,
+
+    /// Set to `true` if there is a panic.
+    /// Used to ignore callbacks after a panic.
+    pub panicked: Arc<AtomicBool>,
+    pub events: Vec<EventToUnsubscribe>,
+}
+
+impl AppRunnerContainer {
+    /// Convenience function to reduce boilerplate and ensure that all event handlers
+    /// are dealt with in the same way
+    pub fn add_event_listener<E: wasm_bindgen::JsCast>(
+        &mut self,
+        target: &EventTarget,
+        event_name: &'static str,
+        mut closure: impl FnMut(E, MutexGuard<'_, AppRunner>) + 'static,
+    ) -> Result<(), JsValue> {
+        // Create a JS closure based on the FnMut provided
+        let closure = Closure::wrap({
+            // Clone atomics
+            let runner_ref = self.runner.clone();
+            let panicked = self.panicked.clone();
+
+            Box::new(move |event: web_sys::Event| {
+                // Only call the wrapped closure if the egui code has not panicked
+                if !panicked.load(Ordering::SeqCst) {
+                    // Cast the event to the expected event type
+                    let event = event.unchecked_into::<E>();
+
+                    closure(event, runner_ref.lock());
+                }
+            }) as Box<dyn FnMut(web_sys::Event)>
+        });
+
+        // Add the event listener to the target
+        target.add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())?;
+
+        let handle = TargetEvent {
+            target: target.clone(),
+            event_name: event_name.to_owned(),
+            closure,
+        };
+
+        self.events.push(EventToUnsubscribe::TargetEvent(handle));
+
+        Ok(())
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Install event listeners to register different input events
+/// and start running the given app.
+pub async fn start(
+    canvas_id: &str,
+    web_options: crate::WebOptions,
+    app_creator: epi::AppCreator,
+) -> Result<AppRunnerRef, JsValue> {
+    #[cfg(not(web_sys_unstable_apis))]
+    tracing::warn!(
+        "eframe compiled without RUSTFLAGS='--cfg=web_sys_unstable_apis'. Copying text won't work."
+    );
+    let follow_system_theme = web_options.follow_system_theme;
+
+    let mut runner = AppRunner::new(canvas_id, web_options, app_creator).await?;
+    runner.warm_up()?;
+    start_runner(runner, follow_system_theme)
+}
+
+/// Install event listeners to register different input events
+/// and starts running the given [`AppRunner`].
+fn start_runner(app_runner: AppRunner, follow_system_theme: bool) -> Result<AppRunnerRef, JsValue> {
+    let mut runner_container = AppRunnerContainer {
+        runner: Arc::new(Mutex::new(app_runner)),
+        panicked: Arc::new(AtomicBool::new(false)),
+        events: Vec::with_capacity(20),
+    };
+
+    super::events::install_canvas_events(&mut runner_container)?;
+    super::events::install_document_events(&mut runner_container)?;
+    super::events::install_window_events(&mut runner_container)?;
+    text_agent::install_text_agent(&mut runner_container)?;
+
+    if follow_system_theme {
+        super::events::install_color_scheme_change_event(&mut runner_container)?;
+    }
+
+    super::events::paint_and_schedule(&runner_container.runner, runner_container.panicked.clone())?;
+
+    // Disable all event handlers on panic
+    let previous_hook = std::panic::take_hook();
+
+    runner_container.runner.lock().events_to_unsubscribe = runner_container.events;
+
+    std::panic::set_hook(Box::new(move |panic_info| {
+        tracing::info!("egui disabled all event handlers due to panic");
+        runner_container.panicked.store(true, SeqCst);
+
+        // Propagate panic info to the previously registered panic hook
+        previous_hook(panic_info);
+    }));
+
+    Ok(runner_container.runner)
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default)]
+struct LocalStorage {}
+
+impl epi::Storage for LocalStorage {
+    fn get_string(&self, key: &str) -> Option<String> {
+        local_storage_get(key)
+    }
+
+    fn set_string(&mut self, key: &str, value: String) {
+        local_storage_set(key, &value);
+    }
+
+    fn flush(&mut self) {}
+}
diff --git a/egui/crates/eframe/src/web/events.rs b/egui/crates/eframe/src/web/events.rs
new file mode 100644
index 0000000..3208ffe
--- /dev/null
+++ b/egui/crates/eframe/src/web/events.rs
@@ -0,0 +1,597 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use egui::Key;
+
+use super::*;
+
+struct IsDestroyed(pub bool);
+
+pub fn paint_and_schedule(
+    runner_ref: &AppRunnerRef,
+    panicked: Arc<AtomicBool>,
+) -> Result<(), JsValue> {
+    fn paint_if_needed(runner_ref: &AppRunnerRef) -> Result<IsDestroyed, JsValue> {
+        let mut runner_lock = runner_ref.lock();
+        let is_destroyed = runner_lock.is_destroyed.fetch();
+
+        if !is_destroyed && runner_lock.needs_repaint.when_to_repaint() <= now_sec() {
+            runner_lock.needs_repaint.clear();
+            let (repaint_after, clipped_primitives) = runner_lock.logic()?;
+            runner_lock.paint(&clipped_primitives)?;
+            runner_lock
+                .needs_repaint
+                .repaint_after(repaint_after.as_secs_f64());
+            runner_lock.auto_save();
+        }
+
+        Ok(IsDestroyed(is_destroyed))
+    }
+
+    fn request_animation_frame(
+        runner_ref: AppRunnerRef,
+        panicked: Arc<AtomicBool>,
+    ) -> Result<(), JsValue> {
+        let window = web_sys::window().unwrap();
+        let closure = Closure::once(move || paint_and_schedule(&runner_ref, panicked));
+        window.request_animation_frame(closure.as_ref().unchecked_ref())?;
+        closure.forget(); // We must forget it, or else the callback is canceled on drop
+        Ok(())
+    }
+
+    // Only paint and schedule if there has been no panic
+    if !panicked.load(Ordering::SeqCst) {
+        let is_destroyed = paint_if_needed(runner_ref)?;
+        if !is_destroyed.0 {
+            request_animation_frame(runner_ref.clone(), panicked)?;
+        }
+    }
+
+    Ok(())
+}
+
+pub fn install_document_events(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+    let document = web_sys::window().unwrap().document().unwrap();
+
+    {
+        // Avoid sticky modifier keys on alt-tab:
+        let clear_modifiers = ["blur", "focus"];
+
+        for event_name in clear_modifiers {
+            let closure =
+                move |_event: web_sys::MouseEvent,
+                      mut runner_lock: egui::mutex::MutexGuard<'_, AppRunner>| {
+                    let has_focus = event_name == "focus";
+                    runner_lock.input.on_web_page_focus_change(has_focus);
+                    runner_lock.egui_ctx().request_repaint();
+                    // tracing::debug!("{event_name:?}");
+                };
+
+            runner_container.add_event_listener(&document, event_name, closure)?;
+        }
+    }
+
+    runner_container.add_event_listener(
+        &document,
+        "keydown",
+        |event: web_sys::KeyboardEvent, mut runner_lock| {
+            if event.is_composing() || event.key_code() == 229 {
+                // https://web.archive.org/web/20200526195704/https://www.fxsitecompat.dev/en-CA/docs/2018/keydown-and-keyup-events-are-now-fired-during-ime-composition/
+                return;
+            }
+
+            let modifiers = modifiers_from_event(&event);
+            runner_lock.input.raw.modifiers = modifiers;
+
+            let key = event.key();
+            let egui_key = translate_key(&key);
+
+            if let Some(key) = egui_key {
+                runner_lock.input.raw.events.push(egui::Event::Key {
+                    key,
+                    pressed: true,
+                    repeat: false, // egui will fill this in for us!
+                    modifiers,
+                });
+            }
+            if !modifiers.ctrl
+                && !modifiers.command
+                && !should_ignore_key(&key)
+                // When text agent is shown, it sends text event instead.
+                && text_agent::text_agent().hidden()
+            {
+                runner_lock.input.raw.events.push(egui::Event::Text(key));
+            }
+            runner_lock.needs_repaint.repaint_asap();
+
+            let egui_wants_keyboard = runner_lock.egui_ctx().wants_keyboard_input();
+
+            #[allow(clippy::if_same_then_else)]
+            let prevent_default = if egui_key == Some(Key::Tab) {
+                // Always prevent moving cursor to url bar.
+                // egui wants to use tab to move to the next text field.
+                true
+            } else if egui_key == Some(Key::P) {
+                #[allow(clippy::needless_bool)]
+                if modifiers.ctrl || modifiers.command || modifiers.mac_cmd {
+                    true // Prevent ctrl-P opening the print dialog. Users may want to use it for a command palette.
+                } else {
+                    false // let normal P:s through
+                }
+            } else if egui_wants_keyboard {
+                matches!(
+                    event.key().as_str(),
+                    "Backspace" // so we don't go back to previous page when deleting text
+                    | "ArrowDown" | "ArrowLeft" | "ArrowRight" | "ArrowUp" // cmd-left is "back" on Mac (https://github.com/emilk/egui/issues/58)
+                )
+            } else {
+                // We never want to prevent:
+                // * F5 / cmd-R (refresh)
+                // * cmd-shift-C (debug tools)
+                // * cmd/ctrl-c/v/x (or we stop copy/past/cut events)
+                false
+            };
+
+            // tracing::debug!(
+            //     "On key-down {:?}, egui_wants_keyboard: {}, prevent_default: {}",
+            //     event.key().as_str(),
+            //     egui_wants_keyboard,
+            //     prevent_default
+            // );
+
+            if prevent_default {
+                event.prevent_default();
+                // event.stop_propagation();
+            }
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &document,
+        "keyup",
+        |event: web_sys::KeyboardEvent, mut runner_lock| {
+            let modifiers = modifiers_from_event(&event);
+            runner_lock.input.raw.modifiers = modifiers;
+            if let Some(key) = translate_key(&event.key()) {
+                runner_lock.input.raw.events.push(egui::Event::Key {
+                    key,
+                    pressed: false,
+                    repeat: false,
+                    modifiers,
+                });
+            }
+            runner_lock.needs_repaint.repaint_asap();
+        },
+    )?;
+
+    #[cfg(web_sys_unstable_apis)]
+    runner_container.add_event_listener(
+        &document,
+        "paste",
+        |event: web_sys::ClipboardEvent, mut runner_lock| {
+            if let Some(data) = event.clipboard_data() {
+                if let Ok(text) = data.get_data("text") {
+                    let text = text.replace("\r\n", "\n");
+                    if !text.is_empty() {
+                        runner_lock.input.raw.events.push(egui::Event::Paste(text));
+                        runner_lock.needs_repaint.repaint_asap();
+                    }
+                    event.stop_propagation();
+                    event.prevent_default();
+                }
+            }
+        },
+    )?;
+
+    #[cfg(web_sys_unstable_apis)]
+    runner_container.add_event_listener(
+        &document,
+        "cut",
+        |_: web_sys::ClipboardEvent, mut runner_lock| {
+            runner_lock.input.raw.events.push(egui::Event::Cut);
+            runner_lock.needs_repaint.repaint_asap();
+        },
+    )?;
+
+    #[cfg(web_sys_unstable_apis)]
+    runner_container.add_event_listener(
+        &document,
+        "copy",
+        |_: web_sys::ClipboardEvent, mut runner_lock| {
+            runner_lock.input.raw.events.push(egui::Event::Copy);
+            runner_lock.needs_repaint.repaint_asap();
+        },
+    )?;
+
+    Ok(())
+}
+
+pub fn install_window_events(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+    let window = web_sys::window().unwrap();
+
+    for event_name in &["load", "pagehide", "pageshow", "resize"] {
+        runner_container.add_event_listener(
+            &window,
+            event_name,
+            |_: web_sys::Event, runner_lock| {
+                runner_lock.needs_repaint.repaint_asap();
+            },
+        )?;
+    }
+
+    runner_container.add_event_listener(
+        &window,
+        "hashchange",
+        |_: web_sys::Event, mut runner_lock| {
+            // `epi::Frame::info(&self)` clones `epi::IntegrationInfo`, but we need to modify the original here
+            runner_lock.frame.info.web_info.location.hash = location_hash();
+        },
+    )?;
+
+    Ok(())
+}
+
+pub fn install_color_scheme_change_event(
+    runner_container: &mut AppRunnerContainer,
+) -> Result<(), JsValue> {
+    let window = web_sys::window().unwrap();
+
+    if let Some(media_query_list) = prefers_color_scheme_dark(&window)? {
+        runner_container.add_event_listener::<web_sys::MediaQueryListEvent>(
+            &media_query_list,
+            "change",
+            |event, mut runner_lock| {
+                let theme = theme_from_dark_mode(event.matches());
+                runner_lock.frame.info.system_theme = Some(theme);
+                runner_lock.egui_ctx().set_visuals(theme.egui_visuals());
+                runner_lock.needs_repaint.repaint_asap();
+            },
+        )?;
+    }
+
+    Ok(())
+}
+
+pub fn install_canvas_events(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+    let canvas = canvas_element(runner_container.runner.lock().canvas_id()).unwrap();
+
+    {
+        let prevent_default_events = [
+            // By default, right-clicks open a context menu.
+            // We don't want to do that (right clicks is handled by egui):
+            "contextmenu",
+            // Allow users to use ctrl-p for e.g. a command palette:
+            "afterprint",
+        ];
+
+        for event_name in prevent_default_events {
+            let closure =
+                move |event: web_sys::MouseEvent,
+                      mut _runner_lock: egui::mutex::MutexGuard<'_, AppRunner>| {
+                    event.prevent_default();
+                    // event.stop_propagation();
+                    // tracing::debug!("Preventing event {event_name:?}");
+                };
+
+            runner_container.add_event_listener(&canvas, event_name, closure)?;
+        }
+    }
+
+    runner_container.add_event_listener(
+        &canvas,
+        "mousedown",
+        |event: web_sys::MouseEvent, mut runner_lock: egui::mutex::MutexGuard<'_, AppRunner>| {
+            if let Some(button) = button_from_mouse_event(&event) {
+                let pos = pos_from_mouse_event(runner_lock.canvas_id(), &event);
+                let modifiers = runner_lock.input.raw.modifiers;
+                runner_lock
+                    .input
+                    .raw
+                    .events
+                    .push(egui::Event::PointerButton {
+                        pos,
+                        button,
+                        pressed: true,
+                        modifiers,
+                    });
+                runner_lock.needs_repaint.repaint_asap();
+            }
+            event.stop_propagation();
+            // Note: prevent_default breaks VSCode tab focusing, hence why we don't call it here.
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "mousemove",
+        |event: web_sys::MouseEvent, mut runner_lock| {
+            let pos = pos_from_mouse_event(runner_lock.canvas_id(), &event);
+            runner_lock
+                .input
+                .raw
+                .events
+                .push(egui::Event::PointerMoved(pos));
+            runner_lock.needs_repaint.repaint_asap();
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "mouseup",
+        |event: web_sys::MouseEvent, mut runner_lock| {
+            if let Some(button) = button_from_mouse_event(&event) {
+                let pos = pos_from_mouse_event(runner_lock.canvas_id(), &event);
+                let modifiers = runner_lock.input.raw.modifiers;
+                runner_lock
+                    .input
+                    .raw
+                    .events
+                    .push(egui::Event::PointerButton {
+                        pos,
+                        button,
+                        pressed: false,
+                        modifiers,
+                    });
+                runner_lock.needs_repaint.repaint_asap();
+
+                text_agent::update_text_agent(runner_lock);
+            }
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "mouseleave",
+        |event: web_sys::MouseEvent, mut runner_lock| {
+            runner_lock.input.raw.events.push(egui::Event::PointerGone);
+            runner_lock.needs_repaint.repaint_asap();
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "touchstart",
+        |event: web_sys::TouchEvent, mut runner_lock| {
+            let mut latest_touch_pos_id = runner_lock.input.latest_touch_pos_id;
+            let pos =
+                pos_from_touch_event(runner_lock.canvas_id(), &event, &mut latest_touch_pos_id);
+            runner_lock.input.latest_touch_pos_id = latest_touch_pos_id;
+            runner_lock.input.latest_touch_pos = Some(pos);
+            let modifiers = runner_lock.input.raw.modifiers;
+            runner_lock
+                .input
+                .raw
+                .events
+                .push(egui::Event::PointerButton {
+                    pos,
+                    button: egui::PointerButton::Primary,
+                    pressed: true,
+                    modifiers,
+                });
+
+            push_touches(&mut runner_lock, egui::TouchPhase::Start, &event);
+            runner_lock.needs_repaint.repaint_asap();
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "touchmove",
+        |event: web_sys::TouchEvent, mut runner_lock| {
+            let mut latest_touch_pos_id = runner_lock.input.latest_touch_pos_id;
+            let pos =
+                pos_from_touch_event(runner_lock.canvas_id(), &event, &mut latest_touch_pos_id);
+            runner_lock.input.latest_touch_pos_id = latest_touch_pos_id;
+            runner_lock.input.latest_touch_pos = Some(pos);
+            runner_lock
+                .input
+                .raw
+                .events
+                .push(egui::Event::PointerMoved(pos));
+
+            push_touches(&mut runner_lock, egui::TouchPhase::Move, &event);
+            runner_lock.needs_repaint.repaint_asap();
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "touchend",
+        |event: web_sys::TouchEvent, mut runner_lock| {
+            if let Some(pos) = runner_lock.input.latest_touch_pos {
+                let modifiers = runner_lock.input.raw.modifiers;
+                // First release mouse to click:
+                runner_lock
+                    .input
+                    .raw
+                    .events
+                    .push(egui::Event::PointerButton {
+                        pos,
+                        button: egui::PointerButton::Primary,
+                        pressed: false,
+                        modifiers,
+                    });
+                // Then remove hover effect:
+                runner_lock.input.raw.events.push(egui::Event::PointerGone);
+
+                push_touches(&mut runner_lock, egui::TouchPhase::End, &event);
+                runner_lock.needs_repaint.repaint_asap();
+                event.stop_propagation();
+                event.prevent_default();
+            }
+
+            // Finally, focus or blur text agent to toggle mobile keyboard:
+            text_agent::update_text_agent(runner_lock);
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "touchcancel",
+        |event: web_sys::TouchEvent, mut runner_lock| {
+            push_touches(&mut runner_lock, egui::TouchPhase::Cancel, &event);
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "wheel",
+        |event: web_sys::WheelEvent, mut runner_lock| {
+            let unit = match event.delta_mode() {
+                web_sys::WheelEvent::DOM_DELTA_PIXEL => egui::MouseWheelUnit::Point,
+                web_sys::WheelEvent::DOM_DELTA_LINE => egui::MouseWheelUnit::Line,
+                web_sys::WheelEvent::DOM_DELTA_PAGE => egui::MouseWheelUnit::Page,
+                _ => return,
+            };
+            // delta sign is flipped to match native (winit) convention.
+            let delta = -egui::vec2(event.delta_x() as f32, event.delta_y() as f32);
+            let modifiers = runner_lock.input.raw.modifiers;
+
+            runner_lock.input.raw.events.push(egui::Event::MouseWheel {
+                unit,
+                delta,
+                modifiers,
+            });
+
+            let scroll_multiplier = match unit {
+                egui::MouseWheelUnit::Page => canvas_size_in_points(runner_lock.canvas_id()).y,
+                egui::MouseWheelUnit::Line => {
+                    #[allow(clippy::let_and_return)]
+                    let points_per_scroll_line = 8.0; // Note that this is intentionally different from what we use in winit.
+                    points_per_scroll_line
+                }
+                egui::MouseWheelUnit::Point => 1.0,
+            };
+
+            let mut delta = scroll_multiplier * delta;
+
+            // Report a zoom event in case CTRL (on Windows or Linux) or CMD (on Mac) is pressed.
+            // This if-statement is equivalent to how `Modifiers.command` is determined in
+            // `modifiers_from_event()`, but we cannot directly use that fn for a [`WheelEvent`].
+            if event.ctrl_key() || event.meta_key() {
+                let factor = (delta.y / 200.0).exp();
+                runner_lock.input.raw.events.push(egui::Event::Zoom(factor));
+            } else {
+                if event.shift_key() {
+                    // Treat as horizontal scrolling.
+                    // Note: one Mac we already get horizontal scroll events when shift is down.
+                    delta = egui::vec2(delta.x + delta.y, 0.0);
+                }
+
+                runner_lock
+                    .input
+                    .raw
+                    .events
+                    .push(egui::Event::Scroll(delta));
+            }
+
+            runner_lock.needs_repaint.repaint_asap();
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "dragover",
+        |event: web_sys::DragEvent, mut runner_lock| {
+            if let Some(data_transfer) = event.data_transfer() {
+                runner_lock.input.raw.hovered_files.clear();
+                for i in 0..data_transfer.items().length() {
+                    if let Some(item) = data_transfer.items().get(i) {
+                        runner_lock.input.raw.hovered_files.push(egui::HoveredFile {
+                            mime: item.type_(),
+                            ..Default::default()
+                        });
+                    }
+                }
+                runner_lock.needs_repaint.repaint_asap();
+                event.stop_propagation();
+                event.prevent_default();
+            }
+        },
+    )?;
+
+    runner_container.add_event_listener(
+        &canvas,
+        "dragleave",
+        |event: web_sys::DragEvent, mut runner_lock| {
+            runner_lock.input.raw.hovered_files.clear();
+            runner_lock.needs_repaint.repaint_asap();
+            event.stop_propagation();
+            event.prevent_default();
+        },
+    )?;
+
+    runner_container.add_event_listener(&canvas, "drop", {
+        let runner_ref = runner_container.runner.clone();
+
+        move |event: web_sys::DragEvent, mut runner_lock| {
+            if let Some(data_transfer) = event.data_transfer() {
+                runner_lock.input.raw.hovered_files.clear();
+                runner_lock.needs_repaint.repaint_asap();
+                // Unlock the runner so it can be locked after a future await point
+                drop(runner_lock);
+
+                if let Some(files) = data_transfer.files() {
+                    for i in 0..files.length() {
+                        if let Some(file) = files.get(i) {
+                            let name = file.name();
+                            let last_modified = std::time::UNIX_EPOCH
+                                + std::time::Duration::from_millis(file.last_modified() as u64);
+
+                            tracing::debug!("Loading {:?} ({} bytes)…", name, file.size());
+
+                            let future = wasm_bindgen_futures::JsFuture::from(file.array_buffer());
+
+                            let runner_ref = runner_ref.clone();
+                            let future = async move {
+                                match future.await {
+                                    Ok(array_buffer) => {
+                                        let bytes = js_sys::Uint8Array::new(&array_buffer).to_vec();
+                                        tracing::debug!(
+                                            "Loaded {:?} ({} bytes).",
+                                            name,
+                                            bytes.len()
+                                        );
+
+                                        // Re-lock the mutex on the other side of the await point
+                                        let mut runner_lock = runner_ref.lock();
+                                        runner_lock.input.raw.dropped_files.push(
+                                            egui::DroppedFile {
+                                                name,
+                                                last_modified: Some(last_modified),
+                                                bytes: Some(bytes.into()),
+                                                ..Default::default()
+                                            },
+                                        );
+                                        runner_lock.needs_repaint.repaint_asap();
+                                    }
+                                    Err(err) => {
+                                        tracing::error!("Failed to read file: {:?}", err);
+                                    }
+                                }
+                            };
+                            wasm_bindgen_futures::spawn_local(future);
+                        }
+                    }
+                }
+                event.stop_propagation();
+                event.prevent_default();
+            }
+        }
+    })?;
+
+    Ok(())
+}
diff --git a/egui/crates/eframe/src/web/input.rs b/egui/crates/eframe/src/web/input.rs
new file mode 100644
index 0000000..443c26f
--- /dev/null
+++ b/egui/crates/eframe/src/web/input.rs
@@ -0,0 +1,217 @@
+use super::{canvas_element, canvas_origin, AppRunner};
+
+pub fn pos_from_mouse_event(canvas_id: &str, event: &web_sys::MouseEvent) -> egui::Pos2 {
+    let canvas = canvas_element(canvas_id).unwrap();
+    let rect = canvas.get_bounding_client_rect();
+    egui::Pos2 {
+        x: event.client_x() as f32 - rect.left() as f32,
+        y: event.client_y() as f32 - rect.top() as f32,
+    }
+}
+
+pub fn button_from_mouse_event(event: &web_sys::MouseEvent) -> Option<egui::PointerButton> {
+    match event.button() {
+        0 => Some(egui::PointerButton::Primary),
+        1 => Some(egui::PointerButton::Middle),
+        2 => Some(egui::PointerButton::Secondary),
+        3 => Some(egui::PointerButton::Extra1),
+        4 => Some(egui::PointerButton::Extra2),
+        _ => None,
+    }
+}
+
+/// A single touch is translated to a pointer movement. When a second touch is added, the pointer
+/// should not jump to a different position. Therefore, we do not calculate the average position
+/// of all touches, but we keep using the same touch as long as it is available.
+///
+/// `touch_id_for_pos` is the [`TouchId`](egui::TouchId) of the [`Touch`](web_sys::Touch) we previously used to determine the
+/// pointer position.
+pub fn pos_from_touch_event(
+    canvas_id: &str,
+    event: &web_sys::TouchEvent,
+    touch_id_for_pos: &mut Option<egui::TouchId>,
+) -> egui::Pos2 {
+    let touch_for_pos = if let Some(touch_id_for_pos) = touch_id_for_pos {
+        // search for the touch we previously used for the position
+        // (unfortunately, `event.touches()` is not a rust collection):
+        (0..event.touches().length())
+            .into_iter()
+            .map(|i| event.touches().get(i).unwrap())
+            .find(|touch| egui::TouchId::from(touch.identifier()) == *touch_id_for_pos)
+    } else {
+        None
+    };
+    // Use the touch found above or pick the first, or return a default position if there is no
+    // touch at all. (The latter is not expected as the current method is only called when there is
+    // at least one touch.)
+    touch_for_pos
+        .or_else(|| event.touches().get(0))
+        .map_or(Default::default(), |touch| {
+            *touch_id_for_pos = Some(egui::TouchId::from(touch.identifier()));
+            pos_from_touch(canvas_origin(canvas_id), &touch)
+        })
+}
+
+fn pos_from_touch(canvas_origin: egui::Pos2, touch: &web_sys::Touch) -> egui::Pos2 {
+    egui::Pos2 {
+        x: touch.page_x() as f32 - canvas_origin.x,
+        y: touch.page_y() as f32 - canvas_origin.y,
+    }
+}
+
+pub fn push_touches(runner: &mut AppRunner, phase: egui::TouchPhase, event: &web_sys::TouchEvent) {
+    let canvas_origin = canvas_origin(runner.canvas_id());
+    for touch_idx in 0..event.changed_touches().length() {
+        if let Some(touch) = event.changed_touches().item(touch_idx) {
+            runner.input.raw.events.push(egui::Event::Touch {
+                device_id: egui::TouchDeviceId(0),
+                id: egui::TouchId::from(touch.identifier()),
+                phase,
+                pos: pos_from_touch(canvas_origin, &touch),
+                force: touch.force(),
+            });
+        }
+    }
+}
+
+/// Web sends all keys as strings, so it is up to us to figure out if it is
+/// a real text input or the name of a key.
+pub fn should_ignore_key(key: &str) -> bool {
+    let is_function_key = key.starts_with('F') && key.len() > 1;
+    is_function_key
+        || matches!(
+            key,
+            "Alt"
+                | "ArrowDown"
+                | "ArrowLeft"
+                | "ArrowRight"
+                | "ArrowUp"
+                | "Backspace"
+                | "CapsLock"
+                | "ContextMenu"
+                | "Control"
+                | "Delete"
+                | "End"
+                | "Enter"
+                | "Esc"
+                | "Escape"
+                | "GroupNext" // https://github.com/emilk/egui/issues/510
+                | "Help"
+                | "Home"
+                | "Insert"
+                | "Meta"
+                | "NumLock"
+                | "PageDown"
+                | "PageUp"
+                | "Pause"
+                | "ScrollLock"
+                | "Shift"
+                | "Tab"
+        )
+}
+
+/// Web sends all all keys as strings, so it is up to us to figure out if it is
+/// a real text input or the name of a key.
+pub fn translate_key(key: &str) -> Option<egui::Key> {
+    use egui::Key;
+
+    match key {
+        "ArrowDown" => Some(Key::ArrowDown),
+        "ArrowLeft" => Some(Key::ArrowLeft),
+        "ArrowRight" => Some(Key::ArrowRight),
+        "ArrowUp" => Some(Key::ArrowUp),
+
+        "Esc" | "Escape" => Some(Key::Escape),
+        "Tab" => Some(Key::Tab),
+        "Backspace" => Some(Key::Backspace),
+        "Enter" => Some(Key::Enter),
+        "Space" | " " => Some(Key::Space),
+
+        "Help" | "Insert" => Some(Key::Insert),
+        "Delete" => Some(Key::Delete),
+        "Home" => Some(Key::Home),
+        "End" => Some(Key::End),
+        "PageUp" => Some(Key::PageUp),
+        "PageDown" => Some(Key::PageDown),
+
+        "-" => Some(Key::Minus),
+        "+" | "=" => Some(Key::PlusEquals),
+
+        "0" => Some(Key::Num0),
+        "1" => Some(Key::Num1),
+        "2" => Some(Key::Num2),
+        "3" => Some(Key::Num3),
+        "4" => Some(Key::Num4),
+        "5" => Some(Key::Num5),
+        "6" => Some(Key::Num6),
+        "7" => Some(Key::Num7),
+        "8" => Some(Key::Num8),
+        "9" => Some(Key::Num9),
+
+        "a" | "A" => Some(Key::A),
+        "b" | "B" => Some(Key::B),
+        "c" | "C" => Some(Key::C),
+        "d" | "D" => Some(Key::D),
+        "e" | "E" => Some(Key::E),
+        "f" | "F" => Some(Key::F),
+        "g" | "G" => Some(Key::G),
+        "h" | "H" => Some(Key::H),
+        "i" | "I" => Some(Key::I),
+        "j" | "J" => Some(Key::J),
+        "k" | "K" => Some(Key::K),
+        "l" | "L" => Some(Key::L),
+        "m" | "M" => Some(Key::M),
+        "n" | "N" => Some(Key::N),
+        "o" | "O" => Some(Key::O),
+        "p" | "P" => Some(Key::P),
+        "q" | "Q" => Some(Key::Q),
+        "r" | "R" => Some(Key::R),
+        "s" | "S" => Some(Key::S),
+        "t" | "T" => Some(Key::T),
+        "u" | "U" => Some(Key::U),
+        "v" | "V" => Some(Key::V),
+        "w" | "W" => Some(Key::W),
+        "x" | "X" => Some(Key::X),
+        "y" | "Y" => Some(Key::Y),
+        "z" | "Z" => Some(Key::Z),
+
+        "F1" => Some(Key::F1),
+        "F2" => Some(Key::F2),
+        "F3" => Some(Key::F3),
+        "F4" => Some(Key::F4),
+        "F5" => Some(Key::F5),
+        "F6" => Some(Key::F6),
+        "F7" => Some(Key::F7),
+        "F8" => Some(Key::F8),
+        "F9" => Some(Key::F9),
+        "F10" => Some(Key::F10),
+        "F11" => Some(Key::F11),
+        "F12" => Some(Key::F12),
+        "F13" => Some(Key::F13),
+        "F14" => Some(Key::F14),
+        "F15" => Some(Key::F15),
+        "F16" => Some(Key::F16),
+        "F17" => Some(Key::F17),
+        "F18" => Some(Key::F18),
+        "F19" => Some(Key::F19),
+        "F20" => Some(Key::F20),
+
+        _ => None,
+    }
+}
+
+pub fn modifiers_from_event(event: &web_sys::KeyboardEvent) -> egui::Modifiers {
+    egui::Modifiers {
+        alt: event.alt_key(),
+        ctrl: event.ctrl_key(),
+        shift: event.shift_key(),
+
+        // Ideally we should know if we are running or mac or not,
+        // but this works good enough for now.
+        mac_cmd: event.meta_key(),
+
+        // Ideally we should know if we are running or mac or not,
+        // but this works good enough for now.
+        command: event.ctrl_key() || event.meta_key(),
+    }
+}
diff --git a/egui/crates/eframe/src/web/mod.rs b/egui/crates/eframe/src/web/mod.rs
new file mode 100644
index 0000000..a6ac014
--- /dev/null
+++ b/egui/crates/eframe/src/web/mod.rs
@@ -0,0 +1,271 @@
+//! [`egui`] bindings for web apps (compiling to WASM).
+
+#![allow(clippy::missing_errors_doc)] // So many `-> Result<_, JsValue>`
+
+pub mod backend;
+mod events;
+mod input;
+pub mod screen_reader;
+pub mod storage;
+mod text_agent;
+
+#[cfg(not(any(feature = "glow", feature = "wgpu")))]
+compile_error!("You must enable either the 'glow' or 'wgpu' feature");
+
+mod web_painter;
+
+#[cfg(feature = "glow")]
+mod web_painter_glow;
+#[cfg(feature = "glow")]
+pub(crate) type ActiveWebPainter = web_painter_glow::WebPainterGlow;
+
+#[cfg(feature = "wgpu")]
+mod web_painter_wgpu;
+#[cfg(all(feature = "wgpu", not(feature = "glow")))]
+pub(crate) type ActiveWebPainter = web_painter_wgpu::WebPainterWgpu;
+
+pub use backend::*;
+pub use events::*;
+pub use storage::*;
+
+use std::collections::BTreeMap;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+use egui::Vec2;
+use wasm_bindgen::prelude::*;
+use web_sys::{EventTarget, MediaQueryList};
+
+use input::*;
+
+use crate::Theme;
+
+// ----------------------------------------------------------------------------
+
+/// Current time in seconds (since undefined point in time).
+///
+/// Monotonically increasing.
+pub fn now_sec() -> f64 {
+    web_sys::window()
+        .expect("should have a Window")
+        .performance()
+        .expect("should have a Performance")
+        .now()
+        / 1000.0
+}
+
+#[allow(dead_code)]
+pub fn screen_size_in_native_points() -> Option<egui::Vec2> {
+    let window = web_sys::window()?;
+    Some(egui::vec2(
+        window.inner_width().ok()?.as_f64()? as f32,
+        window.inner_height().ok()?.as_f64()? as f32,
+    ))
+}
+
+pub fn native_pixels_per_point() -> f32 {
+    let pixels_per_point = web_sys::window().unwrap().device_pixel_ratio() as f32;
+    if pixels_per_point > 0.0 && pixels_per_point.is_finite() {
+        pixels_per_point
+    } else {
+        1.0
+    }
+}
+
+pub fn system_theme() -> Option<Theme> {
+    let dark_mode = prefers_color_scheme_dark(&web_sys::window()?)
+        .ok()??
+        .matches();
+    Some(theme_from_dark_mode(dark_mode))
+}
+
+fn prefers_color_scheme_dark(window: &web_sys::Window) -> Result<Option<MediaQueryList>, JsValue> {
+    window.match_media("(prefers-color-scheme: dark)")
+}
+
+fn theme_from_dark_mode(dark_mode: bool) -> Theme {
+    if dark_mode {
+        Theme::Dark
+    } else {
+        Theme::Light
+    }
+}
+
+pub fn canvas_element(canvas_id: &str) -> Option<web_sys::HtmlCanvasElement> {
+    let document = web_sys::window()?.document()?;
+    let canvas = document.get_element_by_id(canvas_id)?;
+    canvas.dyn_into::<web_sys::HtmlCanvasElement>().ok()
+}
+
+pub fn canvas_element_or_die(canvas_id: &str) -> web_sys::HtmlCanvasElement {
+    canvas_element(canvas_id)
+        .unwrap_or_else(|| panic!("Failed to find canvas with id {:?}", canvas_id))
+}
+
+fn canvas_origin(canvas_id: &str) -> egui::Pos2 {
+    let rect = canvas_element(canvas_id)
+        .unwrap()
+        .get_bounding_client_rect();
+    egui::pos2(rect.left() as f32, rect.top() as f32)
+}
+
+pub fn canvas_size_in_points(canvas_id: &str) -> egui::Vec2 {
+    let canvas = canvas_element(canvas_id).unwrap();
+    let pixels_per_point = native_pixels_per_point();
+    egui::vec2(
+        canvas.width() as f32 / pixels_per_point,
+        canvas.height() as f32 / pixels_per_point,
+    )
+}
+
+pub fn resize_canvas_to_screen_size(canvas_id: &str, max_size_points: egui::Vec2) -> Option<()> {
+    let canvas = canvas_element(canvas_id)?;
+    let parent = canvas.parent_element()?;
+
+    // Prefer the client width and height so that if the parent
+    // element is resized that the egui canvas resizes appropriately.
+    let width = parent.client_width();
+    let height = parent.client_height();
+
+    let canvas_real_size = Vec2 {
+        x: width as f32,
+        y: height as f32,
+    };
+
+    if width <= 0 || height <= 0 {
+        tracing::error!("egui canvas parent size is {}x{}. Try adding `html, body {{ height: 100%; width: 100% }}` to your CSS!", width, height);
+    }
+
+    let pixels_per_point = native_pixels_per_point();
+
+    let max_size_pixels = pixels_per_point * max_size_points;
+
+    let canvas_size_pixels = pixels_per_point * canvas_real_size;
+    let canvas_size_pixels = canvas_size_pixels.min(max_size_pixels);
+    let canvas_size_points = canvas_size_pixels / pixels_per_point;
+
+    // Make sure that the height and width are always even numbers.
+    // otherwise, the page renders blurry on some platforms.
+    // See https://github.com/emilk/egui/issues/103
+    fn round_to_even(v: f32) -> f32 {
+        (v / 2.0).round() * 2.0
+    }
+
+    canvas
+        .style()
+        .set_property(
+            "width",
+            &format!("{}px", round_to_even(canvas_size_points.x)),
+        )
+        .ok()?;
+    canvas
+        .style()
+        .set_property(
+            "height",
+            &format!("{}px", round_to_even(canvas_size_points.y)),
+        )
+        .ok()?;
+    canvas.set_width(round_to_even(canvas_size_pixels.x) as u32);
+    canvas.set_height(round_to_even(canvas_size_pixels.y) as u32);
+
+    Some(())
+}
+
+// ----------------------------------------------------------------------------
+
+pub fn set_cursor_icon(cursor: egui::CursorIcon) -> Option<()> {
+    let document = web_sys::window()?.document()?;
+    document
+        .body()?
+        .style()
+        .set_property("cursor", cursor_web_name(cursor))
+        .ok()
+}
+
+#[cfg(web_sys_unstable_apis)]
+pub fn set_clipboard_text(s: &str) {
+    if let Some(window) = web_sys::window() {
+        if let Some(clipboard) = window.navigator().clipboard() {
+            let promise = clipboard.write_text(s);
+            let future = wasm_bindgen_futures::JsFuture::from(promise);
+            let future = async move {
+                if let Err(err) = future.await {
+                    tracing::error!("Copy/cut action denied: {:?}", err);
+                }
+            };
+            wasm_bindgen_futures::spawn_local(future);
+        }
+    }
+}
+
+fn cursor_web_name(cursor: egui::CursorIcon) -> &'static str {
+    match cursor {
+        egui::CursorIcon::Alias => "alias",
+        egui::CursorIcon::AllScroll => "all-scroll",
+        egui::CursorIcon::Cell => "cell",
+        egui::CursorIcon::ContextMenu => "context-menu",
+        egui::CursorIcon::Copy => "copy",
+        egui::CursorIcon::Crosshair => "crosshair",
+        egui::CursorIcon::Default => "default",
+        egui::CursorIcon::Grab => "grab",
+        egui::CursorIcon::Grabbing => "grabbing",
+        egui::CursorIcon::Help => "help",
+        egui::CursorIcon::Move => "move",
+        egui::CursorIcon::NoDrop => "no-drop",
+        egui::CursorIcon::None => "none",
+        egui::CursorIcon::NotAllowed => "not-allowed",
+        egui::CursorIcon::PointingHand => "pointer",
+        egui::CursorIcon::Progress => "progress",
+        egui::CursorIcon::ResizeHorizontal => "ew-resize",
+        egui::CursorIcon::ResizeNeSw => "nesw-resize",
+        egui::CursorIcon::ResizeNwSe => "nwse-resize",
+        egui::CursorIcon::ResizeVertical => "ns-resize",
+
+        egui::CursorIcon::ResizeEast => "e-resize",
+        egui::CursorIcon::ResizeSouthEast => "se-resize",
+        egui::CursorIcon::ResizeSouth => "s-resize",
+        egui::CursorIcon::ResizeSouthWest => "sw-resize",
+        egui::CursorIcon::ResizeWest => "w-resize",
+        egui::CursorIcon::ResizeNorthWest => "nw-resize",
+        egui::CursorIcon::ResizeNorth => "n-resize",
+        egui::CursorIcon::ResizeNorthEast => "ne-resize",
+        egui::CursorIcon::ResizeColumn => "col-resize",
+        egui::CursorIcon::ResizeRow => "row-resize",
+
+        egui::CursorIcon::Text => "text",
+        egui::CursorIcon::VerticalText => "vertical-text",
+        egui::CursorIcon::Wait => "wait",
+        egui::CursorIcon::ZoomIn => "zoom-in",
+        egui::CursorIcon::ZoomOut => "zoom-out",
+    }
+}
+
+pub fn open_url(url: &str, new_tab: bool) -> Option<()> {
+    let name = if new_tab { "_blank" } else { "_self" };
+
+    web_sys::window()?
+        .open_with_url_and_target(url, name)
+        .ok()?;
+    Some(())
+}
+
+/// e.g. "#fragment" part of "www.example.com/index.html#fragment",
+///
+/// Percent decoded
+pub fn location_hash() -> String {
+    percent_decode(
+        &web_sys::window()
+            .unwrap()
+            .location()
+            .hash()
+            .unwrap_or_default(),
+    )
+}
+
+pub fn percent_decode(s: &str) -> String {
+    percent_encoding::percent_decode_str(s)
+        .decode_utf8_lossy()
+        .to_string()
+}
diff --git a/egui/crates/eframe/src/web/screen_reader.rs b/egui/crates/eframe/src/web/screen_reader.rs
new file mode 100644
index 0000000..058407b
--- /dev/null
+++ b/egui/crates/eframe/src/web/screen_reader.rs
@@ -0,0 +1,49 @@
+pub struct ScreenReader {
+    #[cfg(feature = "tts")]
+    tts: Option<tts::Tts>,
+}
+
+#[cfg(not(feature = "tts"))]
+#[allow(clippy::derivable_impls)] // False positive
+impl Default for ScreenReader {
+    fn default() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(feature = "tts")]
+impl Default for ScreenReader {
+    fn default() -> Self {
+        let tts = match tts::Tts::default() {
+            Ok(screen_reader) => {
+                tracing::debug!("Initialized screen reader.");
+                Some(screen_reader)
+            }
+            Err(err) => {
+                tracing::warn!("Failed to load screen reader: {}", err);
+                None
+            }
+        };
+        Self { tts }
+    }
+}
+
+impl ScreenReader {
+    #[cfg(not(feature = "tts"))]
+    #[allow(clippy::unused_self)]
+    pub fn speak(&mut self, _text: &str) {}
+
+    #[cfg(feature = "tts")]
+    pub fn speak(&mut self, text: &str) {
+        if text.is_empty() {
+            return;
+        }
+        if let Some(tts) = &mut self.tts {
+            tracing::debug!("Speaking: {:?}", text);
+            let interrupt = true;
+            if let Err(err) = tts.speak(text, interrupt) {
+                tracing::warn!("Failed to read: {}", err);
+            }
+        }
+    }
+}
diff --git a/egui/crates/eframe/src/web/storage.rs b/egui/crates/eframe/src/web/storage.rs
new file mode 100644
index 0000000..f0f3c84
--- /dev/null
+++ b/egui/crates/eframe/src/web/storage.rs
@@ -0,0 +1,43 @@
+fn local_storage() -> Option<web_sys::Storage> {
+    web_sys::window()?.local_storage().ok()?
+}
+
+pub fn local_storage_get(key: &str) -> Option<String> {
+    local_storage().map(|storage| storage.get_item(key).ok())??
+}
+
+pub fn local_storage_set(key: &str, value: &str) {
+    local_storage().map(|storage| storage.set_item(key, value));
+}
+
+#[cfg(feature = "persistence")]
+pub fn load_memory(ctx: &egui::Context) {
+    if let Some(memory_string) = local_storage_get("egui_memory_ron") {
+        match ron::from_str(&memory_string) {
+            Ok(memory) => {
+                ctx.memory_mut(|m| *m = memory);
+            }
+            Err(err) => {
+                tracing::error!("Failed to parse memory RON: {}", err);
+            }
+        }
+    }
+}
+
+#[cfg(not(feature = "persistence"))]
+pub fn load_memory(_: &egui::Context) {}
+
+#[cfg(feature = "persistence")]
+pub fn save_memory(ctx: &egui::Context) {
+    match ctx.memory(|mem| ron::to_string(mem)) {
+        Ok(ron) => {
+            local_storage_set("egui_memory_ron", &ron);
+        }
+        Err(err) => {
+            tracing::error!("Failed to serialize memory as RON: {}", err);
+        }
+    }
+}
+
+#[cfg(not(feature = "persistence"))]
+pub fn save_memory(_: &egui::Context) {}
diff --git a/egui/crates/eframe/src/web/text_agent.rs b/egui/crates/eframe/src/web/text_agent.rs
new file mode 100644
index 0000000..de83dda
--- /dev/null
+++ b/egui/crates/eframe/src/web/text_agent.rs
@@ -0,0 +1,225 @@
+//! The text agent is an `<input>` element used to trigger
+//! mobile keyboard and IME input.
+
+use super::{canvas_element, AppRunner, AppRunnerContainer};
+use egui::mutex::MutexGuard;
+use std::cell::Cell;
+use std::rc::Rc;
+use wasm_bindgen::prelude::*;
+
+static AGENT_ID: &str = "egui_text_agent";
+
+pub fn text_agent() -> web_sys::HtmlInputElement {
+    web_sys::window()
+        .unwrap()
+        .document()
+        .unwrap()
+        .get_element_by_id(AGENT_ID)
+        .unwrap()
+        .dyn_into()
+        .unwrap()
+}
+
+/// Text event handler,
+pub fn install_text_agent(runner_container: &mut AppRunnerContainer) -> Result<(), JsValue> {
+    let window = web_sys::window().unwrap();
+    let document = window.document().unwrap();
+    let body = document.body().expect("document should have a body");
+    let input = document
+        .create_element("input")?
+        .dyn_into::<web_sys::HtmlInputElement>()?;
+    let input = std::rc::Rc::new(input);
+    input.set_id(AGENT_ID);
+    let is_composing = Rc::new(Cell::new(false));
+    {
+        let style = input.style();
+        // Transparent
+        style.set_property("opacity", "0").unwrap();
+        // Hide under canvas
+        style.set_property("z-index", "-1").unwrap();
+    }
+    // Set size as small as possible, in case user may click on it.
+    input.set_size(1);
+    input.set_autofocus(true);
+    input.set_hidden(true);
+
+    // When IME is off
+    runner_container.add_event_listener(&input, "input", {
+        let input_clone = input.clone();
+        let is_composing = is_composing.clone();
+
+        move |_event: web_sys::InputEvent, mut runner_lock| {
+            let text = input_clone.value();
+            if !text.is_empty() && !is_composing.get() {
+                input_clone.set_value("");
+                runner_lock.input.raw.events.push(egui::Event::Text(text));
+                runner_lock.needs_repaint.repaint_asap();
+            }
+        }
+    })?;
+
+    {
+        // When IME is on, handle composition event
+        runner_container.add_event_listener(&input, "compositionstart", {
+            let input_clone = input.clone();
+            let is_composing = is_composing.clone();
+
+            move |_event: web_sys::CompositionEvent, mut runner_lock: MutexGuard<'_, AppRunner>| {
+                is_composing.set(true);
+                input_clone.set_value("");
+
+                runner_lock
+                    .input
+                    .raw
+                    .events
+                    .push(egui::Event::CompositionStart);
+                runner_lock.needs_repaint.repaint_asap();
+            }
+        })?;
+
+        runner_container.add_event_listener(
+            &input,
+            "compositionupdate",
+            move |event: web_sys::CompositionEvent, mut runner_lock: MutexGuard<'_, AppRunner>| {
+                if let Some(event) = event.data().map(egui::Event::CompositionUpdate) {
+                    runner_lock.input.raw.events.push(event);
+                    runner_lock.needs_repaint.repaint_asap();
+                }
+            },
+        )?;
+
+        runner_container.add_event_listener(&input, "compositionend", {
+            let input_clone = input.clone();
+
+            move |event: web_sys::CompositionEvent, mut runner_lock: MutexGuard<'_, AppRunner>| {
+                is_composing.set(false);
+                input_clone.set_value("");
+
+                if let Some(event) = event.data().map(egui::Event::CompositionEnd) {
+                    runner_lock.input.raw.events.push(event);
+                    runner_lock.needs_repaint.repaint_asap();
+                }
+            }
+        })?;
+    }
+
+    // When input lost focus, focus on it again.
+    // It is useful when user click somewhere outside canvas.
+    runner_container.add_event_listener(
+        &input,
+        "focusout",
+        move |_event: web_sys::MouseEvent, _| {
+            // Delay 10 ms, and focus again.
+            let func = js_sys::Function::new_no_args(&format!(
+                "document.getElementById('{}').focus()",
+                AGENT_ID
+            ));
+            window
+                .set_timeout_with_callback_and_timeout_and_arguments_0(&func, 10)
+                .unwrap();
+        },
+    )?;
+
+    body.append_child(&input)?;
+
+    Ok(())
+}
+
+/// Focus or blur text agent to toggle mobile keyboard.
+pub fn update_text_agent(runner: MutexGuard<'_, AppRunner>) -> Option<()> {
+    use web_sys::HtmlInputElement;
+    let window = web_sys::window()?;
+    let document = window.document()?;
+    let input: HtmlInputElement = document.get_element_by_id(AGENT_ID)?.dyn_into().unwrap();
+    let canvas_style = canvas_element(runner.canvas_id())?.style();
+
+    if runner.mutable_text_under_cursor {
+        let is_already_editing = input.hidden();
+        if is_already_editing {
+            input.set_hidden(false);
+            input.focus().ok()?;
+
+            // Move up canvas so that text edit is shown at ~30% of screen height.
+            // Only on touch screens, when keyboard popups.
+            if let Some(latest_touch_pos) = runner.input.latest_touch_pos {
+                let window_height = window.inner_height().ok()?.as_f64()? as f32;
+                let current_rel = latest_touch_pos.y / window_height;
+
+                // estimated amount of screen covered by keyboard
+                let keyboard_fraction = 0.5;
+
+                if current_rel > keyboard_fraction {
+                    // below the keyboard
+
+                    let target_rel = 0.3;
+
+                    // Note: `delta` is negative, since we are moving the canvas UP
+                    let delta = target_rel - current_rel;
+
+                    let delta = delta.max(-keyboard_fraction); // Don't move it crazy much
+
+                    let new_pos_percent = format!("{}%", (delta * 100.0).round());
+
+                    canvas_style.set_property("position", "absolute").ok()?;
+                    canvas_style.set_property("top", &new_pos_percent).ok()?;
+                }
+            }
+        }
+    } else {
+        // Drop runner lock
+        drop(runner);
+
+        // Holding the runner lock while calling input.blur() causes a panic.
+        // This is most probably caused by the browser running the event handler
+        // for the triggered blur event synchronously, meaning that the mutex
+        // lock does not get dropped by the time another event handler is called.
+        //
+        // Why this didn't exist before #1290 is a mystery to me, but it exists now
+        // and this apparently is the fix for it
+        //
+        // ¯\_(ツ)_/¯ - @DusterTheFirst
+        input.blur().ok()?;
+
+        input.set_hidden(true);
+        canvas_style.set_property("position", "absolute").ok()?;
+        canvas_style.set_property("top", "0%").ok()?; // move back to normal position
+    }
+    Some(())
+}
+
+/// If context is running under mobile device?
+fn is_mobile() -> Option<bool> {
+    const MOBILE_DEVICE: [&str; 6] = ["Android", "iPhone", "iPad", "iPod", "webOS", "BlackBerry"];
+
+    let user_agent = web_sys::window()?.navigator().user_agent().ok()?;
+    let is_mobile = MOBILE_DEVICE.iter().any(|&name| user_agent.contains(name));
+    Some(is_mobile)
+}
+
+// Move text agent to text cursor's position, on desktop/laptop,
+// candidate window moves following text element (agent),
+// so it appears that the IME candidate window moves with text cursor.
+// On mobile devices, there is no need to do that.
+pub fn move_text_cursor(cursor: Option<egui::Pos2>, canvas_id: &str) -> Option<()> {
+    let style = text_agent().style();
+    // Note: movint agent on mobile devices will lead to unpredictable scroll.
+    if is_mobile() == Some(false) {
+        cursor.as_ref().and_then(|&egui::Pos2 { x, y }| {
+            let canvas = canvas_element(canvas_id)?;
+            let bounding_rect = text_agent().get_bounding_client_rect();
+            let y = (y + (canvas.scroll_top() + canvas.offset_top()) as f32)
+                .min(canvas.client_height() as f32 - bounding_rect.height() as f32);
+            let x = x + (canvas.scroll_left() + canvas.offset_left()) as f32;
+            // Canvas is translated 50% horizontally in html.
+            let x = (x - canvas.offset_width() as f32 / 2.0)
+                .min(canvas.client_width() as f32 - bounding_rect.width() as f32);
+            style.set_property("position", "absolute").ok()?;
+            style.set_property("top", &format!("{}px", y)).ok()?;
+            style.set_property("left", &format!("{}px", x)).ok()
+        })
+    } else {
+        style.set_property("position", "absolute").ok()?;
+        style.set_property("top", "0px").ok()?;
+        style.set_property("left", "0px").ok()
+    }
+}
diff --git a/egui/crates/eframe/src/web/web_painter.rs b/egui/crates/eframe/src/web/web_painter.rs
new file mode 100644
index 0000000..9c7631b
--- /dev/null
+++ b/egui/crates/eframe/src/web/web_painter.rs
@@ -0,0 +1,29 @@
+use wasm_bindgen::JsValue;
+
+/// Renderer for a browser canvas.
+/// As of writing we're not allowing to decide on the painter at runtime,
+/// therefore this trait is merely there for specifying and documenting the interface.
+pub(crate) trait WebPainter {
+    // Create a new web painter targeting a given canvas.
+    // fn new(canvas_id: &str, options: &WebOptions) -> Result<Self, String>
+    // where
+    //     Self: Sized;
+
+    /// Id of the canvas in use.
+    fn canvas_id(&self) -> &str;
+
+    /// Maximum size of a texture in one direction.
+    fn max_texture_side(&self) -> usize;
+
+    /// Update all internal textures and paint gui.
+    fn paint_and_update_textures(
+        &mut self,
+        clear_color: [f32; 4],
+        clipped_primitives: &[egui::ClippedPrimitive],
+        pixels_per_point: f32,
+        textures_delta: &egui::TexturesDelta,
+    ) -> Result<(), JsValue>;
+
+    /// Destroy all resources.
+    fn destroy(&mut self);
+}
diff --git a/egui/crates/eframe/src/web/web_painter_glow.rs b/egui/crates/eframe/src/web/web_painter_glow.rs
new file mode 100644
index 0000000..0fe7e12
--- /dev/null
+++ b/egui/crates/eframe/src/web/web_painter_glow.rs
@@ -0,0 +1,184 @@
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use web_sys::HtmlCanvasElement;
+
+use egui_glow::glow;
+
+use crate::{WebGlContextOption, WebOptions};
+
+use super::web_painter::WebPainter;
+
+pub(crate) struct WebPainterGlow {
+    canvas: HtmlCanvasElement,
+    canvas_id: String,
+    painter: egui_glow::Painter,
+}
+
+impl WebPainterGlow {
+    pub fn gl(&self) -> &std::sync::Arc<glow::Context> {
+        self.painter.gl()
+    }
+
+    pub async fn new(canvas_id: &str, options: &WebOptions) -> Result<Self, String> {
+        let canvas = super::canvas_element_or_die(canvas_id);
+
+        let (gl, shader_prefix) =
+            init_glow_context_from_canvas(&canvas, options.webgl_context_option)?;
+        let gl = std::sync::Arc::new(gl);
+
+        let painter = egui_glow::Painter::new(gl, shader_prefix, None)
+            .map_err(|error| format!("Error starting glow painter: {}", error))?;
+
+        Ok(Self {
+            canvas,
+            canvas_id: canvas_id.to_owned(),
+            painter,
+        })
+    }
+}
+
+impl WebPainter for WebPainterGlow {
+    fn max_texture_side(&self) -> usize {
+        self.painter.max_texture_side()
+    }
+
+    fn canvas_id(&self) -> &str {
+        &self.canvas_id
+    }
+
+    fn paint_and_update_textures(
+        &mut self,
+        clear_color: [f32; 4],
+        clipped_primitives: &[egui::ClippedPrimitive],
+        pixels_per_point: f32,
+        textures_delta: &egui::TexturesDelta,
+    ) -> Result<(), JsValue> {
+        let canvas_dimension = [self.canvas.width(), self.canvas.height()];
+
+        for (id, image_delta) in &textures_delta.set {
+            self.painter.set_texture(*id, image_delta);
+        }
+
+        egui_glow::painter::clear(self.painter.gl(), canvas_dimension, clear_color);
+        self.painter
+            .paint_primitives(canvas_dimension, pixels_per_point, clipped_primitives);
+
+        for &id in &textures_delta.free {
+            self.painter.free_texture(id);
+        }
+
+        Ok(())
+    }
+
+    fn destroy(&mut self) {
+        self.painter.destroy();
+    }
+}
+
+/// Returns glow context and shader prefix.
+fn init_glow_context_from_canvas(
+    canvas: &HtmlCanvasElement,
+    options: WebGlContextOption,
+) -> Result<(glow::Context, &'static str), String> {
+    let result = match options {
+        // Force use WebGl1
+        WebGlContextOption::WebGl1 => init_webgl1(canvas),
+        // Force use WebGl2
+        WebGlContextOption::WebGl2 => init_webgl2(canvas),
+        // Trying WebGl2 first
+        WebGlContextOption::BestFirst => init_webgl2(canvas).or_else(|| init_webgl1(canvas)),
+        // Trying WebGl1 first (useful for testing).
+        WebGlContextOption::CompatibilityFirst => {
+            init_webgl1(canvas).or_else(|| init_webgl2(canvas))
+        }
+    };
+
+    if let Some(result) = result {
+        Ok(result)
+    } else {
+        Err("WebGL isn't supported".into())
+    }
+}
+
+fn init_webgl1(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
+    let gl1_ctx = canvas
+        .get_context("webgl")
+        .expect("Failed to query about WebGL2 context");
+
+    let gl1_ctx = gl1_ctx?;
+    tracing::debug!("WebGL1 selected.");
+
+    let gl1_ctx = gl1_ctx
+        .dyn_into::<web_sys::WebGlRenderingContext>()
+        .unwrap();
+
+    let shader_prefix = if webgl1_requires_brightening(&gl1_ctx) {
+        tracing::debug!("Enabling webkitGTK brightening workaround.");
+        "#define APPLY_BRIGHTENING_GAMMA"
+    } else {
+        ""
+    };
+
+    let gl = glow::Context::from_webgl1_context(gl1_ctx);
+
+    Some((gl, shader_prefix))
+}
+
+fn init_webgl2(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
+    let gl2_ctx = canvas
+        .get_context("webgl2")
+        .expect("Failed to query about WebGL2 context");
+
+    let gl2_ctx = gl2_ctx?;
+    tracing::debug!("WebGL2 selected.");
+
+    let gl2_ctx = gl2_ctx
+        .dyn_into::<web_sys::WebGl2RenderingContext>()
+        .unwrap();
+    let gl = glow::Context::from_webgl2_context(gl2_ctx);
+    let shader_prefix = "";
+
+    Some((gl, shader_prefix))
+}
+
+fn webgl1_requires_brightening(gl: &web_sys::WebGlRenderingContext) -> bool {
+    // See https://github.com/emilk/egui/issues/794
+
+    // detect WebKitGTK
+
+    // WebKitGTK use WebKit default unmasked vendor and renderer
+    // but safari use same vendor and renderer
+    // so exclude "Mac OS X" user-agent.
+    let user_agent = web_sys::window().unwrap().navigator().user_agent().unwrap();
+    !user_agent.contains("Mac OS X") && is_safari_and_webkit_gtk(gl)
+}
+
+/// detecting Safari and `webkitGTK`.
+///
+/// Safari and `webkitGTK` use unmasked renderer :Apple GPU
+///
+/// If we detect safari or `webkitGTKs` returns true.
+///
+/// This function used to avoid displaying linear color with `sRGB` supported systems.
+fn is_safari_and_webkit_gtk(gl: &web_sys::WebGlRenderingContext) -> bool {
+    // This call produces a warning in Firefox ("WEBGL_debug_renderer_info is deprecated in Firefox and will be removed.")
+    // but unless we call it we get errors in Chrome when we call `get_parameter` below.
+    // TODO(emilk): do something smart based on user agent?
+    if gl
+        .get_extension("WEBGL_debug_renderer_info")
+        .unwrap()
+        .is_some()
+    {
+        if let Ok(renderer) =
+            gl.get_parameter(web_sys::WebglDebugRendererInfo::UNMASKED_RENDERER_WEBGL)
+        {
+            if let Some(renderer) = renderer.as_string() {
+                if renderer.contains("Apple") {
+                    return true;
+                }
+            }
+        }
+    }
+
+    false
+}
diff --git a/egui/crates/eframe/src/web/web_painter_wgpu.rs b/egui/crates/eframe/src/web/web_painter_wgpu.rs
new file mode 100644
index 0000000..ab55373
--- /dev/null
+++ b/egui/crates/eframe/src/web/web_painter_wgpu.rs
@@ -0,0 +1,282 @@
+use std::sync::Arc;
+
+use wasm_bindgen::JsValue;
+use web_sys::HtmlCanvasElement;
+
+use egui::mutex::RwLock;
+use egui_wgpu::{renderer::ScreenDescriptor, RenderState, SurfaceErrorAction};
+
+use crate::WebOptions;
+
+use super::web_painter::WebPainter;
+
+pub(crate) struct WebPainterWgpu {
+    canvas: HtmlCanvasElement,
+    canvas_id: String,
+    surface: wgpu::Surface,
+    surface_configuration: wgpu::SurfaceConfiguration,
+    limits: wgpu::Limits,
+    render_state: Option<RenderState>,
+    on_surface_error: Arc<dyn Fn(wgpu::SurfaceError) -> SurfaceErrorAction>,
+    depth_format: Option<wgpu::TextureFormat>,
+    depth_texture_view: Option<wgpu::TextureView>,
+}
+
+impl WebPainterWgpu {
+    #[allow(unused)] // only used if `wgpu` is the only active feature.
+    pub fn render_state(&self) -> Option<RenderState> {
+        self.render_state.clone()
+    }
+
+    pub fn generate_depth_texture_view(
+        &self,
+        render_state: &RenderState,
+        width_in_pixels: u32,
+        height_in_pixels: u32,
+    ) -> Option<wgpu::TextureView> {
+        let device = &render_state.device;
+        self.depth_format.map(|depth_format| {
+            device
+                .create_texture(&wgpu::TextureDescriptor {
+                    label: Some("egui_depth_texture"),
+                    size: wgpu::Extent3d {
+                        width: width_in_pixels,
+                        height: height_in_pixels,
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: depth_format,
+                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                    view_formats: &[depth_format],
+                })
+                .create_view(&wgpu::TextureViewDescriptor::default())
+        })
+    }
+
+    #[allow(unused)] // only used if `wgpu` is the only active feature.
+    pub async fn new(canvas_id: &str, options: &WebOptions) -> Result<Self, String> {
+        tracing::debug!("Creating wgpu painter");
+
+        let canvas = super::canvas_element_or_die(canvas_id);
+
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+            backends: options.wgpu_options.backends,
+            dx12_shader_compiler: Default::default(),
+        });
+        let surface = instance
+            .create_surface_from_canvas(&canvas)
+            .map_err(|err| format!("failed to create wgpu surface: {err}"))?;
+
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: options.wgpu_options.power_preference,
+                force_fallback_adapter: false,
+                compatible_surface: None,
+            })
+            .await
+            .ok_or_else(|| "No suitable GPU adapters found on the system".to_owned())?;
+
+        let (device, queue) = adapter
+            .request_device(
+                &options.wgpu_options.device_descriptor,
+                None, // Capture doesn't work in the browser environment.
+            )
+            .await
+            .map_err(|err| format!("Failed to find wgpu device: {}", err))?;
+
+        let target_format =
+            egui_wgpu::preferred_framebuffer_format(&surface.get_capabilities(&adapter).formats);
+
+        let depth_format = options.wgpu_options.depth_format;
+        let renderer = egui_wgpu::Renderer::new(&device, target_format, depth_format, 1);
+        let render_state = RenderState {
+            device: Arc::new(device),
+            queue: Arc::new(queue),
+            target_format,
+            renderer: Arc::new(RwLock::new(renderer)),
+        };
+
+        let surface_configuration = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format: target_format,
+            width: 0,
+            height: 0,
+            present_mode: options.wgpu_options.present_mode,
+            alpha_mode: wgpu::CompositeAlphaMode::Auto,
+            view_formats: vec![target_format],
+        };
+
+        tracing::debug!("wgpu painter initialized.");
+
+        Ok(Self {
+            canvas,
+            canvas_id: canvas_id.to_owned(),
+            render_state: Some(render_state),
+            surface,
+            surface_configuration,
+            depth_format,
+            depth_texture_view: None,
+            limits: options.wgpu_options.device_descriptor.limits.clone(),
+            on_surface_error: options.wgpu_options.on_surface_error.clone(),
+        })
+    }
+}
+
+impl WebPainter for WebPainterWgpu {
+    fn canvas_id(&self) -> &str {
+        &self.canvas_id
+    }
+
+    fn max_texture_side(&self) -> usize {
+        self.limits.max_texture_dimension_2d as _
+    }
+
+    fn paint_and_update_textures(
+        &mut self,
+        clear_color: [f32; 4],
+        clipped_primitives: &[egui::ClippedPrimitive],
+        pixels_per_point: f32,
+        textures_delta: &egui::TexturesDelta,
+    ) -> Result<(), JsValue> {
+        let size_in_pixels = [self.canvas.width(), self.canvas.height()];
+
+        let render_state = if let Some(render_state) = &self.render_state {
+            render_state
+        } else {
+            return Err(JsValue::from_str(
+                "Can't paint, wgpu renderer was already disposed",
+            ));
+        };
+
+        let mut encoder =
+            render_state
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                    label: Some("egui_webpainter_paint_and_update_textures"),
+                });
+
+        // Upload all resources for the GPU.
+        let screen_descriptor = ScreenDescriptor {
+            size_in_pixels,
+            pixels_per_point,
+        };
+
+        let user_cmd_bufs = {
+            let mut renderer = render_state.renderer.write();
+            for (id, image_delta) in &textures_delta.set {
+                renderer.update_texture(
+                    &render_state.device,
+                    &render_state.queue,
+                    *id,
+                    image_delta,
+                );
+            }
+
+            renderer.update_buffers(
+                &render_state.device,
+                &render_state.queue,
+                &mut encoder,
+                clipped_primitives,
+                &screen_descriptor,
+            )
+        };
+
+        // Resize surface if needed
+        let is_zero_sized_surface = size_in_pixels[0] == 0 || size_in_pixels[1] == 0;
+        let frame = if is_zero_sized_surface {
+            None
+        } else {
+            if size_in_pixels[0] != self.surface_configuration.width
+                || size_in_pixels[1] != self.surface_configuration.height
+            {
+                self.surface_configuration.width = size_in_pixels[0];
+                self.surface_configuration.height = size_in_pixels[1];
+                self.surface
+                    .configure(&render_state.device, &self.surface_configuration);
+                self.depth_texture_view = self.generate_depth_texture_view(
+                    render_state,
+                    size_in_pixels[0],
+                    size_in_pixels[1],
+                );
+            }
+
+            let frame = match self.surface.get_current_texture() {
+                Ok(frame) => frame,
+                #[allow(clippy::single_match_else)]
+                Err(e) => match (*self.on_surface_error)(e) {
+                    SurfaceErrorAction::RecreateSurface => {
+                        self.surface
+                            .configure(&render_state.device, &self.surface_configuration);
+                        return Ok(());
+                    }
+                    SurfaceErrorAction::SkipFrame => {
+                        return Ok(());
+                    }
+                },
+            };
+
+            {
+                let renderer = render_state.renderer.read();
+                let frame_view = frame
+                    .texture
+                    .create_view(&wgpu::TextureViewDescriptor::default());
+                let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                        view: &frame_view,
+                        resolve_target: None,
+                        ops: wgpu::Operations {
+                            load: wgpu::LoadOp::Clear(wgpu::Color {
+                                r: clear_color[0] as f64,
+                                g: clear_color[1] as f64,
+                                b: clear_color[2] as f64,
+                                a: clear_color[3] as f64,
+                            }),
+                            store: true,
+                        },
+                    })],
+                    depth_stencil_attachment: self.depth_texture_view.as_ref().map(|view| {
+                        wgpu::RenderPassDepthStencilAttachment {
+                            view,
+                            depth_ops: Some(wgpu::Operations {
+                                load: wgpu::LoadOp::Clear(1.0),
+                                store: false,
+                            }),
+                            stencil_ops: None,
+                        }
+                    }),
+                    label: Some("egui_render"),
+                });
+
+                renderer.render(&mut render_pass, clipped_primitives, &screen_descriptor);
+            }
+
+            Some(frame)
+        };
+
+        {
+            let mut renderer = render_state.renderer.write();
+            for id in &textures_delta.free {
+                renderer.free_texture(id);
+            }
+        }
+
+        // Submit the commands: both the main buffer and user-defined ones.
+        render_state.queue.submit(
+            user_cmd_bufs
+                .into_iter()
+                .chain(std::iter::once(encoder.finish())),
+        );
+
+        if let Some(frame) = frame {
+            frame.present();
+        }
+
+        Ok(())
+    }
+
+    fn destroy(&mut self) {
+        self.render_state = None;
+    }
+}
diff --git a/egui/crates/egui-wgpu/CHANGELOG.md b/egui/crates/egui-wgpu/CHANGELOG.md
new file mode 100644
index 0000000..0a62511
--- /dev/null
+++ b/egui/crates/egui-wgpu/CHANGELOG.md
@@ -0,0 +1,40 @@
+# Changelog for egui-wgpu
+All notable changes to the `egui-wgpu` integration will be noted in this file.
+
+
+## Unreleased
+* Add `read_screen_rgba` to the egui-wgpu `Painter`, to allow for capturing the current frame when using wgpu. Used in conjunction with `Frame::request_screenshot`. ([#2676](https://github.com/emilk/egui/pull/2676))
+* Improve performance of `update_buffers` ([#2820](https://github.com/emilk/egui/pull/2820))
+* Added support for multisampling (MSAA) ([#2878](https://github.com/emilk/egui/pull/2878))
+
+
+## 0.21.0 - 2023-02-08
+* Update to `wgpu` 0.15 ([#2629](https://github.com/emilk/egui/pull/2629))
+* Return `Err` instead of panic if we can't find a device ([#2428](https://github.com/emilk/egui/pull/2428)).
+* `winit::Painter::set_window` is now `async` ([#2434](https://github.com/emilk/egui/pull/2434)).
+* `egui-wgpu` now only depends on `epaint` instead of the entire `egui` ([#2438](https://github.com/emilk/egui/pull/2438)).
+* `winit::Painter` now supports transparent backbuffer ([#2684](https://github.com/emilk/egui/pull/2684)).
+
+
+## 0.20.0 - 2022-12-08 - web support
+* Renamed `RenderPass` to `Renderer`.
+* Renamed `RenderPass::execute` to `RenderPass::render`.
+* Renamed `RenderPass::execute_with_renderpass` to `Renderer::render` (replacing existing `Renderer::render`)
+* Reexported `Renderer`.
+* You can now use `egui-wgpu` on web, using WebGL ([#2107](https://github.com/emilk/egui/pull/2107)).
+* `Renderer` no longer handles pass creation and depth buffer creation ([#2136](https://github.com/emilk/egui/pull/2136))
+* `PrepareCallback` now passes `wgpu::CommandEncoder` ([#2136](https://github.com/emilk/egui/pull/2136))
+* `PrepareCallback` can now returns `wgpu::CommandBuffer` that are bundled into a single `wgpu::Queue::submit` call ([#2230](https://github.com/emilk/egui/pull/2230))
+* Only a single vertex & index buffer is now created and resized when necessary (previously, vertex/index buffers were allocated for every mesh) ([#2148](https://github.com/emilk/egui/pull/2148)).
+* `Renderer::update_texture` no longer creates a new `wgpu::Sampler` with every new texture ([#2198](https://github.com/emilk/egui/pull/2198))
+* `Painter`'s instance/device/adapter/surface creation is now configurable via `WgpuConfiguration` ([#2207](https://github.com/emilk/egui/pull/2207))
+* Fix panic on using a depth buffer ([#2316](https://github.com/emilk/egui/pull/2316))
+
+
+## 0.19.0 - 2022-08-20
+* Enables deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634)).
+* Make `RenderPass` `Send` and `Sync` ([#1883](https://github.com/emilk/egui/pull/1883)).
+
+
+## 0.18.0 - 2022-05-15
+First published version since moving the code into the `egui` repository from <https://github.com/LU15W1R7H/eww>.
diff --git a/egui/crates/egui-wgpu/Cargo.toml b/egui/crates/egui-wgpu/Cargo.toml
new file mode 100644
index 0000000..edc5813
--- /dev/null
+++ b/egui/crates/egui-wgpu/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "egui-wgpu"
+version = "0.21.0"
+description = "Bindings for using egui natively using the wgpu library"
+authors = [
+  "Nils Hasenbanck <nils@hasenbanck.de>",
+  "embotech <opensource@embotech.com>",
+  "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
+]
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/egui-wgpu"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/egui-wgpu"
+categories = ["gui", "game-development"]
+keywords = ["wgpu", "egui", "gui", "gamedev"]
+include = [
+  "../LICENSE-APACHE",
+  "../LICENSE-MIT",
+  "**/*.rs",
+  "**/*.wgsl",
+  "Cargo.toml",
+]
+
+[package.metadata.docs.rs]
+all-features = true
+
+
+[features]
+## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
+puffin = ["dep:puffin"]
+
+## Enable [`winit`](https://docs.rs/winit) integration.
+winit = ["dep:winit"]
+
+
+[dependencies]
+epaint = { version = "0.21.0", path = "../epaint", default-features = false, features = [
+  "bytemuck",
+] }
+
+bytemuck = "1.7"
+tracing = { version = "0.1", default-features = false, features = ["std"] }
+type-map = "0.5.0"
+wgpu = "0.15.0"
+
+#! ### Optional dependencies
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+winit = { version = "0.28", optional = true }
+
+# Native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+puffin = { version = "0.14", optional = true }
diff --git a/egui/crates/egui-wgpu/README.md b/egui/crates/egui-wgpu/README.md
new file mode 100644
index 0000000..9aab315
--- /dev/null
+++ b/egui/crates/egui-wgpu/README.md
@@ -0,0 +1,10 @@
+# egui-wgpu
+
+[![Latest version](https://img.shields.io/crates/v/egui-wgpu.svg)](https://crates.io/crates/egui-wgpu)
+[![Documentation](https://docs.rs/egui-wgpu/badge.svg)](https://docs.rs/egui-wgpu)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [wgpu](https://crates.io/crates/wgpu).
+
+This was originally hosted at https://github.com/hasenbanck/egui_wgpu_backend
diff --git a/egui/crates/egui-wgpu/src/egui.wgsl b/egui/crates/egui-wgpu/src/egui.wgsl
new file mode 100644
index 0000000..552bcbb
--- /dev/null
+++ b/egui/crates/egui-wgpu/src/egui.wgsl
@@ -0,0 +1,91 @@
+// Vertex shader bindings
+
+struct VertexOutput {
+    @location(0) tex_coord: vec2<f32>,
+    @location(1) color: vec4<f32>, // gamma 0-1
+    @builtin(position) position: vec4<f32>,
+};
+
+struct Locals {
+    screen_size: vec2<f32>,
+    // Uniform buffers need to be at least 16 bytes in WebGL.
+    // See https://github.com/gfx-rs/wgpu/issues/2072
+    _padding: vec2<u32>,
+};
+@group(0) @binding(0) var<uniform> r_locals: Locals;
+
+// 0-1 linear  from  0-1 sRGB gamma
+fn linear_from_gamma_rgb(srgb: vec3<f32>) -> vec3<f32> {
+    let cutoff = srgb < vec3<f32>(0.04045);
+    let lower = srgb / vec3<f32>(12.92);
+    let higher = pow((srgb + vec3<f32>(0.055)) / vec3<f32>(1.055), vec3<f32>(2.4));
+    return select(higher, lower, cutoff);
+}
+
+// 0-1 sRGB gamma  from  0-1 linear
+fn gamma_from_linear_rgb(rgb: vec3<f32>) -> vec3<f32> {
+    let cutoff = rgb < vec3<f32>(0.0031308);
+    let lower = rgb * vec3<f32>(12.92);
+    let higher = vec3<f32>(1.055) * pow(rgb, vec3<f32>(1.0 / 2.4)) - vec3<f32>(0.055);
+    return select(higher, lower, cutoff);
+}
+
+// 0-1 sRGBA gamma  from  0-1 linear
+fn gamma_from_linear_rgba(linear_rgba: vec4<f32>) -> vec4<f32> {
+    return vec4<f32>(gamma_from_linear_rgb(linear_rgba.rgb), linear_rgba.a);
+}
+
+// [u8; 4] SRGB as u32 -> [r, g, b, a] in 0.-1
+fn unpack_color(color: u32) -> vec4<f32> {
+    return vec4<f32>(
+        f32(color & 255u),
+        f32((color >> 8u) & 255u),
+        f32((color >> 16u) & 255u),
+        f32((color >> 24u) & 255u),
+    ) / 255.0;
+}
+
+fn position_from_screen(screen_pos: vec2<f32>) -> vec4<f32> {
+    return vec4<f32>(
+        2.0 * screen_pos.x / r_locals.screen_size.x - 1.0,
+        1.0 - 2.0 * screen_pos.y / r_locals.screen_size.y,
+        0.0,
+        1.0,
+    );
+}
+
+@vertex
+fn vs_main(
+    @location(0) a_pos: vec2<f32>,
+    @location(1) a_tex_coord: vec2<f32>,
+    @location(2) a_color: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.tex_coord = a_tex_coord;
+    out.color = unpack_color(a_color);
+    out.position = position_from_screen(a_pos);
+    return out;
+}
+
+// Fragment shader bindings
+
+@group(1) @binding(0) var r_tex_color: texture_2d<f32>;
+@group(1) @binding(1) var r_tex_sampler: sampler;
+
+@fragment
+fn fs_main_linear_framebuffer(in: VertexOutput) -> @location(0) vec4<f32> {
+    // We always have an sRGB aware texture at the moment.
+    let tex_linear = textureSample(r_tex_color, r_tex_sampler, in.tex_coord);
+    let tex_gamma = gamma_from_linear_rgba(tex_linear);
+    let out_color_gamma = in.color * tex_gamma;
+    return vec4<f32>(linear_from_gamma_rgb(out_color_gamma.rgb), out_color_gamma.a);
+}
+
+@fragment
+fn fs_main_gamma_framebuffer(in: VertexOutput) -> @location(0) vec4<f32> {
+    // We always have an sRGB aware texture at the moment.
+    let tex_linear = textureSample(r_tex_color, r_tex_sampler, in.tex_coord);
+    let tex_gamma = gamma_from_linear_rgba(tex_linear);
+    let out_color_gamma = in.color * tex_gamma;
+    return out_color_gamma;
+}
diff --git a/egui/crates/egui-wgpu/src/lib.rs b/egui/crates/egui-wgpu/src/lib.rs
new file mode 100644
index 0000000..e5ba7f5
--- /dev/null
+++ b/egui/crates/egui-wgpu/src/lib.rs
@@ -0,0 +1,155 @@
+//! This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [wgpu](https://crates.io/crates/wgpu).
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(unsafe_code)]
+
+pub use wgpu;
+
+/// Low-level painting of [`egui`](https://github.com/emilk/egui) on [`wgpu`].
+pub mod renderer;
+pub use renderer::CallbackFn;
+pub use renderer::Renderer;
+
+/// Module for painting [`egui`](https://github.com/emilk/egui) with [`wgpu`] on [`winit`].
+#[cfg(feature = "winit")]
+pub mod winit;
+
+use std::sync::Arc;
+
+use epaint::mutex::RwLock;
+
+/// Access to the render state for egui.
+#[derive(Clone)]
+pub struct RenderState {
+    pub device: Arc<wgpu::Device>,
+    pub queue: Arc<wgpu::Queue>,
+    pub target_format: wgpu::TextureFormat,
+    pub renderer: Arc<RwLock<Renderer>>,
+}
+
+/// Specifies which action should be taken as consequence of a [`wgpu::SurfaceError`]
+pub enum SurfaceErrorAction {
+    /// Do nothing and skip the current frame.
+    SkipFrame,
+
+    /// Instructs egui to recreate the surface, then skip the current frame.
+    RecreateSurface,
+}
+
+/// Configuration for using wgpu with eframe or the egui-wgpu winit feature.
+#[derive(Clone)]
+pub struct WgpuConfiguration {
+    /// Configuration passed on device request.
+    pub device_descriptor: wgpu::DeviceDescriptor<'static>,
+
+    /// Backends that should be supported (wgpu will pick one of these)
+    pub backends: wgpu::Backends,
+
+    /// Present mode used for the primary surface.
+    pub present_mode: wgpu::PresentMode,
+
+    /// Power preference for the adapter.
+    pub power_preference: wgpu::PowerPreference,
+
+    /// Callback for surface errors.
+    pub on_surface_error: Arc<dyn Fn(wgpu::SurfaceError) -> SurfaceErrorAction>,
+
+    pub depth_format: Option<wgpu::TextureFormat>,
+}
+
+impl Default for WgpuConfiguration {
+    fn default() -> Self {
+        Self {
+            device_descriptor: wgpu::DeviceDescriptor {
+                label: Some("egui wgpu device"),
+                features: wgpu::Features::default(),
+                limits: wgpu::Limits::default(),
+            },
+            backends: wgpu::Backends::PRIMARY | wgpu::Backends::GL,
+            present_mode: wgpu::PresentMode::AutoVsync,
+            power_preference: wgpu::PowerPreference::HighPerformance,
+            depth_format: None,
+
+            on_surface_error: Arc::new(|err| {
+                if err == wgpu::SurfaceError::Outdated {
+                    // This error occurs when the app is minimized on Windows.
+                    // Silently return here to prevent spamming the console with:
+                    // "The underlying surface has changed, and therefore the swap chain must be updated"
+                } else {
+                    tracing::warn!("Dropped frame with error: {err}");
+                }
+                SurfaceErrorAction::SkipFrame
+            }),
+        }
+    }
+}
+
+/// Find the framebuffer format that egui prefers
+pub fn preferred_framebuffer_format(formats: &[wgpu::TextureFormat]) -> wgpu::TextureFormat {
+    for &format in formats {
+        if matches!(
+            format,
+            wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Bgra8Unorm
+        ) {
+            return format;
+        }
+    }
+    formats[0] // take the first
+}
+// maybe use this-error?
+#[derive(Debug)]
+pub enum WgpuError {
+    DeviceError(wgpu::RequestDeviceError),
+    SurfaceError(wgpu::CreateSurfaceError),
+}
+
+impl std::fmt::Display for WgpuError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self, f)
+    }
+}
+
+impl std::error::Error for WgpuError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            WgpuError::DeviceError(e) => e.source(),
+            WgpuError::SurfaceError(e) => e.source(),
+        }
+    }
+}
+
+impl From<wgpu::RequestDeviceError> for WgpuError {
+    fn from(e: wgpu::RequestDeviceError) -> Self {
+        Self::DeviceError(e)
+    }
+}
+
+impl From<wgpu::CreateSurfaceError> for WgpuError {
+    fn from(e: wgpu::CreateSurfaceError) -> Self {
+        Self::SurfaceError(e)
+    }
+}
+// ---------------------------------------------------------------------------
+
+/// Profiling macro for feature "puffin"
+macro_rules! profile_function {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        #[cfg(not(target_arch = "wasm32"))]
+        puffin::profile_function!($($arg)*);
+    };
+}
+pub(crate) use profile_function;
+
+/// Profiling macro for feature "puffin"
+macro_rules! profile_scope {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        #[cfg(not(target_arch = "wasm32"))]
+        puffin::profile_scope!($($arg)*);
+    };
+}
+pub(crate) use profile_scope;
diff --git a/egui/crates/egui-wgpu/src/renderer.rs b/egui/crates/egui-wgpu/src/renderer.rs
new file mode 100644
index 0000000..901706e
--- /dev/null
+++ b/egui/crates/egui-wgpu/src/renderer.rs
@@ -0,0 +1,979 @@
+#![allow(unsafe_code)]
+
+use std::num::NonZeroU64;
+use std::ops::Range;
+use std::{borrow::Cow, collections::HashMap, num::NonZeroU32};
+
+use type_map::concurrent::TypeMap;
+use wgpu;
+use wgpu::util::DeviceExt as _;
+
+use epaint::{emath::NumExt, PaintCallbackInfo, Primitive, Vertex};
+
+/// A callback function that can be used to compose an [`epaint::PaintCallback`] for custom WGPU
+/// rendering.
+///
+/// The callback is composed of two functions: `prepare` and `paint`:
+/// - `prepare` is called every frame before `paint`, and can use the passed-in
+///   [`wgpu::Device`] and [`wgpu::Buffer`] to allocate or modify GPU resources such as buffers.
+/// - `paint` is called after `prepare` and is given access to the [`wgpu::RenderPass`] so
+///   that it can issue draw commands into the same [`wgpu::RenderPass`] that is used for
+///   all other egui elements.
+///
+/// The final argument of both the `prepare` and `paint` callbacks is a the
+/// [`paint_callback_resources`][crate::renderer::Renderer::paint_callback_resources].
+/// `paint_callback_resources` has the same lifetime as the Egui render pass, so it can be used to
+/// store buffers, pipelines, and other information that needs to be accessed during the render
+/// pass.
+///
+/// # Example
+///
+/// See the [`custom3d_wgpu`](https://github.com/emilk/egui/blob/master/crates/egui_demo_app/src/apps/custom3d_wgpu.rs) demo source for a detailed usage example.
+pub struct CallbackFn {
+    prepare: Box<PrepareCallback>,
+    paint: Box<PaintCallback>,
+}
+
+type PrepareCallback = dyn Fn(
+        &wgpu::Device,
+        &wgpu::Queue,
+        &mut wgpu::CommandEncoder,
+        &mut TypeMap,
+    ) -> Vec<wgpu::CommandBuffer>
+    + Sync
+    + Send;
+
+type PaintCallback =
+    dyn for<'a, 'b> Fn(PaintCallbackInfo, &'a mut wgpu::RenderPass<'b>, &'b TypeMap) + Sync + Send;
+
+impl Default for CallbackFn {
+    fn default() -> Self {
+        CallbackFn {
+            prepare: Box::new(|_, _, _, _| Vec::new()),
+            paint: Box::new(|_, _, _| ()),
+        }
+    }
+}
+
+impl CallbackFn {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the prepare callback.
+    ///
+    /// The passed-in `CommandEncoder` is egui's and can be used directly to register
+    /// wgpu commands for simple use cases.
+    /// This allows reusing the same [`wgpu::CommandEncoder`] for all callbacks and egui
+    /// rendering itself.
+    ///
+    /// For more complicated use cases, one can also return a list of arbitrary
+    /// `CommandBuffer`s and have complete control over how they get created and fed.
+    /// In particular, this gives an opportunity to parallelize command registration and
+    /// prevents a faulty callback from poisoning the main wgpu pipeline.
+    ///
+    /// When using eframe, the main egui command buffer, as well as all user-defined
+    /// command buffers returned by this function, are guaranteed to all be submitted
+    /// at once in a single call.
+    pub fn prepare<F>(mut self, prepare: F) -> Self
+    where
+        F: Fn(
+                &wgpu::Device,
+                &wgpu::Queue,
+                &mut wgpu::CommandEncoder,
+                &mut TypeMap,
+            ) -> Vec<wgpu::CommandBuffer>
+            + Sync
+            + Send
+            + 'static,
+    {
+        self.prepare = Box::new(prepare) as _;
+        self
+    }
+
+    /// Set the paint callback
+    pub fn paint<F>(mut self, paint: F) -> Self
+    where
+        F: for<'a, 'b> Fn(PaintCallbackInfo, &'a mut wgpu::RenderPass<'b>, &'b TypeMap)
+            + Sync
+            + Send
+            + 'static,
+    {
+        self.paint = Box::new(paint) as _;
+        self
+    }
+}
+
+/// Information about the screen used for rendering.
+pub struct ScreenDescriptor {
+    /// Size of the window in physical pixels.
+    pub size_in_pixels: [u32; 2],
+
+    /// HiDPI scale factor (pixels per point).
+    pub pixels_per_point: f32,
+}
+
+impl ScreenDescriptor {
+    /// size in "logical" points
+    fn screen_size_in_points(&self) -> [f32; 2] {
+        [
+            self.size_in_pixels[0] as f32 / self.pixels_per_point,
+            self.size_in_pixels[1] as f32 / self.pixels_per_point,
+        ]
+    }
+}
+
+/// Uniform buffer used when rendering.
+#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+#[repr(C)]
+struct UniformBuffer {
+    screen_size_in_points: [f32; 2],
+    // Uniform buffers need to be at least 16 bytes in WebGL.
+    // See https://github.com/gfx-rs/wgpu/issues/2072
+    _padding: [u32; 2],
+}
+
+impl PartialEq for UniformBuffer {
+    fn eq(&self, other: &Self) -> bool {
+        self.screen_size_in_points == other.screen_size_in_points
+    }
+}
+
+struct SlicedBuffer {
+    buffer: wgpu::Buffer,
+    slices: Vec<Range<usize>>,
+    capacity: wgpu::BufferAddress,
+}
+
+/// Renderer for a egui based GUI.
+pub struct Renderer {
+    pipeline: wgpu::RenderPipeline,
+
+    index_buffer: SlicedBuffer,
+    vertex_buffer: SlicedBuffer,
+
+    uniform_buffer: wgpu::Buffer,
+    previous_uniform_buffer_content: UniformBuffer,
+    uniform_bind_group: wgpu::BindGroup,
+    texture_bind_group_layout: wgpu::BindGroupLayout,
+
+    /// Map of egui texture IDs to textures and their associated bindgroups (texture view +
+    /// sampler). The texture may be None if the TextureId is just a handle to a user-provided
+    /// sampler.
+    textures: HashMap<epaint::TextureId, (Option<wgpu::Texture>, wgpu::BindGroup)>,
+    next_user_texture_id: u64,
+    samplers: HashMap<epaint::textures::TextureOptions, wgpu::Sampler>,
+
+    /// Storage for use by [`epaint::PaintCallback`]'s that need to store resources such as render
+    /// pipelines that must have the lifetime of the renderpass.
+    pub paint_callback_resources: TypeMap,
+}
+
+impl Renderer {
+    /// Creates a renderer for a egui UI.
+    ///
+    /// `output_color_format` should preferably be [`wgpu::TextureFormat::Rgba8Unorm`] or
+    /// [`wgpu::TextureFormat::Bgra8Unorm`], i.e. in gamma-space.
+    pub fn new(
+        device: &wgpu::Device,
+        output_color_format: wgpu::TextureFormat,
+        output_depth_format: Option<wgpu::TextureFormat>,
+        msaa_samples: u32,
+    ) -> Self {
+        crate::profile_function!();
+
+        let shader = wgpu::ShaderModuleDescriptor {
+            label: Some("egui"),
+            source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("egui.wgsl"))),
+        };
+        let module = device.create_shader_module(shader);
+
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("egui_uniform_buffer"),
+            contents: bytemuck::cast_slice(&[UniformBuffer {
+                screen_size_in_points: [0.0, 0.0],
+                _padding: Default::default(),
+            }]),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+
+        let uniform_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("egui_uniform_bind_group_layout"),
+                entries: &[wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::VERTEX,
+                    ty: wgpu::BindingType::Buffer {
+                        has_dynamic_offset: false,
+                        min_binding_size: NonZeroU64::new(std::mem::size_of::<UniformBuffer>() as _),
+                        ty: wgpu::BufferBindingType::Uniform,
+                    },
+                    count: None,
+                }],
+            });
+
+        let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("egui_uniform_bind_group"),
+            layout: &uniform_bind_group_layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                    buffer: &uniform_buffer,
+                    offset: 0,
+                    size: None,
+                }),
+            }],
+        });
+
+        let texture_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("egui_texture_bind_group_layout"),
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                        count: None,
+                    },
+                ],
+            });
+
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("egui_pipeline_layout"),
+            bind_group_layouts: &[&uniform_bind_group_layout, &texture_bind_group_layout],
+            push_constant_ranges: &[],
+        });
+
+        let depth_stencil = output_depth_format.map(|format| wgpu::DepthStencilState {
+            format,
+            depth_write_enabled: false,
+            depth_compare: wgpu::CompareFunction::Always,
+            stencil: wgpu::StencilState::default(),
+            bias: wgpu::DepthBiasState::default(),
+        });
+
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("egui_pipeline"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                entry_point: "vs_main",
+                module: &module,
+                buffers: &[wgpu::VertexBufferLayout {
+                    array_stride: 5 * 4,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    // 0: vec2 position
+                    // 1: vec2 texture coordinates
+                    // 2: uint color
+                    attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2, 2 => Uint32],
+                }],
+            },
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                unclipped_depth: false,
+                conservative: false,
+                cull_mode: None,
+                front_face: wgpu::FrontFace::default(),
+                polygon_mode: wgpu::PolygonMode::default(),
+                strip_index_format: None,
+            },
+            depth_stencil,
+            multisample: wgpu::MultisampleState {
+                alpha_to_coverage_enabled: false,
+                count: msaa_samples,
+                mask: !0,
+            },
+
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: if output_color_format.describe().srgb {
+                    tracing::warn!("Detected a linear (sRGBA aware) framebuffer {:?}. egui prefers Rgba8Unorm or Bgra8Unorm", output_color_format);
+                    "fs_main_linear_framebuffer"
+                } else {
+                    "fs_main_gamma_framebuffer" // this is what we prefer
+                },
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: output_color_format,
+                    blend: Some(wgpu::BlendState {
+                        color: wgpu::BlendComponent {
+                            src_factor: wgpu::BlendFactor::One,
+                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                            operation: wgpu::BlendOperation::Add,
+                        },
+                        alpha: wgpu::BlendComponent {
+                            src_factor: wgpu::BlendFactor::OneMinusDstAlpha,
+                            dst_factor: wgpu::BlendFactor::One,
+                            operation: wgpu::BlendOperation::Add,
+                        },
+                    }),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview: None,
+        });
+
+        const VERTEX_BUFFER_START_CAPACITY: wgpu::BufferAddress =
+            (std::mem::size_of::<Vertex>() * 1024) as _;
+        const INDEX_BUFFER_START_CAPACITY: wgpu::BufferAddress =
+            (std::mem::size_of::<u32>() * 1024 * 3) as _;
+
+        Self {
+            pipeline,
+            vertex_buffer: SlicedBuffer {
+                buffer: create_vertex_buffer(device, VERTEX_BUFFER_START_CAPACITY),
+                slices: Vec::with_capacity(64),
+                capacity: VERTEX_BUFFER_START_CAPACITY,
+            },
+            index_buffer: SlicedBuffer {
+                buffer: create_index_buffer(device, INDEX_BUFFER_START_CAPACITY),
+                slices: Vec::with_capacity(64),
+                capacity: INDEX_BUFFER_START_CAPACITY,
+            },
+            uniform_buffer,
+            // Buffers on wgpu are zero initialized, so this is indeed its current state!
+            previous_uniform_buffer_content: UniformBuffer {
+                screen_size_in_points: [0.0, 0.0],
+                _padding: [0, 0],
+            },
+            uniform_bind_group,
+            texture_bind_group_layout,
+            textures: HashMap::new(),
+            next_user_texture_id: 0,
+            samplers: HashMap::new(),
+            paint_callback_resources: TypeMap::default(),
+        }
+    }
+
+    /// Executes the egui renderer onto an existing wgpu renderpass.
+    pub fn render<'rp>(
+        &'rp self,
+        render_pass: &mut wgpu::RenderPass<'rp>,
+        paint_jobs: &[epaint::ClippedPrimitive],
+        screen_descriptor: &ScreenDescriptor,
+    ) {
+        crate::profile_function!();
+
+        let pixels_per_point = screen_descriptor.pixels_per_point;
+        let size_in_pixels = screen_descriptor.size_in_pixels;
+
+        // Whether or not we need to reset the render pass because a paint callback has just
+        // run.
+        let mut needs_reset = true;
+
+        let mut index_buffer_slices = self.index_buffer.slices.iter();
+        let mut vertex_buffer_slices = self.vertex_buffer.slices.iter();
+
+        for epaint::ClippedPrimitive {
+            clip_rect,
+            primitive,
+        } in paint_jobs
+        {
+            if needs_reset {
+                render_pass.set_viewport(
+                    0.0,
+                    0.0,
+                    size_in_pixels[0] as f32,
+                    size_in_pixels[1] as f32,
+                    0.0,
+                    1.0,
+                );
+                render_pass.set_pipeline(&self.pipeline);
+                render_pass.set_bind_group(0, &self.uniform_bind_group, &[]);
+                needs_reset = false;
+            }
+
+            {
+                let rect = ScissorRect::new(clip_rect, pixels_per_point, size_in_pixels);
+
+                if rect.width == 0 || rect.height == 0 {
+                    // Skip rendering zero-sized clip areas.
+                    if let Primitive::Mesh(_) = primitive {
+                        // If this is a mesh, we need to advance the index and vertex buffer iterators:
+                        index_buffer_slices.next().unwrap();
+                        vertex_buffer_slices.next().unwrap();
+                    }
+                    continue;
+                }
+
+                render_pass.set_scissor_rect(rect.x, rect.y, rect.width, rect.height);
+            }
+
+            match primitive {
+                Primitive::Mesh(mesh) => {
+                    let index_buffer_slice = index_buffer_slices.next().unwrap();
+                    let vertex_buffer_slice = vertex_buffer_slices.next().unwrap();
+
+                    if let Some((_texture, bind_group)) = self.textures.get(&mesh.texture_id) {
+                        render_pass.set_bind_group(1, bind_group, &[]);
+                        render_pass.set_index_buffer(
+                            self.index_buffer.buffer.slice(
+                                index_buffer_slice.start as u64..index_buffer_slice.end as u64,
+                            ),
+                            wgpu::IndexFormat::Uint32,
+                        );
+                        render_pass.set_vertex_buffer(
+                            0,
+                            self.vertex_buffer.buffer.slice(
+                                vertex_buffer_slice.start as u64..vertex_buffer_slice.end as u64,
+                            ),
+                        );
+                        render_pass.draw_indexed(0..mesh.indices.len() as u32, 0, 0..1);
+                    } else {
+                        tracing::warn!("Missing texture: {:?}", mesh.texture_id);
+                    }
+                }
+                Primitive::Callback(callback) => {
+                    let cbfn = if let Some(c) = callback.callback.downcast_ref::<CallbackFn>() {
+                        c
+                    } else {
+                        // We already warned in the `prepare` callback
+                        continue;
+                    };
+
+                    if callback.rect.is_positive() {
+                        crate::profile_scope!("callback");
+
+                        needs_reset = true;
+
+                        {
+                            // We're setting a default viewport for the render pass as a
+                            // courtesy for the user, so that they don't have to think about
+                            // it in the simple case where they just want to fill the whole
+                            // paint area.
+                            //
+                            // The user still has the possibility of setting their own custom
+                            // viewport during the paint callback, effectively overriding this
+                            // one.
+
+                            let min = (callback.rect.min.to_vec2() * pixels_per_point).round();
+                            let max = (callback.rect.max.to_vec2() * pixels_per_point).round();
+
+                            render_pass.set_viewport(
+                                min.x,
+                                min.y,
+                                max.x - min.x,
+                                max.y - min.y,
+                                0.0,
+                                1.0,
+                            );
+                        }
+
+                        (cbfn.paint)(
+                            PaintCallbackInfo {
+                                viewport: callback.rect,
+                                clip_rect: *clip_rect,
+                                pixels_per_point,
+                                screen_size_px: size_in_pixels,
+                            },
+                            render_pass,
+                            &self.paint_callback_resources,
+                        );
+                    }
+                }
+            }
+        }
+
+        render_pass.set_scissor_rect(0, 0, size_in_pixels[0], size_in_pixels[1]);
+    }
+
+    /// Should be called before `render()`.
+    pub fn update_texture(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        id: epaint::TextureId,
+        image_delta: &epaint::ImageDelta,
+    ) {
+        crate::profile_function!();
+
+        let width = image_delta.image.width() as u32;
+        let height = image_delta.image.height() as u32;
+
+        let size = wgpu::Extent3d {
+            width,
+            height,
+            depth_or_array_layers: 1,
+        };
+
+        let data_color32 = match &image_delta.image {
+            epaint::ImageData::Color(image) => {
+                assert_eq!(
+                    width as usize * height as usize,
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+                Cow::Borrowed(&image.pixels)
+            }
+            epaint::ImageData::Font(image) => {
+                assert_eq!(
+                    width as usize * height as usize,
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+                Cow::Owned(image.srgba_pixels(None).collect::<Vec<_>>())
+            }
+        };
+        let data_bytes: &[u8] = bytemuck::cast_slice(data_color32.as_slice());
+
+        let queue_write_data_to_texture = |texture, origin| {
+            queue.write_texture(
+                wgpu::ImageCopyTexture {
+                    texture,
+                    mip_level: 0,
+                    origin,
+                    aspect: wgpu::TextureAspect::All,
+                },
+                data_bytes,
+                wgpu::ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: NonZeroU32::new(4 * width),
+                    rows_per_image: NonZeroU32::new(height),
+                },
+                size,
+            );
+        };
+
+        if let Some(pos) = image_delta.pos {
+            // update the existing texture
+            let (texture, _bind_group) = self
+                .textures
+                .get(&id)
+                .expect("Tried to update a texture that has not been allocated yet.");
+            let origin = wgpu::Origin3d {
+                x: pos[0] as u32,
+                y: pos[1] as u32,
+                z: 0,
+            };
+            queue_write_data_to_texture(
+                texture.as_ref().expect("Tried to update user texture."),
+                origin,
+            );
+        } else {
+            // allocate a new texture
+            // Use same label for all resources associated with this texture id (no point in retyping the type)
+            let label_str = format!("egui_texid_{:?}", id);
+            let label = Some(label_str.as_str());
+            let texture = device.create_texture(&wgpu::TextureDescriptor {
+                label,
+                size,
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8UnormSrgb, // Minspec for wgpu WebGL emulation is WebGL2, so this should always be supported.
+                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+                view_formats: &[wgpu::TextureFormat::Rgba8UnormSrgb],
+            });
+            let sampler = self
+                .samplers
+                .entry(image_delta.options)
+                .or_insert_with(|| create_sampler(image_delta.options, device));
+            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label,
+                layout: &self.texture_bind_group_layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(
+                            &texture.create_view(&wgpu::TextureViewDescriptor::default()),
+                        ),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::Sampler(sampler),
+                    },
+                ],
+            });
+            let origin = wgpu::Origin3d::ZERO;
+            queue_write_data_to_texture(&texture, origin);
+            self.textures.insert(id, (Some(texture), bind_group));
+        };
+    }
+
+    pub fn free_texture(&mut self, id: &epaint::TextureId) {
+        self.textures.remove(id);
+    }
+
+    /// Get the WGPU texture and bind group associated to a texture that has been allocated by egui.
+    ///
+    /// This could be used by custom paint hooks to render images that have been added through with
+    /// [`egui_extras::RetainedImage`](https://docs.rs/egui_extras/latest/egui_extras/image/struct.RetainedImage.html)
+    /// or [`epaint::Context::load_texture`](https://docs.rs/egui/latest/egui/struct.Context.html#method.load_texture).
+    pub fn texture(
+        &self,
+        id: &epaint::TextureId,
+    ) -> Option<&(Option<wgpu::Texture>, wgpu::BindGroup)> {
+        self.textures.get(id)
+    }
+
+    /// Registers a `wgpu::Texture` with a `epaint::TextureId`.
+    ///
+    /// This enables the application to reference the texture inside an image ui element.
+    /// This effectively enables off-screen rendering inside the egui UI. Texture must have
+    /// the texture format `TextureFormat::Rgba8UnormSrgb` and
+    /// Texture usage `TextureUsage::SAMPLED`.
+    pub fn register_native_texture(
+        &mut self,
+        device: &wgpu::Device,
+        texture: &wgpu::TextureView,
+        texture_filter: wgpu::FilterMode,
+    ) -> epaint::TextureId {
+        self.register_native_texture_with_sampler_options(
+            device,
+            texture,
+            wgpu::SamplerDescriptor {
+                label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
+                mag_filter: texture_filter,
+                min_filter: texture_filter,
+                ..Default::default()
+            },
+        )
+    }
+
+    /// Registers a `wgpu::Texture` with an existing `epaint::TextureId`.
+    ///
+    /// This enables applications to reuse `TextureId`s.
+    pub fn update_egui_texture_from_wgpu_texture(
+        &mut self,
+        device: &wgpu::Device,
+        texture: &wgpu::TextureView,
+        texture_filter: wgpu::FilterMode,
+        id: epaint::TextureId,
+    ) {
+        self.update_egui_texture_from_wgpu_texture_with_sampler_options(
+            device,
+            texture,
+            wgpu::SamplerDescriptor {
+                label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
+                mag_filter: texture_filter,
+                min_filter: texture_filter,
+                ..Default::default()
+            },
+            id,
+        );
+    }
+
+    /// Registers a `wgpu::Texture` with a `epaint::TextureId` while also accepting custom
+    /// `wgpu::SamplerDescriptor` options.
+    ///
+    /// This allows applications to specify individual minification/magnification filters as well as
+    /// custom mipmap and tiling options.
+    ///
+    /// The `Texture` must have the format `TextureFormat::Rgba8UnormSrgb` and usage
+    /// `TextureUsage::SAMPLED`. Any compare function supplied in the `SamplerDescriptor` will be
+    /// ignored.
+    #[allow(clippy::needless_pass_by_value)] // false positive
+    pub fn register_native_texture_with_sampler_options(
+        &mut self,
+        device: &wgpu::Device,
+        texture: &wgpu::TextureView,
+        sampler_descriptor: wgpu::SamplerDescriptor<'_>,
+    ) -> epaint::TextureId {
+        crate::profile_function!();
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            compare: None,
+            ..sampler_descriptor
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
+            layout: &self.texture_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(texture),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+            ],
+        });
+
+        let id = epaint::TextureId::User(self.next_user_texture_id);
+        self.textures.insert(id, (None, bind_group));
+        self.next_user_texture_id += 1;
+
+        id
+    }
+
+    /// Registers a `wgpu::Texture` with an existing `epaint::TextureId` while also accepting custom
+    /// `wgpu::SamplerDescriptor` options.
+    ///
+    /// This allows applications to reuse `TextureId`s created with custom sampler options.
+    #[allow(clippy::needless_pass_by_value)] // false positive
+    pub fn update_egui_texture_from_wgpu_texture_with_sampler_options(
+        &mut self,
+        device: &wgpu::Device,
+        texture: &wgpu::TextureView,
+        sampler_descriptor: wgpu::SamplerDescriptor<'_>,
+        id: epaint::TextureId,
+    ) {
+        crate::profile_function!();
+
+        let (_user_texture, user_texture_binding) = self
+            .textures
+            .get_mut(&id)
+            .expect("Tried to update a texture that has not been allocated yet.");
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            compare: None,
+            ..sampler_descriptor
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some(format!("egui_user_image_{}", self.next_user_texture_id).as_str()),
+            layout: &self.texture_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(texture),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+            ],
+        });
+
+        *user_texture_binding = bind_group;
+    }
+
+    /// Uploads the uniform, vertex and index data used by the renderer.
+    /// Should be called before `render()`.
+    ///
+    /// Returns all user-defined command buffers gathered from prepare callbacks.
+    pub fn update_buffers(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        paint_jobs: &[epaint::ClippedPrimitive],
+        screen_descriptor: &ScreenDescriptor,
+    ) -> Vec<wgpu::CommandBuffer> {
+        crate::profile_function!();
+
+        let screen_size_in_points = screen_descriptor.screen_size_in_points();
+
+        let uniform_buffer_content = UniformBuffer {
+            screen_size_in_points,
+            _padding: Default::default(),
+        };
+        if uniform_buffer_content != self.previous_uniform_buffer_content {
+            crate::profile_scope!("update uniforms");
+            queue.write_buffer(
+                &self.uniform_buffer,
+                0,
+                bytemuck::cast_slice(&[uniform_buffer_content]),
+            );
+            self.previous_uniform_buffer_content = uniform_buffer_content;
+        }
+
+        // Determine how many vertices & indices need to be rendered.
+        let (vertex_count, index_count) = {
+            crate::profile_scope!("count_vertices_indices");
+            paint_jobs.iter().fold((0, 0), |acc, clipped_primitive| {
+                match &clipped_primitive.primitive {
+                    Primitive::Mesh(mesh) => {
+                        (acc.0 + mesh.vertices.len(), acc.1 + mesh.indices.len())
+                    }
+                    Primitive::Callback(_) => acc,
+                }
+            })
+        };
+
+        if index_count > 0 {
+            crate::profile_scope!("indices");
+
+            self.index_buffer.slices.clear();
+            let required_index_buffer_size = (std::mem::size_of::<u32>() * index_count) as u64;
+            if self.index_buffer.capacity < required_index_buffer_size {
+                // Resize index buffer if needed.
+                self.index_buffer.capacity =
+                    (self.index_buffer.capacity * 2).at_least(required_index_buffer_size);
+                self.index_buffer.buffer = create_index_buffer(device, self.index_buffer.capacity);
+            }
+
+            let mut index_buffer_staging = queue
+                .write_buffer_with(
+                    &self.index_buffer.buffer,
+                    0,
+                    NonZeroU64::new(required_index_buffer_size).unwrap(),
+                )
+                .expect("Failed to create staging buffer for index data");
+            let mut index_offset = 0;
+            for epaint::ClippedPrimitive { primitive, .. } in paint_jobs.iter() {
+                match primitive {
+                    Primitive::Mesh(mesh) => {
+                        let size = mesh.indices.len() * std::mem::size_of::<u32>();
+                        let slice = index_offset..(size + index_offset);
+                        index_buffer_staging[slice.clone()]
+                            .copy_from_slice(bytemuck::cast_slice(&mesh.indices));
+                        self.index_buffer.slices.push(slice);
+                        index_offset += size;
+                    }
+                    Primitive::Callback(_) => {}
+                }
+            }
+        }
+        if vertex_count > 0 {
+            crate::profile_scope!("vertices");
+
+            self.vertex_buffer.slices.clear();
+            let required_vertex_buffer_size = (std::mem::size_of::<Vertex>() * vertex_count) as u64;
+            if self.vertex_buffer.capacity < required_vertex_buffer_size {
+                // Resize vertex buffer if needed.
+                self.vertex_buffer.capacity =
+                    (self.vertex_buffer.capacity * 2).at_least(required_vertex_buffer_size);
+                self.vertex_buffer.buffer =
+                    create_vertex_buffer(device, self.vertex_buffer.capacity);
+            }
+
+            let mut vertex_buffer_staging = queue
+                .write_buffer_with(
+                    &self.vertex_buffer.buffer,
+                    0,
+                    NonZeroU64::new(required_vertex_buffer_size).unwrap(),
+                )
+                .expect("Failed to create staging buffer for vertex data");
+            let mut vertex_offset = 0;
+            for epaint::ClippedPrimitive { primitive, .. } in paint_jobs.iter() {
+                match primitive {
+                    Primitive::Mesh(mesh) => {
+                        let size = mesh.vertices.len() * std::mem::size_of::<Vertex>();
+                        let slice = vertex_offset..(size + vertex_offset);
+                        vertex_buffer_staging[slice.clone()]
+                            .copy_from_slice(bytemuck::cast_slice(&mesh.vertices));
+                        self.vertex_buffer.slices.push(slice);
+                        vertex_offset += size;
+                    }
+                    Primitive::Callback(_) => {}
+                }
+            }
+        }
+
+        {
+            crate::profile_scope!("user command buffers");
+            let mut user_cmd_bufs = Vec::new(); // collect user command buffers
+            for epaint::ClippedPrimitive { primitive, .. } in paint_jobs.iter() {
+                match primitive {
+                    Primitive::Mesh(_) => {}
+                    Primitive::Callback(callback) => {
+                        let cbfn = if let Some(c) = callback.callback.downcast_ref::<CallbackFn>() {
+                            c
+                        } else {
+                            tracing::warn!(
+                                "Unknown paint callback: expected `egui_wgpu::CallbackFn`"
+                            );
+                            continue;
+                        };
+
+                        crate::profile_scope!("callback");
+                        user_cmd_bufs.extend((cbfn.prepare)(
+                            device,
+                            queue,
+                            encoder,
+                            &mut self.paint_callback_resources,
+                        ));
+                    }
+                }
+            }
+            user_cmd_bufs
+        }
+    }
+}
+
+fn create_sampler(
+    options: epaint::textures::TextureOptions,
+    device: &wgpu::Device,
+) -> wgpu::Sampler {
+    let mag_filter = match options.magnification {
+        epaint::textures::TextureFilter::Nearest => wgpu::FilterMode::Nearest,
+        epaint::textures::TextureFilter::Linear => wgpu::FilterMode::Linear,
+    };
+    let min_filter = match options.minification {
+        epaint::textures::TextureFilter::Nearest => wgpu::FilterMode::Nearest,
+        epaint::textures::TextureFilter::Linear => wgpu::FilterMode::Linear,
+    };
+    device.create_sampler(&wgpu::SamplerDescriptor {
+        label: Some(&format!(
+            "egui sampler (mag: {:?}, min {:?})",
+            mag_filter, min_filter
+        )),
+        mag_filter,
+        min_filter,
+        ..Default::default()
+    })
+}
+
+fn create_vertex_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
+    crate::profile_function!();
+    device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("egui_vertex_buffer"),
+        usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+        size,
+        mapped_at_creation: false,
+    })
+}
+
+fn create_index_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
+    crate::profile_function!();
+    device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("egui_index_buffer"),
+        usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
+        size,
+        mapped_at_creation: false,
+    })
+}
+
+/// A Rect in physical pixel space, used for setting clipping rectangles.
+struct ScissorRect {
+    x: u32,
+    y: u32,
+    width: u32,
+    height: u32,
+}
+
+impl ScissorRect {
+    fn new(clip_rect: &epaint::Rect, pixels_per_point: f32, target_size: [u32; 2]) -> Self {
+        // Transform clip rect to physical pixels:
+        let clip_min_x = pixels_per_point * clip_rect.min.x;
+        let clip_min_y = pixels_per_point * clip_rect.min.y;
+        let clip_max_x = pixels_per_point * clip_rect.max.x;
+        let clip_max_y = pixels_per_point * clip_rect.max.y;
+
+        // Round to integer:
+        let clip_min_x = clip_min_x.round() as u32;
+        let clip_min_y = clip_min_y.round() as u32;
+        let clip_max_x = clip_max_x.round() as u32;
+        let clip_max_y = clip_max_y.round() as u32;
+
+        // Clamp:
+        let clip_min_x = clip_min_x.clamp(0, target_size[0]);
+        let clip_min_y = clip_min_y.clamp(0, target_size[1]);
+        let clip_max_x = clip_max_x.clamp(clip_min_x, target_size[0]);
+        let clip_max_y = clip_max_y.clamp(clip_min_y, target_size[1]);
+
+        Self {
+            x: clip_min_x,
+            y: clip_min_y,
+            width: clip_max_x - clip_min_x,
+            height: clip_max_y - clip_min_y,
+        }
+    }
+}
+
+#[test]
+fn renderer_impl_send_sync() {
+    fn assert_send_sync<T: Send + Sync>() {}
+    assert_send_sync::<Renderer>();
+}
diff --git a/egui/crates/egui-wgpu/src/winit.rs b/egui/crates/egui-wgpu/src/winit.rs
new file mode 100644
index 0000000..1ec4a9b
--- /dev/null
+++ b/egui/crates/egui-wgpu/src/winit.rs
@@ -0,0 +1,630 @@
+use std::sync::Arc;
+
+use epaint::{self, mutex::RwLock};
+
+use tracing::error;
+
+use crate::{renderer, RenderState, Renderer, SurfaceErrorAction, WgpuConfiguration};
+
+struct SurfaceState {
+    surface: wgpu::Surface,
+    alpha_mode: wgpu::CompositeAlphaMode,
+    width: u32,
+    height: u32,
+}
+
+/// A texture and a buffer for reading the rendered frame back to the cpu.
+/// The texture is required since [`wgpu::TextureUsages::COPY_DST`] is not an allowed
+/// flag for the surface texture on all platforms. This means that anytime we want to
+/// capture the frame, we first render it to this texture, and then we can copy it to
+/// both the surface texture and the buffer, from where we can pull it back to the cpu.
+struct CaptureState {
+    texture: wgpu::Texture,
+    buffer: wgpu::Buffer,
+    padding: BufferPadding,
+}
+
+impl CaptureState {
+    fn new(device: &Arc<wgpu::Device>, surface_texture: &wgpu::Texture) -> Self {
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("egui_screen_capture_texture"),
+            size: surface_texture.size(),
+            mip_level_count: surface_texture.mip_level_count(),
+            sample_count: surface_texture.sample_count(),
+            dimension: surface_texture.dimension(),
+            format: surface_texture.format(),
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+
+        let padding = BufferPadding::new(surface_texture.width());
+
+        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("egui_screen_capture_buffer"),
+            size: (padding.padded_bytes_per_row * texture.height()) as u64,
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+
+        Self {
+            texture,
+            buffer,
+            padding,
+        }
+    }
+}
+
+struct BufferPadding {
+    unpadded_bytes_per_row: u32,
+    padded_bytes_per_row: u32,
+}
+
+impl BufferPadding {
+    fn new(width: u32) -> Self {
+        let bytes_per_pixel = std::mem::size_of::<u32>() as u32;
+        let unpadded_bytes_per_row = width * bytes_per_pixel;
+        let padded_bytes_per_row =
+            wgpu::util::align_to(unpadded_bytes_per_row, wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);
+        Self {
+            unpadded_bytes_per_row,
+            padded_bytes_per_row,
+        }
+    }
+}
+
+/// Everything you need to paint egui with [`wgpu`] on [`winit`].
+///
+/// Alternatively you can use [`crate::renderer`] directly.
+pub struct Painter {
+    configuration: WgpuConfiguration,
+    msaa_samples: u32,
+    support_transparent_backbuffer: bool,
+    depth_format: Option<wgpu::TextureFormat>,
+    depth_texture_view: Option<wgpu::TextureView>,
+    msaa_texture_view: Option<wgpu::TextureView>,
+    screen_capture_state: Option<CaptureState>,
+
+    instance: wgpu::Instance,
+    adapter: Option<wgpu::Adapter>,
+    render_state: Option<RenderState>,
+    surface_state: Option<SurfaceState>,
+}
+
+impl Painter {
+    /// Manages [`wgpu`] state, including surface state, required to render egui.
+    ///
+    /// Only the [`wgpu::Instance`] is initialized here. Device selection and the initialization
+    /// of render + surface state is deferred until the painter is given its first window target
+    /// via [`set_window()`](Self::set_window). (Ensuring that a device that's compatible with the
+    /// native window is chosen)
+    ///
+    /// Before calling [`paint_and_update_textures()`](Self::paint_and_update_textures) a
+    /// [`wgpu::Surface`] must be initialized (and corresponding render state) by calling
+    /// [`set_window()`](Self::set_window) once you have
+    /// a [`winit::window::Window`] with a valid `.raw_window_handle()`
+    /// associated.
+    pub fn new(
+        configuration: WgpuConfiguration,
+        msaa_samples: u32,
+        depth_bits: u8,
+        support_transparent_backbuffer: bool,
+    ) -> Self {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+            backends: configuration.backends,
+            dx12_shader_compiler: Default::default(), //
+        });
+
+        Self {
+            configuration,
+            msaa_samples,
+            support_transparent_backbuffer,
+            depth_format: (depth_bits > 0).then_some(wgpu::TextureFormat::Depth32Float),
+            depth_texture_view: None,
+            screen_capture_state: None,
+
+            instance,
+            adapter: None,
+            render_state: None,
+            surface_state: None,
+            msaa_texture_view: None,
+        }
+    }
+
+    /// Get the [`RenderState`].
+    ///
+    /// Will return [`None`] if the render state has not been initialized yet.
+    pub fn render_state(&self) -> Option<RenderState> {
+        self.render_state.clone()
+    }
+
+    async fn init_render_state(
+        &self,
+        adapter: &wgpu::Adapter,
+        target_format: wgpu::TextureFormat,
+    ) -> Result<RenderState, wgpu::RequestDeviceError> {
+        adapter
+            .request_device(&self.configuration.device_descriptor, None)
+            .await
+            .map(|(device, queue)| {
+                let renderer =
+                    Renderer::new(&device, target_format, self.depth_format, self.msaa_samples);
+                RenderState {
+                    device: Arc::new(device),
+                    queue: Arc::new(queue),
+                    target_format,
+                    renderer: Arc::new(RwLock::new(renderer)),
+                }
+            })
+    }
+
+    // We want to defer the initialization of our render state until we have a surface
+    // so we can take its format into account.
+    //
+    // After we've initialized our render state once though we expect all future surfaces
+    // will have the same format and so this render state will remain valid.
+    async fn ensure_render_state_for_surface(
+        &mut self,
+        surface: &wgpu::Surface,
+    ) -> Result<(), wgpu::RequestDeviceError> {
+        if self.adapter.is_none() {
+            self.adapter = self
+                .instance
+                .request_adapter(&wgpu::RequestAdapterOptions {
+                    power_preference: self.configuration.power_preference,
+                    compatible_surface: Some(surface),
+                    force_fallback_adapter: false,
+                })
+                .await;
+        }
+        if self.render_state.is_none() {
+            match &self.adapter {
+                Some(adapter) => {
+                    let swapchain_format = crate::preferred_framebuffer_format(
+                        &surface.get_capabilities(adapter).formats,
+                    );
+                    let rs = self.init_render_state(adapter, swapchain_format).await?;
+                    self.render_state = Some(rs);
+                }
+                None => return Err(wgpu::RequestDeviceError {}),
+            }
+        }
+        Ok(())
+    }
+
+    fn configure_surface(
+        surface_state: &SurfaceState,
+        render_state: &RenderState,
+        present_mode: wgpu::PresentMode,
+    ) {
+        surface_state.surface.configure(
+            &render_state.device,
+            &wgpu::SurfaceConfiguration {
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
+                format: render_state.target_format,
+                width: surface_state.width,
+                height: surface_state.height,
+                present_mode,
+                alpha_mode: surface_state.alpha_mode,
+                view_formats: vec![render_state.target_format],
+            },
+        );
+    }
+
+    /// Updates (or clears) the [`winit::window::Window`] associated with the [`Painter`]
+    ///
+    /// This creates a [`wgpu::Surface`] for the given Window (as well as initializing render
+    /// state if needed) that is used for egui rendering.
+    ///
+    /// This must be called before trying to render via
+    /// [`paint_and_update_textures`](Self::paint_and_update_textures)
+    ///
+    /// # Portability
+    ///
+    /// _In particular it's important to note that on Android a it's only possible to create
+    /// a window surface between `Resumed` and `Paused` lifecycle events, and Winit will panic on
+    /// attempts to query the raw window handle while paused._
+    ///
+    /// On Android [`set_window`](Self::set_window) should be called with `Some(window)` for each
+    /// `Resumed` event and `None` for each `Paused` event. Currently, on all other platforms
+    /// [`set_window`](Self::set_window) may be called with `Some(window)` as soon as you have a
+    /// valid [`winit::window::Window`].
+    ///
+    /// # Safety
+    ///
+    /// The raw Window handle associated with the given `window` must be a valid object to create a
+    /// surface upon and must remain valid for the lifetime of the created surface. (The surface may
+    /// be cleared by passing `None`).
+    ///
+    /// # Errors
+    /// If the provided wgpu configuration does not match an available device.
+    pub async unsafe fn set_window(
+        &mut self,
+        window: Option<&winit::window::Window>,
+    ) -> Result<(), crate::WgpuError> {
+        match window {
+            Some(window) => {
+                let surface = self.instance.create_surface(&window)?;
+
+                self.ensure_render_state_for_surface(&surface).await?;
+
+                let alpha_mode = if self.support_transparent_backbuffer {
+                    let supported_alpha_modes = surface
+                        .get_capabilities(self.adapter.as_ref().unwrap())
+                        .alpha_modes;
+
+                    // Prefer pre multiplied over post multiplied!
+                    if supported_alpha_modes.contains(&wgpu::CompositeAlphaMode::PreMultiplied) {
+                        wgpu::CompositeAlphaMode::PreMultiplied
+                    } else if supported_alpha_modes
+                        .contains(&wgpu::CompositeAlphaMode::PostMultiplied)
+                    {
+                        wgpu::CompositeAlphaMode::PostMultiplied
+                    } else {
+                        tracing::warn!("Transparent window was requested, but the active wgpu surface does not support a `CompositeAlphaMode` with transparency.");
+                        wgpu::CompositeAlphaMode::Auto
+                    }
+                } else {
+                    wgpu::CompositeAlphaMode::Auto
+                };
+
+                let size = window.inner_size();
+                self.surface_state = Some(SurfaceState {
+                    surface,
+                    width: size.width,
+                    height: size.height,
+                    alpha_mode,
+                });
+                self.resize_and_generate_depth_texture_view_and_msaa_view(size.width, size.height);
+            }
+            None => {
+                self.surface_state = None;
+            }
+        }
+        Ok(())
+    }
+
+    /// Returns the maximum texture dimension supported if known
+    ///
+    /// This API will only return a known dimension after `set_window()` has been called
+    /// at least once, since the underlying device and render state are initialized lazily
+    /// once we have a window (that may determine the choice of adapter/device).
+    pub fn max_texture_side(&self) -> Option<usize> {
+        self.render_state
+            .as_ref()
+            .map(|rs| rs.device.limits().max_texture_dimension_2d as usize)
+    }
+
+    fn resize_and_generate_depth_texture_view_and_msaa_view(
+        &mut self,
+        width_in_pixels: u32,
+        height_in_pixels: u32,
+    ) {
+        let render_state = self.render_state.as_ref().unwrap();
+        let surface_state = self.surface_state.as_mut().unwrap();
+
+        surface_state.width = width_in_pixels;
+        surface_state.height = height_in_pixels;
+
+        Self::configure_surface(surface_state, render_state, self.configuration.present_mode);
+
+        self.depth_texture_view = self.depth_format.map(|depth_format| {
+            render_state
+                .device
+                .create_texture(&wgpu::TextureDescriptor {
+                    label: Some("egui_depth_texture"),
+                    size: wgpu::Extent3d {
+                        width: width_in_pixels,
+                        height: height_in_pixels,
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: depth_format,
+                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                        | wgpu::TextureUsages::TEXTURE_BINDING,
+                    view_formats: &[depth_format],
+                })
+                .create_view(&wgpu::TextureViewDescriptor::default())
+        });
+
+        self.msaa_texture_view = (self.msaa_samples > 1)
+            .then_some(self.render_state.as_ref())
+            .flatten()
+            .map(|render_state| {
+                let texture_format = render_state.target_format;
+                render_state
+                    .device
+                    .create_texture(&wgpu::TextureDescriptor {
+                        label: Some("egui_msaa_texture"),
+                        size: wgpu::Extent3d {
+                            width: width_in_pixels,
+                            height: height_in_pixels,
+                            depth_or_array_layers: 1,
+                        },
+                        mip_level_count: 1,
+                        sample_count: self.msaa_samples,
+                        dimension: wgpu::TextureDimension::D2,
+                        format: texture_format,
+                        usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                        view_formats: &[texture_format],
+                    })
+                    .create_view(&wgpu::TextureViewDescriptor::default())
+            });
+    }
+
+    pub fn on_window_resized(&mut self, width_in_pixels: u32, height_in_pixels: u32) {
+        if self.surface_state.is_some() {
+            self.resize_and_generate_depth_texture_view_and_msaa_view(
+                width_in_pixels,
+                height_in_pixels,
+            );
+        } else {
+            error!("Ignoring window resize notification with no surface created via Painter::set_window()");
+        }
+    }
+
+    // CaptureState only needs to be updated when the size of the two textures don't match and we want to
+    // capture a frame
+    fn update_capture_state(
+        screen_capture_state: &mut Option<CaptureState>,
+        surface_texture: &wgpu::SurfaceTexture,
+        render_state: &RenderState,
+    ) {
+        let surface_texture = &surface_texture.texture;
+        match screen_capture_state {
+            Some(capture_state) => {
+                if capture_state.texture.size() != surface_texture.size() {
+                    *capture_state = CaptureState::new(&render_state.device, surface_texture);
+                }
+            }
+            None => {
+                *screen_capture_state =
+                    Some(CaptureState::new(&render_state.device, surface_texture));
+            }
+        }
+    }
+
+    // Handles copying from the CaptureState texture to the surface texture and the cpu
+    fn read_screen_rgba(
+        screen_capture_state: &CaptureState,
+        render_state: &RenderState,
+        output_frame: &wgpu::SurfaceTexture,
+    ) -> Option<epaint::ColorImage> {
+        let CaptureState {
+            texture: tex,
+            buffer,
+            padding,
+        } = screen_capture_state;
+
+        let device = &render_state.device;
+        let queue = &render_state.queue;
+
+        let tex_extent = tex.size();
+
+        let mut encoder = device.create_command_encoder(&Default::default());
+        encoder.copy_texture_to_buffer(
+            tex.as_image_copy(),
+            wgpu::ImageCopyBuffer {
+                buffer,
+                layout: wgpu::ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: Some(std::num::NonZeroU32::new(padding.padded_bytes_per_row)?),
+                    rows_per_image: None,
+                },
+            },
+            tex_extent,
+        );
+
+        encoder.copy_texture_to_texture(
+            tex.as_image_copy(),
+            output_frame.texture.as_image_copy(),
+            tex.size(),
+        );
+
+        let id = queue.submit(Some(encoder.finish()));
+        let buffer_slice = buffer.slice(..);
+        let (sender, receiver) = std::sync::mpsc::channel();
+        buffer_slice.map_async(wgpu::MapMode::Read, move |v| {
+            drop(sender.send(v));
+        });
+        device.poll(wgpu::Maintain::WaitForSubmissionIndex(id));
+        receiver.recv().ok()?.ok()?;
+
+        let to_rgba = match tex.format() {
+            wgpu::TextureFormat::Rgba8Unorm => [0, 1, 2, 3],
+            wgpu::TextureFormat::Bgra8Unorm => [2, 1, 0, 3],
+            _ => {
+                tracing::error!("Screen can't be captured unless the surface format is Rgba8Unorm or Bgra8Unorm. Current surface format is {:?}", tex.format());
+                return None;
+            }
+        };
+
+        let mut pixels = Vec::with_capacity((tex.width() * tex.height()) as usize);
+        for padded_row in buffer_slice
+            .get_mapped_range()
+            .chunks(padding.padded_bytes_per_row as usize)
+        {
+            let row = &padded_row[..padding.unpadded_bytes_per_row as usize];
+            for color in row.chunks(4) {
+                pixels.push(epaint::Color32::from_rgba_premultiplied(
+                    color[to_rgba[0]],
+                    color[to_rgba[1]],
+                    color[to_rgba[2]],
+                    color[to_rgba[3]],
+                ));
+            }
+        }
+        buffer.unmap();
+
+        Some(epaint::ColorImage {
+            size: [tex.width() as usize, tex.height() as usize],
+            pixels,
+        })
+    }
+
+    // Returns a vector with the frame's pixel data if it was requested.
+    pub fn paint_and_update_textures(
+        &mut self,
+        pixels_per_point: f32,
+        clear_color: [f32; 4],
+        clipped_primitives: &[epaint::ClippedPrimitive],
+        textures_delta: &epaint::textures::TexturesDelta,
+        capture: bool,
+    ) -> Option<epaint::ColorImage> {
+        crate::profile_function!();
+
+        let render_state = self.render_state.as_mut()?;
+        let surface_state = self.surface_state.as_ref()?;
+
+        let output_frame = {
+            crate::profile_scope!("get_current_texture");
+            // This is what vsync-waiting happens, at least on Mac.
+            surface_state.surface.get_current_texture()
+        };
+
+        let output_frame = match output_frame {
+            Ok(frame) => frame,
+            #[allow(clippy::single_match_else)]
+            Err(e) => match (*self.configuration.on_surface_error)(e) {
+                SurfaceErrorAction::RecreateSurface => {
+                    Self::configure_surface(
+                        surface_state,
+                        render_state,
+                        self.configuration.present_mode,
+                    );
+                    return None;
+                }
+                SurfaceErrorAction::SkipFrame => {
+                    return None;
+                }
+            },
+        };
+
+        let mut encoder =
+            render_state
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                    label: Some("encoder"),
+                });
+
+        // Upload all resources for the GPU.
+        let screen_descriptor = renderer::ScreenDescriptor {
+            size_in_pixels: [surface_state.width, surface_state.height],
+            pixels_per_point,
+        };
+
+        let user_cmd_bufs = {
+            let mut renderer = render_state.renderer.write();
+            for (id, image_delta) in &textures_delta.set {
+                renderer.update_texture(
+                    &render_state.device,
+                    &render_state.queue,
+                    *id,
+                    image_delta,
+                );
+            }
+
+            renderer.update_buffers(
+                &render_state.device,
+                &render_state.queue,
+                &mut encoder,
+                clipped_primitives,
+                &screen_descriptor,
+            )
+        };
+
+        {
+            let renderer = render_state.renderer.read();
+            let frame_view = if capture {
+                Self::update_capture_state(
+                    &mut self.screen_capture_state,
+                    &output_frame,
+                    render_state,
+                );
+                self.screen_capture_state
+                    .as_ref()?
+                    .texture
+                    .create_view(&wgpu::TextureViewDescriptor::default())
+            } else {
+                output_frame
+                    .texture
+                    .create_view(&wgpu::TextureViewDescriptor::default())
+            };
+
+            let (view, resolve_target) = (self.msaa_samples > 1)
+                .then_some(self.msaa_texture_view.as_ref())
+                .flatten()
+                .map_or((&frame_view, None), |texture_view| {
+                    (texture_view, Some(&frame_view))
+                });
+
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view,
+                    resolve_target,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color {
+                            r: clear_color[0] as f64,
+                            g: clear_color[1] as f64,
+                            b: clear_color[2] as f64,
+                            a: clear_color[3] as f64,
+                        }),
+                        store: true,
+                    },
+                })],
+                depth_stencil_attachment: self.depth_texture_view.as_ref().map(|view| {
+                    wgpu::RenderPassDepthStencilAttachment {
+                        view,
+                        depth_ops: Some(wgpu::Operations {
+                            load: wgpu::LoadOp::Clear(1.0),
+                            store: true,
+                        }),
+                        stencil_ops: None,
+                    }
+                }),
+                label: Some("egui_render"),
+            });
+
+            renderer.render(&mut render_pass, clipped_primitives, &screen_descriptor);
+        }
+
+        {
+            let mut renderer = render_state.renderer.write();
+            for id in &textures_delta.free {
+                renderer.free_texture(id);
+            }
+        }
+
+        let encoded = {
+            crate::profile_scope!("CommandEncoder::finish");
+            encoder.finish()
+        };
+
+        // Submit the commands: both the main buffer and user-defined ones.
+        {
+            crate::profile_scope!("Queue::submit");
+            render_state
+                .queue
+                .submit(user_cmd_bufs.into_iter().chain(std::iter::once(encoded)));
+        };
+
+        let screenshot = if capture {
+            let screen_capture_state = self.screen_capture_state.as_ref()?;
+            Self::read_screen_rgba(screen_capture_state, render_state, &output_frame)
+        } else {
+            None
+        };
+        // Redraw egui
+        {
+            crate::profile_scope!("present");
+            output_frame.present();
+        }
+        screenshot
+    }
+
+    #[allow(clippy::unused_self)]
+    pub fn destroy(&mut self) {
+        // TODO(emilk): something here?
+    }
+}
diff --git a/egui/crates/egui-winit/CHANGELOG.md b/egui/crates/egui-winit/CHANGELOG.md
new file mode 100644
index 0000000..f7b011f
--- /dev/null
+++ b/egui/crates/egui-winit/CHANGELOG.md
@@ -0,0 +1,64 @@
+# Changelog for egui-winit
+All notable changes to the `egui-winit` integration will be noted in this file.
+
+
+## Unreleased
+* Fix unsafe API: remove `State::new_with_wayland_display`; change `Clipboard::new` to take `&EventLoopWindowTarget<T>`.
+
+## 0.21.1 - 2023-02-12
+* Fixed crash when window position is in an invalid state, which could happen e.g. due to changes in monitor size or DPI ([#2722](https://github.com/emilk/egui/issues/2722)).
+
+
+## 0.21.0 - 2023-02-08
+* Fixed persistence of native window position on Windows OS ([#2583](https://github.com/emilk/egui/issues/2583)).
+* Update to `winit` 0.28, adding support for mac trackpad zoom ([#2654](https://github.com/emilk/egui/pull/2654)).
+* Remove the `screen_reader` feature. Use the `accesskit` feature flag instead ([#2669](https://github.com/emilk/egui/pull/2669)).
+* Fix bug where the cursor could get stuck using the wrong icon.
+
+
+## 0.20.1 - 2022-12-11
+* Fix [docs.rs](https://docs.rs/egui-winit) build ([#2420](https://github.com/emilk/egui/pull/2420)).
+
+
+## 0.20.0 - 2022-12-08
+* The default features of the `winit` crate are not enabled if the default features of `egui-winit` are disabled too ([#1971](https://github.com/emilk/egui/pull/1971)).
+* Added new feature `wayland` which enables Wayland support ([#1971](https://github.com/emilk/egui/pull/1971)).
+* Don't repaint when just moving window ([#1980](https://github.com/emilk/egui/pull/1980)).
+* Added optional integration with [AccessKit](https://accesskit.dev/) for implementing platform accessibility APIs ([#2294](https://github.com/emilk/egui/pull/2294)).
+
+## 0.19.0 - 2022-08-20
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* Fixed clipboard on Wayland ([#1613](https://github.com/emilk/egui/pull/1613)).
+* Allow deferred render + surface state initialization for Android ([#1634](https://github.com/emilk/egui/pull/1634)).
+* Fixed window position persistence ([#1745](https://github.com/emilk/egui/pull/1745)).
+* Fixed mouse cursor change on Linux ([#1747](https://github.com/emilk/egui/pull/1747)).
+* Use the new `RawInput::has_focus` field to indicate whether the window has the keyboard focus ([#1859](https://github.com/emilk/egui/pull/1859)).
+
+
+## 0.18.0 - 2022-04-30
+* Reexport `egui` crate
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Added new feature `puffin` to add [`puffin profiler`](https://github.com/EmbarkStudios/puffin) scopes ([#1483](https://github.com/emilk/egui/pull/1483)).
+* Renamed the feature `convert_bytemuck` to `bytemuck` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Renamed the feature `serialize` to `serde` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Removed the features `dark-light` and `persistence` ([#1542](https://github.com/emilk/egui/pull/1542)).
+
+
+## 0.17.0 - 2022-02-22
+* Fixed horizontal scrolling direction on Linux.
+* Replaced `std::time::Instant` with `instant::Instant` for WebAssembly compatibility ([#1023](https://github.com/emilk/egui/pull/1023))
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+* Fixed `enable_drag` on Windows OS ([#1108](https://github.com/emilk/egui/pull/1108)).
+* Shift-scroll will now result in horizontal scrolling on all platforms ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Require knowledge about max texture side (e.g. `GL_MAX_TEXTURE_SIZE`)) ([#1154](https://github.com/emilk/egui/pull/1154)).
+
+
+## 0.16.0 - 2021-12-29
+* Added helper `EpiIntegration` ([#871](https://github.com/emilk/egui/pull/871)).
+* Fixed shift key getting stuck enabled with the X11 option `shift:both_capslock` enabled ([#849](https://github.com/emilk/egui/pull/849)).
+* Removed `State::is_quit_event` and `State::is_quit_shortcut` ([#881](https://github.com/emilk/egui/pull/881)).
+* Updated `winit` to 0.26 ([#930](https://github.com/emilk/egui/pull/930)).
+
+
+## 0.15.0 - 2021-10-24
+First stand-alone release. Previously part of `egui_glium`.
diff --git a/egui/crates/egui-winit/Cargo.toml b/egui/crates/egui-winit/Cargo.toml
new file mode 100644
index 0000000..bd576eb
--- /dev/null
+++ b/egui/crates/egui-winit/Cargo.toml
@@ -0,0 +1,88 @@
+[package]
+name = "egui-winit"
+version = "0.21.1"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "Bindings for using egui with winit"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/egui-winit"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/egui-winit"
+categories = ["gui", "game-development"]
+keywords = ["winit", "egui", "gui", "gamedev"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+
+[features]
+default = ["clipboard", "links", "wayland", "winit/default"]
+
+## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
+accesskit = ["accesskit_winit", "egui/accesskit"]
+
+## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast [`egui::epaint::Vertex`], [`egui::Vec2`] etc to `&[u8]`.
+bytemuck = ["egui/bytemuck"]
+
+## Enable cut/copy/paste to OS clipboard.
+## If disabled a clipboard will be simulated so you can still copy/paste within the egui app.
+clipboard = ["arboard", "smithay-clipboard"]
+
+## Enable opening links in a browser when an egui hyperlink is clicked.
+links = ["webbrowser"]
+
+## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
+puffin = ["dep:puffin"]
+
+## Allow serialization of [`WindowSettings`] using [`serde`](https://docs.rs/serde).
+serde = ["egui/serde", "dep:serde"]
+
+## Enables Wayland support.
+wayland = ["winit/wayland"]
+
+# Allow crates to choose an android-activity backend via Winit
+# - It's important that most applications should not have to depend on android-activity directly, and can
+#   rely on Winit to pull in a suitable version (unlike most Rust crates, any version conflicts won't link)
+# - It's also important that we don't impose an android-activity backend by taking this choice away from applications.
+
+## Enable the `native-activity` backend via Winit on Android
+android-native-activity = [ "winit/android-native-activity" ]
+## Enable the `game-activity` backend via Winit on Android
+android-game-activity = [ "winit/android-game-activity" ]
+
+[dependencies]
+egui = { version = "0.21.0", path = "../egui", default-features = false, features = [
+  "tracing",
+] }
+tracing = { version = "0.1", default-features = false, features = ["std"] }
+winit = { version = "0.28", default-features = false }
+
+#! ### Optional dependencies
+
+# feature accesskit
+accesskit_winit = { version = "0.12.0", optional = true }
+
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+puffin = { version = "0.14", optional = true }
+serde = { version = "1.0", optional = true, features = ["derive"] }
+
+webbrowser = { version = "0.8.3", optional = true }
+
+[target.'cfg(not(target_arch="wasm32"))'.dependencies]
+instant = { version = "0.1" }
+
+[target.'cfg(target_arch="wasm32")'.dependencies]
+instant = { version = "0.1", features = [
+  "wasm-bindgen",
+] } # We use instant so we can (maybe) compile for web
+
+[target.'cfg(any(target_os="linux", target_os="dragonfly", target_os="freebsd", target_os="netbsd", target_os="openbsd"))'.dependencies]
+smithay-clipboard = { version = "0.6.3", optional = true }
+
+[target.'cfg(not(target_os = "android"))'.dependencies]
+arboard = { version = "3.2", optional = true, default-features = false }
+
diff --git a/egui/crates/egui-winit/README.md b/egui/crates/egui-winit/README.md
new file mode 100644
index 0000000..2386416
--- /dev/null
+++ b/egui/crates/egui-winit/README.md
@@ -0,0 +1,10 @@
+# egui-winit
+
+[![Latest version](https://img.shields.io/crates/v/egui-winit.svg)](https://crates.io/crates/egui-winit)
+[![Documentation](https://docs.rs/egui-winit/badge.svg)](https://docs.rs/egui-winit)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [`winit`](https://crates.io/crates/winit).
+
+The library translates winit events to egui, handled copy/paste, updates the cursor, open links clicked in egui, etc.
diff --git a/egui/crates/egui-winit/src/clipboard.rs b/egui/crates/egui-winit/src/clipboard.rs
new file mode 100644
index 0000000..7556317
--- /dev/null
+++ b/egui/crates/egui-winit/src/clipboard.rs
@@ -0,0 +1,163 @@
+use winit::event_loop::EventLoopWindowTarget;
+
+/// Handles interfacing with the OS clipboard.
+///
+/// If the "clipboard" feature is off, or we cannot connect to the OS clipboard,
+/// then a fallback clipboard that just works works within the same app is used instead.
+pub struct Clipboard {
+    #[cfg(all(feature = "arboard", not(target_os = "android")))]
+    arboard: Option<arboard::Clipboard>,
+
+    #[cfg(all(
+        any(
+            target_os = "linux",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "openbsd"
+        ),
+        feature = "smithay-clipboard"
+    ))]
+    smithay: Option<smithay_clipboard::Clipboard>,
+
+    /// Fallback manual clipboard.
+    clipboard: String,
+}
+
+impl Clipboard {
+    /// Construct a new instance
+    ///
+    /// # Safety
+    ///
+    /// The returned `Clipboard` must not outlive the input `_event_loop`.
+    pub fn new<T>(_event_loop: &EventLoopWindowTarget<T>) -> Self {
+        Self {
+            #[cfg(all(feature = "arboard", not(target_os = "android")))]
+            arboard: init_arboard(),
+
+            #[cfg(all(
+                any(
+                    target_os = "linux",
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "netbsd",
+                    target_os = "openbsd"
+                ),
+                feature = "smithay-clipboard"
+            ))]
+            smithay: init_smithay_clipboard(_event_loop),
+
+            clipboard: Default::default(),
+        }
+    }
+
+    pub fn get(&mut self) -> Option<String> {
+        #[cfg(all(
+            any(
+                target_os = "linux",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            ),
+            feature = "smithay-clipboard"
+        ))]
+        if let Some(clipboard) = &mut self.smithay {
+            return match clipboard.load() {
+                Ok(text) => Some(text),
+                Err(err) => {
+                    tracing::error!("smithay paste error: {err}");
+                    None
+                }
+            };
+        }
+
+        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        if let Some(clipboard) = &mut self.arboard {
+            return match clipboard.get_text() {
+                Ok(text) => Some(text),
+                Err(err) => {
+                    tracing::error!("arboard paste error: {err}");
+                    None
+                }
+            };
+        }
+
+        Some(self.clipboard.clone())
+    }
+
+    pub fn set(&mut self, text: String) {
+        #[cfg(all(
+            any(
+                target_os = "linux",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            ),
+            feature = "smithay-clipboard"
+        ))]
+        if let Some(clipboard) = &mut self.smithay {
+            clipboard.store(text);
+            return;
+        }
+
+        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        if let Some(clipboard) = &mut self.arboard {
+            if let Err(err) = clipboard.set_text(text) {
+                tracing::error!("arboard copy/cut error: {err}");
+            }
+            return;
+        }
+
+        self.clipboard = text;
+    }
+}
+
+#[cfg(all(feature = "arboard", not(target_os = "android")))]
+fn init_arboard() -> Option<arboard::Clipboard> {
+    tracing::debug!("Initializing arboard clipboard…");
+    match arboard::Clipboard::new() {
+        Ok(clipboard) => Some(clipboard),
+        Err(err) => {
+            tracing::warn!("Failed to initialize arboard clipboard: {err}");
+            None
+        }
+    }
+}
+
+#[cfg(all(
+    any(
+        target_os = "linux",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    feature = "smithay-clipboard"
+))]
+fn init_smithay_clipboard<T>(
+    _event_loop: &EventLoopWindowTarget<T>,
+) -> Option<smithay_clipboard::Clipboard> {
+    // Note: ideally "smithay-clipboard" would imply "wayland", but it doesn't.
+    #[cfg(feature = "wayland")]
+    {
+        use winit::platform::wayland::EventLoopWindowTargetExtWayland as _;
+        if let Some(display) = _event_loop.wayland_display() {
+            tracing::debug!("Initializing smithay clipboard…");
+            #[allow(unsafe_code)]
+            Some(unsafe { smithay_clipboard::Clipboard::new(display) })
+        } else {
+            tracing::debug!("Cannot initialize smithay clipboard without a display handle");
+            None
+        }
+    }
+
+    #[cfg(not(feature = "wayland"))]
+    {
+        tracing::debug!(
+            "You need to enable the 'wayland' feature of 'egui-winit' to get a working clipboard"
+        );
+        None
+    }
+}
diff --git a/egui/crates/egui-winit/src/lib.rs b/egui/crates/egui-winit/src/lib.rs
new file mode 100644
index 0000000..3ed9496
--- /dev/null
+++ b/egui/crates/egui-winit/src/lib.rs
@@ -0,0 +1,917 @@
+//! [`egui`] bindings for [`winit`](https://github.com/rust-windowing/winit).
+//!
+//! The library translates winit events to egui, handled copy/paste,
+//! updates the cursor, open links clicked in egui, etc.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::manual_range_contains)]
+
+#[cfg(feature = "accesskit")]
+pub use accesskit_winit;
+pub use egui;
+#[cfg(feature = "accesskit")]
+use egui::accesskit;
+pub use winit;
+
+pub mod clipboard;
+mod window_settings;
+
+pub use window_settings::WindowSettings;
+
+use winit::event_loop::EventLoopWindowTarget;
+
+pub fn native_pixels_per_point(window: &winit::window::Window) -> f32 {
+    window.scale_factor() as f32
+}
+
+pub fn screen_size_in_pixels(window: &winit::window::Window) -> egui::Vec2 {
+    let size = window.inner_size();
+    egui::vec2(size.width as f32, size.height as f32)
+}
+
+// ----------------------------------------------------------------------------
+
+#[must_use]
+pub struct EventResponse {
+    /// If true, egui consumed this event, i.e. wants exclusive use of this event
+    /// (e.g. a mouse click on an egui window, or entering text into a text field).
+    ///
+    /// For instance, if you use egui for a game, you should only
+    /// pass on the events to your game when [`Self::consumed`] is `false.
+    ///
+    /// Note that egui uses `tab` to move focus between elements, so this will always be `true` for tabs.
+    pub consumed: bool,
+
+    /// Do we need an egui refresh because of this event?
+    pub repaint: bool,
+}
+
+// ----------------------------------------------------------------------------
+
+/// Handles the integration between egui and winit.
+pub struct State {
+    start_time: instant::Instant,
+    egui_input: egui::RawInput,
+    pointer_pos_in_points: Option<egui::Pos2>,
+    any_pointer_button_down: bool,
+    current_cursor_icon: Option<egui::CursorIcon>,
+
+    /// What egui uses.
+    current_pixels_per_point: f32,
+
+    clipboard: clipboard::Clipboard,
+
+    /// If `true`, mouse inputs will be treated as touches.
+    /// Useful for debugging touch support in egui.
+    ///
+    /// Creates duplicate touches, if real touch inputs are coming.
+    simulate_touch_screen: bool,
+
+    /// Is Some(…) when a touch is being translated to a pointer.
+    ///
+    /// Only one touch will be interpreted as pointer at any time.
+    pointer_touch_id: Option<u64>,
+
+    /// track ime state
+    input_method_editor_started: bool,
+
+    #[cfg(feature = "accesskit")]
+    accesskit: Option<accesskit_winit::Adapter>,
+}
+
+impl State {
+    /// Construct a new instance
+    ///
+    /// # Safety
+    ///
+    /// The returned `State` must not outlive the input `_event_loop`.
+    pub fn new<T>(event_loop: &EventLoopWindowTarget<T>) -> Self {
+        let egui_input = egui::RawInput {
+            has_focus: false, // winit will tell us when we have focus
+            ..Default::default()
+        };
+
+        Self {
+            start_time: instant::Instant::now(),
+            egui_input,
+            pointer_pos_in_points: None,
+            any_pointer_button_down: false,
+            current_cursor_icon: None,
+            current_pixels_per_point: 1.0,
+
+            clipboard: clipboard::Clipboard::new(event_loop),
+
+            simulate_touch_screen: false,
+            pointer_touch_id: None,
+
+            input_method_editor_started: false,
+
+            #[cfg(feature = "accesskit")]
+            accesskit: None,
+        }
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub fn init_accesskit<T: From<accesskit_winit::ActionRequestEvent> + Send>(
+        &mut self,
+        window: &winit::window::Window,
+        event_loop_proxy: winit::event_loop::EventLoopProxy<T>,
+        initial_tree_update_factory: impl 'static + FnOnce() -> accesskit::TreeUpdate + Send,
+    ) {
+        self.accesskit = Some(accesskit_winit::Adapter::new(
+            window,
+            initial_tree_update_factory,
+            event_loop_proxy,
+        ));
+    }
+
+    /// Call this once a graphics context has been created to update the maximum texture dimensions
+    /// that egui will use.
+    pub fn set_max_texture_side(&mut self, max_texture_side: usize) {
+        self.egui_input.max_texture_side = Some(max_texture_side);
+    }
+
+    /// Call this when a new native Window is created for rendering to initialize the `pixels_per_point`
+    /// for that window.
+    ///
+    /// In particular, on Android it is necessary to call this after each `Resumed` lifecycle
+    /// event, each time a new native window is created.
+    ///
+    /// Once this has been initialized for a new window then this state will be maintained by handling
+    /// [`winit::event::WindowEvent::ScaleFactorChanged`] events.
+    pub fn set_pixels_per_point(&mut self, pixels_per_point: f32) {
+        self.egui_input.pixels_per_point = Some(pixels_per_point);
+        self.current_pixels_per_point = pixels_per_point;
+    }
+
+    /// The number of physical pixels per logical point,
+    /// as configured on the current egui context (see [`egui::Context::pixels_per_point`]).
+    #[inline]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.current_pixels_per_point
+    }
+
+    /// The current input state.
+    /// This is changed by [`Self::on_event`] and cleared by [`Self::take_egui_input`].
+    #[inline]
+    pub fn egui_input(&self) -> &egui::RawInput {
+        &self.egui_input
+    }
+
+    /// Prepare for a new frame by extracting the accumulated input,
+    /// as well as setting [the time](egui::RawInput::time) and [screen rectangle](egui::RawInput::screen_rect).
+    pub fn take_egui_input(&mut self, window: &winit::window::Window) -> egui::RawInput {
+        let pixels_per_point = self.pixels_per_point();
+
+        self.egui_input.time = Some(self.start_time.elapsed().as_secs_f64());
+
+        // On Windows, a minimized window will have 0 width and height.
+        // See: https://github.com/rust-windowing/winit/issues/208
+        // This solves an issue where egui window positions would be changed when minimizing on Windows.
+        let screen_size_in_pixels = screen_size_in_pixels(window);
+        let screen_size_in_points = screen_size_in_pixels / pixels_per_point;
+        self.egui_input.screen_rect =
+            if screen_size_in_points.x > 0.0 && screen_size_in_points.y > 0.0 {
+                Some(egui::Rect::from_min_size(
+                    egui::Pos2::ZERO,
+                    screen_size_in_points,
+                ))
+            } else {
+                None
+            };
+
+        self.egui_input.take()
+    }
+
+    /// Call this when there is a new event.
+    ///
+    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
+    pub fn on_event(
+        &mut self,
+        egui_ctx: &egui::Context,
+        event: &winit::event::WindowEvent<'_>,
+    ) -> EventResponse {
+        use winit::event::WindowEvent;
+        match event {
+            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
+                let pixels_per_point = *scale_factor as f32;
+                self.egui_input.pixels_per_point = Some(pixels_per_point);
+                self.current_pixels_per_point = pixels_per_point;
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::MouseInput { state, button, .. } => {
+                self.on_mouse_button_input(*state, *button);
+                EventResponse {
+                    repaint: true,
+                    consumed: egui_ctx.wants_pointer_input(),
+                }
+            }
+            WindowEvent::MouseWheel { delta, .. } => {
+                self.on_mouse_wheel(*delta);
+                EventResponse {
+                    repaint: true,
+                    consumed: egui_ctx.wants_pointer_input(),
+                }
+            }
+            WindowEvent::CursorMoved { position, .. } => {
+                self.on_cursor_moved(*position);
+                EventResponse {
+                    repaint: true,
+                    consumed: egui_ctx.is_using_pointer(),
+                }
+            }
+            WindowEvent::CursorLeft { .. } => {
+                self.pointer_pos_in_points = None;
+                self.egui_input.events.push(egui::Event::PointerGone);
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            // WindowEvent::TouchpadPressure {device_id, pressure, stage, ..  } => {} // TODO
+            WindowEvent::Touch(touch) => {
+                self.on_touch(touch);
+                let consumed = match touch.phase {
+                    winit::event::TouchPhase::Started
+                    | winit::event::TouchPhase::Ended
+                    | winit::event::TouchPhase::Cancelled => egui_ctx.wants_pointer_input(),
+                    winit::event::TouchPhase::Moved => egui_ctx.is_using_pointer(),
+                };
+                EventResponse {
+                    repaint: true,
+                    consumed,
+                }
+            }
+            WindowEvent::ReceivedCharacter(ch) => {
+                // On Mac we get here when the user presses Cmd-C (copy), ctrl-W, etc.
+                // We need to ignore these characters that are side-effects of commands.
+                let is_mac_cmd = cfg!(target_os = "macos")
+                    && (self.egui_input.modifiers.ctrl || self.egui_input.modifiers.mac_cmd);
+
+                let consumed = if is_printable_char(*ch) && !is_mac_cmd {
+                    self.egui_input
+                        .events
+                        .push(egui::Event::Text(ch.to_string()));
+                    egui_ctx.wants_keyboard_input()
+                } else {
+                    false
+                };
+                EventResponse {
+                    repaint: true,
+                    consumed,
+                }
+            }
+            WindowEvent::Ime(ime) => {
+                // on Mac even Cmd-C is pressed during ime, a `c` is pushed to Preedit.
+                // So no need to check is_mac_cmd.
+                //
+                // How winit produce `Ime::Enabled` and `Ime::Disabled` differs in MacOS
+                // and Windows.
+                //
+                // - On Windows, before and after each Commit will produce an Enable/Disabled
+                // event.
+                // - On MacOS, only when user explicit enable/disable ime. No Disabled
+                // after Commit.
+                //
+                // We use input_method_editor_started to manually insert CompositionStart
+                // between Commits.
+                match ime {
+                    winit::event::Ime::Enabled | winit::event::Ime::Disabled => (),
+                    winit::event::Ime::Commit(text) => {
+                        self.input_method_editor_started = false;
+                        self.egui_input
+                            .events
+                            .push(egui::Event::CompositionEnd(text.clone()));
+                    }
+                    winit::event::Ime::Preedit(text, ..) => {
+                        if !self.input_method_editor_started {
+                            self.input_method_editor_started = true;
+                            self.egui_input.events.push(egui::Event::CompositionStart);
+                        }
+                        self.egui_input
+                            .events
+                            .push(egui::Event::CompositionUpdate(text.clone()));
+                    }
+                };
+
+                EventResponse {
+                    repaint: true,
+                    consumed: egui_ctx.wants_keyboard_input(),
+                }
+            }
+            WindowEvent::KeyboardInput { input, .. } => {
+                self.on_keyboard_input(input);
+                let consumed = egui_ctx.wants_keyboard_input()
+                    || input.virtual_keycode == Some(winit::event::VirtualKeyCode::Tab);
+                EventResponse {
+                    repaint: true,
+                    consumed,
+                }
+            }
+            WindowEvent::Focused(has_focus) => {
+                self.egui_input.has_focus = *has_focus;
+                // We will not be given a KeyboardInput event when the modifiers are released while
+                // the window does not have focus. Unset all modifier state to be safe.
+                self.egui_input.modifiers = egui::Modifiers::default();
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::HoveredFile(path) => {
+                self.egui_input.hovered_files.push(egui::HoveredFile {
+                    path: Some(path.clone()),
+                    ..Default::default()
+                });
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::HoveredFileCancelled => {
+                self.egui_input.hovered_files.clear();
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::DroppedFile(path) => {
+                self.egui_input.hovered_files.clear();
+                self.egui_input.dropped_files.push(egui::DroppedFile {
+                    path: Some(path.clone()),
+                    ..Default::default()
+                });
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::ModifiersChanged(state) => {
+                self.egui_input.modifiers.alt = state.alt();
+                self.egui_input.modifiers.ctrl = state.ctrl();
+                self.egui_input.modifiers.shift = state.shift();
+                self.egui_input.modifiers.mac_cmd = cfg!(target_os = "macos") && state.logo();
+                self.egui_input.modifiers.command = if cfg!(target_os = "macos") {
+                    state.logo()
+                } else {
+                    state.ctrl()
+                };
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+
+            // Things that may require repaint:
+            WindowEvent::CloseRequested
+            | WindowEvent::CursorEntered { .. }
+            | WindowEvent::Destroyed
+            | WindowEvent::Occluded(_)
+            | WindowEvent::Resized(_)
+            | WindowEvent::ThemeChanged(_)
+            | WindowEvent::TouchpadPressure { .. } => EventResponse {
+                repaint: true,
+                consumed: false,
+            },
+
+            // Things we completely ignore:
+            WindowEvent::AxisMotion { .. }
+            | WindowEvent::Moved(_)
+            | WindowEvent::SmartMagnify { .. }
+            | WindowEvent::TouchpadRotate { .. } => EventResponse {
+                repaint: false,
+                consumed: false,
+            },
+
+            WindowEvent::TouchpadMagnify { delta, .. } => {
+                // Positive delta values indicate magnification (zooming in).
+                // Negative delta values indicate shrinking (zooming out).
+                let zoom_factor = (*delta as f32).exp();
+                self.egui_input.events.push(egui::Event::Zoom(zoom_factor));
+                EventResponse {
+                    repaint: true,
+                    consumed: egui_ctx.wants_pointer_input(),
+                }
+            }
+        }
+    }
+
+    /// Call this when there is a new [`accesskit::ActionRequest`].
+    ///
+    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
+    #[cfg(feature = "accesskit")]
+    pub fn on_accesskit_action_request(&mut self, request: accesskit::ActionRequest) {
+        self.egui_input
+            .events
+            .push(egui::Event::AccessKitActionRequest(request));
+    }
+
+    fn on_mouse_button_input(
+        &mut self,
+        state: winit::event::ElementState,
+        button: winit::event::MouseButton,
+    ) {
+        if let Some(pos) = self.pointer_pos_in_points {
+            if let Some(button) = translate_mouse_button(button) {
+                let pressed = state == winit::event::ElementState::Pressed;
+
+                self.egui_input.events.push(egui::Event::PointerButton {
+                    pos,
+                    button,
+                    pressed,
+                    modifiers: self.egui_input.modifiers,
+                });
+
+                if self.simulate_touch_screen {
+                    if pressed {
+                        self.any_pointer_button_down = true;
+
+                        self.egui_input.events.push(egui::Event::Touch {
+                            device_id: egui::TouchDeviceId(0),
+                            id: egui::TouchId(0),
+                            phase: egui::TouchPhase::Start,
+                            pos,
+                            force: 0.0,
+                        });
+                    } else {
+                        self.any_pointer_button_down = false;
+
+                        self.egui_input.events.push(egui::Event::PointerGone);
+
+                        self.egui_input.events.push(egui::Event::Touch {
+                            device_id: egui::TouchDeviceId(0),
+                            id: egui::TouchId(0),
+                            phase: egui::TouchPhase::End,
+                            pos,
+                            force: 0.0,
+                        });
+                    };
+                }
+            }
+        }
+    }
+
+    fn on_cursor_moved(&mut self, pos_in_pixels: winit::dpi::PhysicalPosition<f64>) {
+        let pos_in_points = egui::pos2(
+            pos_in_pixels.x as f32 / self.pixels_per_point(),
+            pos_in_pixels.y as f32 / self.pixels_per_point(),
+        );
+        self.pointer_pos_in_points = Some(pos_in_points);
+
+        if self.simulate_touch_screen {
+            if self.any_pointer_button_down {
+                self.egui_input
+                    .events
+                    .push(egui::Event::PointerMoved(pos_in_points));
+
+                self.egui_input.events.push(egui::Event::Touch {
+                    device_id: egui::TouchDeviceId(0),
+                    id: egui::TouchId(0),
+                    phase: egui::TouchPhase::Move,
+                    pos: pos_in_points,
+                    force: 0.0,
+                });
+            }
+        } else {
+            self.egui_input
+                .events
+                .push(egui::Event::PointerMoved(pos_in_points));
+        }
+    }
+
+    fn on_touch(&mut self, touch: &winit::event::Touch) {
+        // Emit touch event
+        self.egui_input.events.push(egui::Event::Touch {
+            device_id: egui::TouchDeviceId(egui::epaint::util::hash(touch.device_id)),
+            id: egui::TouchId::from(touch.id),
+            phase: match touch.phase {
+                winit::event::TouchPhase::Started => egui::TouchPhase::Start,
+                winit::event::TouchPhase::Moved => egui::TouchPhase::Move,
+                winit::event::TouchPhase::Ended => egui::TouchPhase::End,
+                winit::event::TouchPhase::Cancelled => egui::TouchPhase::Cancel,
+            },
+            pos: egui::pos2(
+                touch.location.x as f32 / self.pixels_per_point(),
+                touch.location.y as f32 / self.pixels_per_point(),
+            ),
+            force: match touch.force {
+                Some(winit::event::Force::Normalized(force)) => force as f32,
+                Some(winit::event::Force::Calibrated {
+                    force,
+                    max_possible_force,
+                    ..
+                }) => (force / max_possible_force) as f32,
+                None => 0_f32,
+            },
+        });
+        // If we're not yet translating a touch or we're translating this very
+        // touch …
+        if self.pointer_touch_id.is_none() || self.pointer_touch_id.unwrap() == touch.id {
+            // … emit PointerButton resp. PointerMoved events to emulate mouse
+            match touch.phase {
+                winit::event::TouchPhase::Started => {
+                    self.pointer_touch_id = Some(touch.id);
+                    // First move the pointer to the right location
+                    self.on_cursor_moved(touch.location);
+                    self.on_mouse_button_input(
+                        winit::event::ElementState::Pressed,
+                        winit::event::MouseButton::Left,
+                    );
+                }
+                winit::event::TouchPhase::Moved => {
+                    self.on_cursor_moved(touch.location);
+                }
+                winit::event::TouchPhase::Ended => {
+                    self.pointer_touch_id = None;
+                    self.on_mouse_button_input(
+                        winit::event::ElementState::Released,
+                        winit::event::MouseButton::Left,
+                    );
+                    // The pointer should vanish completely to not get any
+                    // hover effects
+                    self.pointer_pos_in_points = None;
+                    self.egui_input.events.push(egui::Event::PointerGone);
+                }
+                winit::event::TouchPhase::Cancelled => {
+                    self.pointer_touch_id = None;
+                    self.pointer_pos_in_points = None;
+                    self.egui_input.events.push(egui::Event::PointerGone);
+                }
+            }
+        }
+    }
+
+    fn on_mouse_wheel(&mut self, delta: winit::event::MouseScrollDelta) {
+        {
+            let (unit, delta) = match delta {
+                winit::event::MouseScrollDelta::LineDelta(x, y) => {
+                    (egui::MouseWheelUnit::Line, egui::vec2(x, y))
+                }
+                winit::event::MouseScrollDelta::PixelDelta(winit::dpi::PhysicalPosition {
+                    x,
+                    y,
+                }) => (
+                    egui::MouseWheelUnit::Point,
+                    egui::vec2(x as f32, y as f32) / self.pixels_per_point(),
+                ),
+            };
+            let modifiers = self.egui_input.modifiers;
+            self.egui_input.events.push(egui::Event::MouseWheel {
+                unit,
+                delta,
+                modifiers,
+            });
+        }
+        let delta = match delta {
+            winit::event::MouseScrollDelta::LineDelta(x, y) => {
+                let points_per_scroll_line = 50.0; // Scroll speed decided by consensus: https://github.com/emilk/egui/issues/461
+                egui::vec2(x, y) * points_per_scroll_line
+            }
+            winit::event::MouseScrollDelta::PixelDelta(delta) => {
+                egui::vec2(delta.x as f32, delta.y as f32) / self.pixels_per_point()
+            }
+        };
+
+        if self.egui_input.modifiers.ctrl || self.egui_input.modifiers.command {
+            // Treat as zoom instead:
+            let factor = (delta.y / 200.0).exp();
+            self.egui_input.events.push(egui::Event::Zoom(factor));
+        } else if self.egui_input.modifiers.shift {
+            // Treat as horizontal scrolling.
+            // Note: one Mac we already get horizontal scroll events when shift is down.
+            self.egui_input
+                .events
+                .push(egui::Event::Scroll(egui::vec2(delta.x + delta.y, 0.0)));
+        } else {
+            self.egui_input.events.push(egui::Event::Scroll(delta));
+        }
+    }
+
+    fn on_keyboard_input(&mut self, input: &winit::event::KeyboardInput) {
+        if let Some(keycode) = input.virtual_keycode {
+            let pressed = input.state == winit::event::ElementState::Pressed;
+
+            if pressed {
+                // VirtualKeyCode::Paste etc in winit are broken/untrustworthy,
+                // so we detect these things manually:
+                if is_cut_command(self.egui_input.modifiers, keycode) {
+                    self.egui_input.events.push(egui::Event::Cut);
+                } else if is_copy_command(self.egui_input.modifiers, keycode) {
+                    self.egui_input.events.push(egui::Event::Copy);
+                } else if is_paste_command(self.egui_input.modifiers, keycode) {
+                    if let Some(contents) = self.clipboard.get() {
+                        let contents = contents.replace("\r\n", "\n");
+                        if !contents.is_empty() {
+                            self.egui_input.events.push(egui::Event::Paste(contents));
+                        }
+                    }
+                }
+            }
+
+            if let Some(key) = translate_virtual_key_code(keycode) {
+                self.egui_input.events.push(egui::Event::Key {
+                    key,
+                    pressed,
+                    repeat: false, // egui will fill this in for us!
+                    modifiers: self.egui_input.modifiers,
+                });
+            }
+        }
+    }
+
+    /// Call with the output given by `egui`.
+    ///
+    /// This will, if needed:
+    /// * update the cursor
+    /// * copy text to the clipboard
+    /// * open any clicked urls
+    /// * update the IME
+    /// *
+    pub fn handle_platform_output(
+        &mut self,
+        window: &winit::window::Window,
+        egui_ctx: &egui::Context,
+        platform_output: egui::PlatformOutput,
+    ) {
+        let egui::PlatformOutput {
+            cursor_icon,
+            open_url,
+            copied_text,
+            events: _,                    // handled above
+            mutable_text_under_cursor: _, // only used in eframe web
+            text_cursor_pos,
+            #[cfg(feature = "accesskit")]
+            accesskit_update,
+        } = platform_output;
+        self.current_pixels_per_point = egui_ctx.pixels_per_point(); // someone can have changed it to scale the UI
+
+        self.set_cursor_icon(window, cursor_icon);
+
+        if let Some(open_url) = open_url {
+            open_url_in_browser(&open_url.url);
+        }
+
+        if !copied_text.is_empty() {
+            self.clipboard.set(copied_text);
+        }
+
+        if let Some(egui::Pos2 { x, y }) = text_cursor_pos {
+            window.set_ime_position(winit::dpi::LogicalPosition { x, y });
+        }
+
+        #[cfg(feature = "accesskit")]
+        if let Some(accesskit) = self.accesskit.as_ref() {
+            if let Some(update) = accesskit_update {
+                accesskit.update_if_active(|| update);
+            }
+        }
+    }
+
+    fn set_cursor_icon(&mut self, window: &winit::window::Window, cursor_icon: egui::CursorIcon) {
+        if self.current_cursor_icon == Some(cursor_icon) {
+            // Prevent flickering near frame boundary when Windows OS tries to control cursor icon for window resizing.
+            // On other platforms: just early-out to save CPU.
+            return;
+        }
+
+        let is_pointer_in_window = self.pointer_pos_in_points.is_some();
+        if is_pointer_in_window {
+            self.current_cursor_icon = Some(cursor_icon);
+
+            if let Some(winit_cursor_icon) = translate_cursor(cursor_icon) {
+                window.set_cursor_visible(true);
+                window.set_cursor_icon(winit_cursor_icon);
+            } else {
+                window.set_cursor_visible(false);
+            }
+        } else {
+            // Remember to set the cursor again once the cursor returns to the screen:
+            self.current_cursor_icon = None;
+        }
+    }
+}
+
+fn open_url_in_browser(_url: &str) {
+    #[cfg(feature = "webbrowser")]
+    if let Err(err) = webbrowser::open(_url) {
+        tracing::warn!("Failed to open url: {}", err);
+    }
+
+    #[cfg(not(feature = "webbrowser"))]
+    {
+        tracing::warn!("Cannot open url - feature \"links\" not enabled.");
+    }
+}
+
+/// Winit sends special keys (backspace, delete, F1, …) as characters.
+/// Ignore those.
+/// We also ignore '\r', '\n', '\t'.
+/// Newlines are handled by the `Key::Enter` event.
+fn is_printable_char(chr: char) -> bool {
+    let is_in_private_use_area = '\u{e000}' <= chr && chr <= '\u{f8ff}'
+        || '\u{f0000}' <= chr && chr <= '\u{ffffd}'
+        || '\u{100000}' <= chr && chr <= '\u{10fffd}';
+
+    !is_in_private_use_area && !chr.is_ascii_control()
+}
+
+fn is_cut_command(modifiers: egui::Modifiers, keycode: winit::event::VirtualKeyCode) -> bool {
+    (modifiers.command && keycode == winit::event::VirtualKeyCode::X)
+        || (cfg!(target_os = "windows")
+            && modifiers.shift
+            && keycode == winit::event::VirtualKeyCode::Delete)
+}
+
+fn is_copy_command(modifiers: egui::Modifiers, keycode: winit::event::VirtualKeyCode) -> bool {
+    (modifiers.command && keycode == winit::event::VirtualKeyCode::C)
+        || (cfg!(target_os = "windows")
+            && modifiers.ctrl
+            && keycode == winit::event::VirtualKeyCode::Insert)
+}
+
+fn is_paste_command(modifiers: egui::Modifiers, keycode: winit::event::VirtualKeyCode) -> bool {
+    (modifiers.command && keycode == winit::event::VirtualKeyCode::V)
+        || (cfg!(target_os = "windows")
+            && modifiers.shift
+            && keycode == winit::event::VirtualKeyCode::Insert)
+}
+
+fn translate_mouse_button(button: winit::event::MouseButton) -> Option<egui::PointerButton> {
+    match button {
+        winit::event::MouseButton::Left => Some(egui::PointerButton::Primary),
+        winit::event::MouseButton::Right => Some(egui::PointerButton::Secondary),
+        winit::event::MouseButton::Middle => Some(egui::PointerButton::Middle),
+        winit::event::MouseButton::Other(1) => Some(egui::PointerButton::Extra1),
+        winit::event::MouseButton::Other(2) => Some(egui::PointerButton::Extra2),
+        winit::event::MouseButton::Other(_) => None,
+    }
+}
+
+fn translate_virtual_key_code(key: winit::event::VirtualKeyCode) -> Option<egui::Key> {
+    use egui::Key;
+    use winit::event::VirtualKeyCode;
+
+    Some(match key {
+        VirtualKeyCode::Down => Key::ArrowDown,
+        VirtualKeyCode::Left => Key::ArrowLeft,
+        VirtualKeyCode::Right => Key::ArrowRight,
+        VirtualKeyCode::Up => Key::ArrowUp,
+
+        VirtualKeyCode::Escape => Key::Escape,
+        VirtualKeyCode::Tab => Key::Tab,
+        VirtualKeyCode::Back => Key::Backspace,
+        VirtualKeyCode::Return => Key::Enter,
+        VirtualKeyCode::Space => Key::Space,
+
+        VirtualKeyCode::Insert => Key::Insert,
+        VirtualKeyCode::Delete => Key::Delete,
+        VirtualKeyCode::Home => Key::Home,
+        VirtualKeyCode::End => Key::End,
+        VirtualKeyCode::PageUp => Key::PageUp,
+        VirtualKeyCode::PageDown => Key::PageDown,
+
+        VirtualKeyCode::Minus => Key::Minus,
+        // Using Mac the key with the Plus sign on it is reported as the Equals key
+        // (with both English and Swedish keyboard).
+        VirtualKeyCode::Equals => Key::PlusEquals,
+
+        VirtualKeyCode::Key0 | VirtualKeyCode::Numpad0 => Key::Num0,
+        VirtualKeyCode::Key1 | VirtualKeyCode::Numpad1 => Key::Num1,
+        VirtualKeyCode::Key2 | VirtualKeyCode::Numpad2 => Key::Num2,
+        VirtualKeyCode::Key3 | VirtualKeyCode::Numpad3 => Key::Num3,
+        VirtualKeyCode::Key4 | VirtualKeyCode::Numpad4 => Key::Num4,
+        VirtualKeyCode::Key5 | VirtualKeyCode::Numpad5 => Key::Num5,
+        VirtualKeyCode::Key6 | VirtualKeyCode::Numpad6 => Key::Num6,
+        VirtualKeyCode::Key7 | VirtualKeyCode::Numpad7 => Key::Num7,
+        VirtualKeyCode::Key8 | VirtualKeyCode::Numpad8 => Key::Num8,
+        VirtualKeyCode::Key9 | VirtualKeyCode::Numpad9 => Key::Num9,
+
+        VirtualKeyCode::A => Key::A,
+        VirtualKeyCode::B => Key::B,
+        VirtualKeyCode::C => Key::C,
+        VirtualKeyCode::D => Key::D,
+        VirtualKeyCode::E => Key::E,
+        VirtualKeyCode::F => Key::F,
+        VirtualKeyCode::G => Key::G,
+        VirtualKeyCode::H => Key::H,
+        VirtualKeyCode::I => Key::I,
+        VirtualKeyCode::J => Key::J,
+        VirtualKeyCode::K => Key::K,
+        VirtualKeyCode::L => Key::L,
+        VirtualKeyCode::M => Key::M,
+        VirtualKeyCode::N => Key::N,
+        VirtualKeyCode::O => Key::O,
+        VirtualKeyCode::P => Key::P,
+        VirtualKeyCode::Q => Key::Q,
+        VirtualKeyCode::R => Key::R,
+        VirtualKeyCode::S => Key::S,
+        VirtualKeyCode::T => Key::T,
+        VirtualKeyCode::U => Key::U,
+        VirtualKeyCode::V => Key::V,
+        VirtualKeyCode::W => Key::W,
+        VirtualKeyCode::X => Key::X,
+        VirtualKeyCode::Y => Key::Y,
+        VirtualKeyCode::Z => Key::Z,
+
+        VirtualKeyCode::F1 => Key::F1,
+        VirtualKeyCode::F2 => Key::F2,
+        VirtualKeyCode::F3 => Key::F3,
+        VirtualKeyCode::F4 => Key::F4,
+        VirtualKeyCode::F5 => Key::F5,
+        VirtualKeyCode::F6 => Key::F6,
+        VirtualKeyCode::F7 => Key::F7,
+        VirtualKeyCode::F8 => Key::F8,
+        VirtualKeyCode::F9 => Key::F9,
+        VirtualKeyCode::F10 => Key::F10,
+        VirtualKeyCode::F11 => Key::F11,
+        VirtualKeyCode::F12 => Key::F12,
+        VirtualKeyCode::F13 => Key::F13,
+        VirtualKeyCode::F14 => Key::F14,
+        VirtualKeyCode::F15 => Key::F15,
+        VirtualKeyCode::F16 => Key::F16,
+        VirtualKeyCode::F17 => Key::F17,
+        VirtualKeyCode::F18 => Key::F18,
+        VirtualKeyCode::F19 => Key::F19,
+        VirtualKeyCode::F20 => Key::F20,
+
+        _ => {
+            return None;
+        }
+    })
+}
+
+fn translate_cursor(cursor_icon: egui::CursorIcon) -> Option<winit::window::CursorIcon> {
+    match cursor_icon {
+        egui::CursorIcon::None => None,
+
+        egui::CursorIcon::Alias => Some(winit::window::CursorIcon::Alias),
+        egui::CursorIcon::AllScroll => Some(winit::window::CursorIcon::AllScroll),
+        egui::CursorIcon::Cell => Some(winit::window::CursorIcon::Cell),
+        egui::CursorIcon::ContextMenu => Some(winit::window::CursorIcon::ContextMenu),
+        egui::CursorIcon::Copy => Some(winit::window::CursorIcon::Copy),
+        egui::CursorIcon::Crosshair => Some(winit::window::CursorIcon::Crosshair),
+        egui::CursorIcon::Default => Some(winit::window::CursorIcon::Default),
+        egui::CursorIcon::Grab => Some(winit::window::CursorIcon::Grab),
+        egui::CursorIcon::Grabbing => Some(winit::window::CursorIcon::Grabbing),
+        egui::CursorIcon::Help => Some(winit::window::CursorIcon::Help),
+        egui::CursorIcon::Move => Some(winit::window::CursorIcon::Move),
+        egui::CursorIcon::NoDrop => Some(winit::window::CursorIcon::NoDrop),
+        egui::CursorIcon::NotAllowed => Some(winit::window::CursorIcon::NotAllowed),
+        egui::CursorIcon::PointingHand => Some(winit::window::CursorIcon::Hand),
+        egui::CursorIcon::Progress => Some(winit::window::CursorIcon::Progress),
+
+        egui::CursorIcon::ResizeHorizontal => Some(winit::window::CursorIcon::EwResize),
+        egui::CursorIcon::ResizeNeSw => Some(winit::window::CursorIcon::NeswResize),
+        egui::CursorIcon::ResizeNwSe => Some(winit::window::CursorIcon::NwseResize),
+        egui::CursorIcon::ResizeVertical => Some(winit::window::CursorIcon::NsResize),
+
+        egui::CursorIcon::ResizeEast => Some(winit::window::CursorIcon::EResize),
+        egui::CursorIcon::ResizeSouthEast => Some(winit::window::CursorIcon::SeResize),
+        egui::CursorIcon::ResizeSouth => Some(winit::window::CursorIcon::SResize),
+        egui::CursorIcon::ResizeSouthWest => Some(winit::window::CursorIcon::SwResize),
+        egui::CursorIcon::ResizeWest => Some(winit::window::CursorIcon::WResize),
+        egui::CursorIcon::ResizeNorthWest => Some(winit::window::CursorIcon::NwResize),
+        egui::CursorIcon::ResizeNorth => Some(winit::window::CursorIcon::NResize),
+        egui::CursorIcon::ResizeNorthEast => Some(winit::window::CursorIcon::NeResize),
+        egui::CursorIcon::ResizeColumn => Some(winit::window::CursorIcon::ColResize),
+        egui::CursorIcon::ResizeRow => Some(winit::window::CursorIcon::RowResize),
+
+        egui::CursorIcon::Text => Some(winit::window::CursorIcon::Text),
+        egui::CursorIcon::VerticalText => Some(winit::window::CursorIcon::VerticalText),
+        egui::CursorIcon::Wait => Some(winit::window::CursorIcon::Wait),
+        egui::CursorIcon::ZoomIn => Some(winit::window::CursorIcon::ZoomIn),
+        egui::CursorIcon::ZoomOut => Some(winit::window::CursorIcon::ZoomOut),
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+/// Profiling macro for feature "puffin"
+#[allow(unused_macros)]
+macro_rules! profile_function {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        puffin::profile_function!($($arg)*);
+    };
+}
+
+#[allow(unused_imports)]
+pub(crate) use profile_function;
+
+/// Profiling macro for feature "puffin"
+#[allow(unused_macros)]
+macro_rules! profile_scope {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        puffin::profile_scope!($($arg)*);
+    };
+}
+
+#[allow(unused_imports)]
+pub(crate) use profile_scope;
diff --git a/egui/crates/egui-winit/src/window_settings.rs b/egui/crates/egui-winit/src/window_settings.rs
new file mode 100644
index 0000000..0137af2
--- /dev/null
+++ b/egui/crates/egui-winit/src/window_settings.rs
@@ -0,0 +1,144 @@
+/// Can be used to store native window settings (position and size).
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WindowSettings {
+    /// Position of window in physical pixels. This is either
+    /// the inner or outer position depending on the platform.
+    /// See [`winit::window::WindowBuilder::with_position`] for details.
+    position: Option<egui::Pos2>,
+
+    fullscreen: bool,
+
+    /// Inner size of window in logical pixels
+    inner_size_points: Option<egui::Vec2>,
+}
+
+impl WindowSettings {
+    pub fn from_display(window: &winit::window::Window) -> Self {
+        let inner_size_points = window.inner_size().to_logical::<f32>(window.scale_factor());
+        let position = if cfg!(macos) {
+            // MacOS uses inner position when positioning windows.
+            window
+                .inner_position()
+                .ok()
+                .map(|p| egui::pos2(p.x as f32, p.y as f32))
+        } else {
+            // Other platforms use the outer position.
+            window
+                .outer_position()
+                .ok()
+                .map(|p| egui::pos2(p.x as f32, p.y as f32))
+        };
+
+        Self {
+            position,
+
+            fullscreen: window.fullscreen().is_some(),
+
+            inner_size_points: Some(egui::vec2(
+                inner_size_points.width,
+                inner_size_points.height,
+            )),
+        }
+    }
+
+    pub fn inner_size_points(&self) -> Option<egui::Vec2> {
+        self.inner_size_points
+    }
+
+    pub fn initialize_window(
+        &self,
+        mut window: winit::window::WindowBuilder,
+    ) -> winit::window::WindowBuilder {
+        // If the app last ran on two monitors and only one is now connected, then
+        // the given position is invalid.
+        // If this happens on Mac, the window is clamped into valid area.
+        // If this happens on Windows, the clamping behavior is managed by the function
+        // clamp_window_to_sane_position.
+        if let Some(pos) = self.position {
+            window = window.with_position(winit::dpi::PhysicalPosition {
+                x: pos.x as f64,
+                y: pos.y as f64,
+            });
+        }
+
+        if let Some(inner_size_points) = self.inner_size_points {
+            window
+                .with_inner_size(winit::dpi::LogicalSize {
+                    width: inner_size_points.x as f64,
+                    height: inner_size_points.y as f64,
+                })
+                .with_fullscreen(
+                    self.fullscreen
+                        .then_some(winit::window::Fullscreen::Borderless(None)),
+                )
+        } else {
+            window
+        }
+    }
+
+    pub fn clamp_to_sane_values(&mut self, max_size: egui::Vec2) {
+        use egui::NumExt as _;
+
+        if let Some(size) = &mut self.inner_size_points {
+            // Prevent ridiculously small windows
+            let min_size = egui::Vec2::splat(64.0);
+            *size = size.at_least(min_size);
+            *size = size.at_most(max_size);
+        }
+    }
+
+    pub fn clamp_window_to_sane_position<E>(
+        &mut self,
+        event_loop: &winit::event_loop::EventLoopWindowTarget<E>,
+    ) {
+        if let (Some(position), Some(inner_size_points)) =
+            (&mut self.position, &self.inner_size_points)
+        {
+            let monitors = event_loop.available_monitors();
+            // default to primary monitor, in case the correct monitor was disconnected.
+            let mut active_monitor = if let Some(active_monitor) = event_loop
+                .primary_monitor()
+                .or_else(|| event_loop.available_monitors().next())
+            {
+                active_monitor
+            } else {
+                return; // no monitors 🤷
+            };
+            for monitor in monitors {
+                let monitor_x_range = (monitor.position().x - inner_size_points.x as i32)
+                    ..(monitor.position().x + monitor.size().width as i32);
+                let monitor_y_range = (monitor.position().y - inner_size_points.y as i32)
+                    ..(monitor.position().y + monitor.size().height as i32);
+
+                if monitor_x_range.contains(&(position.x as i32))
+                    && monitor_y_range.contains(&(position.y as i32))
+                {
+                    active_monitor = monitor;
+                }
+            }
+
+            let mut inner_size_pixels = *inner_size_points * (active_monitor.scale_factor() as f32);
+            // Add size of title bar. This is 32 px by default in Win 10/11.
+            if cfg!(target_os = "windows") {
+                inner_size_pixels +=
+                    egui::Vec2::new(0.0, 32.0 * active_monitor.scale_factor() as f32);
+            }
+            let monitor_position = egui::Pos2::new(
+                active_monitor.position().x as f32,
+                active_monitor.position().y as f32,
+            );
+            let monitor_size = egui::Vec2::new(
+                active_monitor.size().width as f32,
+                active_monitor.size().height as f32,
+            );
+
+            // Window size cannot be negative or the subsequent `clamp` will panic.
+            let window_size = (monitor_size - inner_size_pixels).max(egui::Vec2::ZERO);
+            // To get the maximum position, we get the rightmost corner of the display, then
+            // subtract the size of the window to get the bottom right most value window.position
+            // can have.
+            *position = position.clamp(monitor_position, monitor_position + window_size);
+        }
+    }
+}
diff --git a/egui/crates/egui/Cargo.toml b/egui/crates/egui/Cargo.toml
new file mode 100644
index 0000000..db487d9
--- /dev/null
+++ b/egui/crates/egui/Cargo.toml
@@ -0,0 +1,84 @@
+[package]
+name = "egui"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "An easy-to-use immediate mode GUI that runs on both web and native"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui"
+license = "MIT OR Apache-2.0"
+readme = "../../README.md"
+repository = "https://github.com/emilk/egui"
+categories = ["gui", "game-development"]
+keywords = ["gui", "imgui", "immediate", "portable", "gamedev"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = ["default_fonts"]
+
+## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast [`epaint::Vertex`], [`emath::Vec2`] etc to `&[u8]`.
+bytemuck = ["epaint/bytemuck"]
+
+## [`cint`](https://docs.rs/cint) enables interoperability with other color libraries.
+cint = ["epaint/cint"]
+
+## Enable the [`hex_color`] macro.
+color-hex = ["epaint/color-hex"]
+
+## This will automatically detect deadlocks due to double-locking on the same thread.
+## If your app freezes, you may want to enable this!
+## Only affects [`epaint::mutex::RwLock`] (which egui uses a lot).
+deadlock_detection = ["epaint/deadlock_detection"]
+
+## If set, egui will use `include_bytes!` to bundle some fonts.
+## If you plan on specifying your own fonts you may disable this feature.
+default_fonts = ["epaint/default_fonts"]
+
+## Enable additional checks if debug assertions are enabled (debug builds).
+extra_debug_asserts = ["epaint/extra_debug_asserts"]
+## Always enable additional checks.
+extra_asserts = ["epaint/extra_asserts"]
+
+## [`mint`](https://docs.rs/mint) enables interoperability with other math libraries such as [`glam`](https://docs.rs/glam) and [`nalgebra`](https://docs.rs/nalgebra).
+mint = ["epaint/mint"]
+
+## Enable persistence of memory (window positions etc).
+persistence = ["serde", "epaint/serde", "ron"]
+
+## Allow serialization using [`serde`](https://docs.rs/serde).
+serde = ["dep:serde", "epaint/serde", "accesskit?/serde"]
+
+## Change Vertex layout to be compatible with unity
+unity = ["epaint/unity"]
+
+
+[dependencies]
+epaint = { version = "0.21.0", path = "../epaint", default-features = false }
+
+ahash = { version = "0.8.1", default-features = false, features = [
+    "no-rng", # we don't need DOS-protection, so we let users opt-in to it instead
+    "std",
+] }
+nohash-hasher = "0.2"
+
+#! ### Optional dependencies
+## Exposes detailed accessibility implementation required by platform
+## accessibility APIs. Also requires support in the egui integration.
+accesskit = { version = "0.10.1", optional = true }
+
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+ron = { version = "0.8", optional = true }
+serde = { version = "1", optional = true, features = ["derive", "rc"] }
+
+# egui doesn't log much, but when it does, it uses [`tracing`](https://docs.rs/tracing).
+tracing = { version = "0.1", optional = true, default-features = false, features = [
+    "std",
+] }
diff --git a/egui/crates/egui/README.md b/egui/crates/egui/README.md
new file mode 100644
index 0000000..8abcec6
--- /dev/null
+++ b/egui/crates/egui/README.md
@@ -0,0 +1,2 @@
+# GUI implementation
+This is the core library crate egui. It is fully platform independent without any backend. You give the egui library input each frame (mouse pos etc), and it outputs a triangle mesh for you to paint.
diff --git a/egui/crates/egui/examples/README.md b/egui/crates/egui/examples/README.md
new file mode 100644
index 0000000..e4d19c8
--- /dev/null
+++ b/egui/crates/egui/examples/README.md
@@ -0,0 +1,7 @@
+There are no stand-alone egui examples, because egui is not stand-alone!
+
+See the top-level [examples](https://github.com/emilk/egui/tree/master/examples/) folder instead.
+
+There are also plenty of examples in [the online demo](https://www.egui.rs/#demo). You can find the source code for it at <https://github.com/emilk/egui/tree/master/crates/egui_demo_lib>.
+
+To learn how to set up `eframe` for web and native, go to <https://github.com/emilk/eframe_template/> and follow the instructions there!
diff --git a/egui/crates/egui/src/animation_manager.rs b/egui/crates/egui/src/animation_manager.rs
new file mode 100644
index 0000000..be18150
--- /dev/null
+++ b/egui/crates/egui/src/animation_manager.rs
@@ -0,0 +1,114 @@
+use crate::{emath::remap_clamp, Id, IdMap, InputState};
+
+#[derive(Clone, Default)]
+pub(crate) struct AnimationManager {
+    bools: IdMap<BoolAnim>,
+    values: IdMap<ValueAnim>,
+}
+
+#[derive(Clone, Debug)]
+struct BoolAnim {
+    value: bool,
+
+    /// when did `value` last toggle?
+    toggle_time: f64,
+}
+
+#[derive(Clone, Debug)]
+struct ValueAnim {
+    from_value: f32,
+
+    to_value: f32,
+
+    /// when did `value` last toggle?
+    toggle_time: f64,
+}
+
+impl AnimationManager {
+    /// See `Context::animate_bool` for documentation
+    pub fn animate_bool(
+        &mut self,
+        input: &InputState,
+        animation_time: f32,
+        id: Id,
+        value: bool,
+    ) -> f32 {
+        match self.bools.get_mut(&id) {
+            None => {
+                self.bools.insert(
+                    id,
+                    BoolAnim {
+                        value,
+                        toggle_time: -f64::INFINITY, // long time ago
+                    },
+                );
+                if value {
+                    1.0
+                } else {
+                    0.0
+                }
+            }
+            Some(anim) => {
+                if anim.value != value {
+                    anim.value = value;
+                    anim.toggle_time = input.time;
+                }
+
+                let time_since_toggle = (input.time - anim.toggle_time) as f32;
+
+                // On the frame we toggle we don't want to return the old value,
+                // so we extrapolate forwards:
+                let time_since_toggle = time_since_toggle + input.predicted_dt;
+
+                if value {
+                    remap_clamp(time_since_toggle, 0.0..=animation_time, 0.0..=1.0)
+                } else {
+                    remap_clamp(time_since_toggle, 0.0..=animation_time, 1.0..=0.0)
+                }
+            }
+        }
+    }
+
+    pub fn animate_value(
+        &mut self,
+        input: &InputState,
+        animation_time: f32,
+        id: Id,
+        value: f32,
+    ) -> f32 {
+        match self.values.get_mut(&id) {
+            None => {
+                self.values.insert(
+                    id,
+                    ValueAnim {
+                        from_value: value,
+                        to_value: value,
+                        toggle_time: -f64::INFINITY, // long time ago
+                    },
+                );
+                value
+            }
+            Some(anim) => {
+                let time_since_toggle = (input.time - anim.toggle_time) as f32;
+                // On the frame we toggle we don't want to return the old value,
+                // so we extrapolate forwards:
+                let time_since_toggle = time_since_toggle + input.predicted_dt;
+                let current_value = remap_clamp(
+                    time_since_toggle,
+                    0.0..=animation_time,
+                    anim.from_value..=anim.to_value,
+                );
+                if anim.to_value != value {
+                    anim.from_value = current_value; //start new animation from current position of playing animation
+                    anim.to_value = value;
+                    anim.toggle_time = input.time;
+                }
+                if animation_time == 0.0 {
+                    anim.from_value = value;
+                    anim.to_value = value;
+                }
+                current_value
+            }
+        }
+    }
+}
diff --git a/egui/crates/egui/src/containers/area.rs b/egui/crates/egui/src/containers/area.rs
new file mode 100644
index 0000000..380c175
--- /dev/null
+++ b/egui/crates/egui/src/containers/area.rs
@@ -0,0 +1,514 @@
+//! Area is a [`Ui`] that has no parent, it floats on the background.
+//! It has no frame or own size. It is potentially movable.
+//! It is the foundation for windows and popups.
+
+use crate::*;
+
+/// State that is persisted between frames.
+// TODO(emilk): this is not currently stored in `Memory::data`, but maybe it should be?
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) struct State {
+    /// Last known pos of the pivot
+    pub pivot_pos: Pos2,
+
+    pub pivot: Align2,
+
+    /// Last know size. Used for catching clicks.
+    pub size: Vec2,
+
+    /// If false, clicks goes straight through to what is behind us.
+    /// Good for tooltips etc.
+    pub interactable: bool,
+}
+
+impl State {
+    pub fn left_top_pos(&self) -> Pos2 {
+        pos2(
+            self.pivot_pos.x - self.pivot.x().to_factor() * self.size.x,
+            self.pivot_pos.y - self.pivot.y().to_factor() * self.size.y,
+        )
+    }
+
+    pub fn set_left_top_pos(&mut self, pos: Pos2) {
+        self.pivot_pos = pos2(
+            pos.x + self.pivot.x().to_factor() * self.size.x,
+            pos.y + self.pivot.y().to_factor() * self.size.y,
+        );
+    }
+
+    pub fn rect(&self) -> Rect {
+        Rect::from_min_size(self.left_top_pos(), self.size)
+    }
+}
+
+/// An area on the screen that can be moved by dragging.
+///
+/// This forms the base of the [`Window`] container.
+///
+/// ```
+/// # egui::__run_test_ctx(|ctx| {
+/// egui::Area::new("my_area")
+///     .fixed_pos(egui::pos2(32.0, 32.0))
+///     .show(ctx, |ui| {
+///         ui.label("Floating text!");
+///     });
+/// # });
+/// ```
+#[must_use = "You should call .show()"]
+#[derive(Clone, Copy, Debug)]
+pub struct Area {
+    pub(crate) id: Id,
+    movable: bool,
+    interactable: bool,
+    enabled: bool,
+    constrain: bool,
+    order: Order,
+    default_pos: Option<Pos2>,
+    pivot: Align2,
+    anchor: Option<(Align2, Vec2)>,
+    new_pos: Option<Pos2>,
+    drag_bounds: Option<Rect>,
+}
+
+impl Area {
+    pub fn new(id: impl Into<Id>) -> Self {
+        Self {
+            id: id.into(),
+            movable: true,
+            interactable: true,
+            constrain: false,
+            enabled: true,
+            order: Order::Middle,
+            default_pos: None,
+            new_pos: None,
+            pivot: Align2::LEFT_TOP,
+            anchor: None,
+            drag_bounds: None,
+        }
+    }
+
+    pub fn id(mut self, id: Id) -> Self {
+        self.id = id;
+        self
+    }
+
+    pub fn layer(&self) -> LayerId {
+        LayerId::new(self.order, self.id)
+    }
+
+    /// If false, no content responds to click
+    /// and widgets will be shown grayed out.
+    /// You won't be able to move the window.
+    /// Default: `true`.
+    pub fn enabled(mut self, enabled: bool) -> Self {
+        self.enabled = enabled;
+        self
+    }
+
+    /// moveable by dragging the area?
+    pub fn movable(mut self, movable: bool) -> Self {
+        self.movable = movable;
+        self.interactable |= movable;
+        self
+    }
+
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+
+    pub fn is_movable(&self) -> bool {
+        self.movable && self.enabled
+    }
+
+    /// If false, clicks goes straight through to what is behind us.
+    /// Good for tooltips etc.
+    pub fn interactable(mut self, interactable: bool) -> Self {
+        self.interactable = interactable;
+        self.movable &= interactable;
+        self
+    }
+
+    /// `order(Order::Foreground)` for an Area that should always be on top
+    pub fn order(mut self, order: Order) -> Self {
+        self.order = order;
+        self
+    }
+
+    pub fn default_pos(mut self, default_pos: impl Into<Pos2>) -> Self {
+        self.default_pos = Some(default_pos.into());
+        self
+    }
+
+    /// Positions the window and prevents it from being moved
+    pub fn fixed_pos(mut self, fixed_pos: impl Into<Pos2>) -> Self {
+        self.new_pos = Some(fixed_pos.into());
+        self.movable = false;
+        self
+    }
+
+    /// Constrains this area to the screen bounds.
+    pub fn constrain(mut self, constrain: bool) -> Self {
+        self.constrain = constrain;
+        self
+    }
+
+    /// Where the "root" of the area is.
+    ///
+    /// For instance, if you set this to [`Align2::RIGHT_TOP`]
+    /// then [`Self::fixed_pos`] will set the position of the right-top
+    /// corner of the area.
+    ///
+    /// Default: [`Align2::LEFT_TOP`].
+    pub fn pivot(mut self, pivot: Align2) -> Self {
+        self.pivot = pivot;
+        self
+    }
+
+    /// Positions the window but you can still move it.
+    pub fn current_pos(mut self, current_pos: impl Into<Pos2>) -> Self {
+        self.new_pos = Some(current_pos.into());
+        self
+    }
+
+    /// Set anchor and distance.
+    ///
+    /// An anchor of `Align2::RIGHT_TOP` means "put the right-top corner of the window
+    /// in the right-top corner of the screen".
+    ///
+    /// The offset is added to the position, so e.g. an offset of `[-5.0, 5.0]`
+    /// would move the window left and down from the given anchor.
+    ///
+    /// Anchoring also makes the window immovable.
+    ///
+    /// It is an error to set both an anchor and a position.
+    pub fn anchor(mut self, align: Align2, offset: impl Into<Vec2>) -> Self {
+        self.anchor = Some((align, offset.into()));
+        self.movable(false)
+    }
+
+    /// Constrain the area up to which the window can be dragged.
+    pub fn drag_bounds(mut self, bounds: Rect) -> Self {
+        self.drag_bounds = Some(bounds);
+        self
+    }
+
+    pub(crate) fn get_pivot(&self) -> Align2 {
+        if let Some((pivot, _)) = self.anchor {
+            pivot
+        } else {
+            Align2::LEFT_TOP
+        }
+    }
+}
+
+pub(crate) struct Prepared {
+    layer_id: LayerId,
+    state: State,
+    move_response: Response,
+    enabled: bool,
+    drag_bounds: Option<Rect>,
+
+    /// We always make windows invisible the first frame to hide "first-frame-jitters".
+    ///
+    /// This is so that we use the first frame to calculate the window size,
+    /// and then can correctly position the window and its contents the next frame,
+    /// without having one frame where the window is wrongly positioned or sized.
+    temporarily_invisible: bool,
+}
+
+impl Area {
+    pub fn show<R>(
+        self,
+        ctx: &Context,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        let prepared = self.begin(ctx);
+        let mut content_ui = prepared.content_ui(ctx);
+        let inner = add_contents(&mut content_ui);
+        let response = prepared.end(ctx, content_ui);
+        InnerResponse { inner, response }
+    }
+
+    pub(crate) fn begin(self, ctx: &Context) -> Prepared {
+        let Area {
+            id,
+            movable,
+            order,
+            interactable,
+            enabled,
+            default_pos,
+            new_pos,
+            pivot,
+            anchor,
+            drag_bounds,
+            constrain,
+        } = self;
+
+        let layer_id = LayerId::new(order, id);
+
+        let state = ctx.memory(|mem| mem.areas.get(id).copied());
+        let is_new = state.is_none();
+        if is_new {
+            ctx.request_repaint(); // if we don't know the previous size we are likely drawing the area in the wrong place
+        }
+        let mut state = state.unwrap_or_else(|| State {
+            pivot_pos: default_pos.unwrap_or_else(|| automatic_area_position(ctx)),
+            pivot,
+            size: Vec2::ZERO,
+            interactable,
+        });
+        state.pivot_pos = new_pos.unwrap_or(state.pivot_pos);
+        state.interactable = interactable;
+
+        if let Some((anchor, offset)) = anchor {
+            let screen = ctx.available_rect();
+            state.set_left_top_pos(
+                anchor.align_size_within_rect(state.size, screen).left_top() + offset,
+            );
+        }
+
+        // interact right away to prevent frame-delay
+        let move_response = {
+            let interact_id = layer_id.id.with("move");
+            let sense = if movable {
+                Sense::click_and_drag()
+            } else if interactable {
+                Sense::click() // allow clicks to bring to front
+            } else {
+                Sense::hover()
+            };
+
+            let move_response = ctx.interact(
+                Rect::EVERYTHING,
+                ctx.style().spacing.item_spacing,
+                layer_id,
+                interact_id,
+                state.rect(),
+                sense,
+                enabled,
+            );
+
+            // Important check - don't try to move e.g. a combobox popup!
+            if movable {
+                if move_response.dragged() {
+                    state.pivot_pos += ctx.input(|i| i.pointer.delta());
+                }
+
+                state.set_left_top_pos(
+                    ctx.constrain_window_rect_to_area(state.rect(), drag_bounds)
+                        .min,
+                );
+            }
+
+            if (move_response.dragged() || move_response.clicked())
+                || pointer_pressed_on_area(ctx, layer_id)
+                || !ctx.memory(|m| m.areas.visible_last_frame(&layer_id))
+            {
+                ctx.memory_mut(|m| m.areas.move_to_top(layer_id));
+                ctx.request_repaint();
+            }
+
+            move_response
+        };
+
+        state.set_left_top_pos(ctx.round_pos_to_pixels(state.left_top_pos()));
+
+        if constrain {
+            state.set_left_top_pos(
+                ctx.constrain_window_rect_to_area(state.rect(), drag_bounds)
+                    .left_top(),
+            );
+        }
+
+        Prepared {
+            layer_id,
+            state,
+            move_response,
+            enabled,
+            drag_bounds,
+            temporarily_invisible: is_new,
+        }
+    }
+
+    pub fn show_open_close_animation(&self, ctx: &Context, frame: &Frame, is_open: bool) {
+        // must be called first so animation managers know the latest state
+        let visibility_factor = ctx.animate_bool(self.id.with("close_animation"), is_open);
+
+        if is_open {
+            // we actually only show close animations.
+            // when opening a window we show it right away.
+            return;
+        }
+        if visibility_factor <= 0.0 {
+            return;
+        }
+
+        let layer_id = LayerId::new(self.order, self.id);
+        let area_rect = ctx.memory(|mem| mem.areas.get(self.id).map(|area| area.rect()));
+        if let Some(area_rect) = area_rect {
+            let clip_rect = ctx.available_rect();
+            let painter = Painter::new(ctx.clone(), layer_id, clip_rect);
+
+            // shrinkage: looks kinda a bad on its own
+            // let area_rect =
+            //     Rect::from_center_size(area_rect.center(), visibility_factor * area_rect.size());
+
+            let frame = frame.multiply_with_opacity(visibility_factor);
+            painter.add(frame.paint(area_rect));
+        }
+    }
+}
+
+impl Prepared {
+    pub(crate) fn state(&self) -> &State {
+        &self.state
+    }
+
+    pub(crate) fn state_mut(&mut self) -> &mut State {
+        &mut self.state
+    }
+
+    pub(crate) fn drag_bounds(&self) -> Option<Rect> {
+        self.drag_bounds
+    }
+
+    pub(crate) fn content_ui(&self, ctx: &Context) -> Ui {
+        let screen_rect = ctx.screen_rect();
+
+        let bounds = if let Some(bounds) = self.drag_bounds {
+            bounds.intersect(screen_rect) // protect against infinite bounds
+        } else {
+            let central_area = ctx.available_rect();
+
+            let is_within_central_area = central_area.contains_rect(self.state.rect().shrink(1.0));
+            if is_within_central_area {
+                central_area // let's try to not cover side panels
+            } else {
+                screen_rect
+            }
+        };
+
+        let max_rect = Rect::from_min_max(
+            self.state.left_top_pos(),
+            bounds
+                .max
+                .at_least(self.state.left_top_pos() + Vec2::splat(32.0)),
+        );
+
+        let shadow_radius = ctx.style().visuals.window_shadow.extrusion; // hacky
+        let clip_rect_margin = ctx.style().visuals.clip_rect_margin.max(shadow_radius);
+
+        let clip_rect = Rect::from_min_max(self.state.left_top_pos(), bounds.max)
+            .expand(clip_rect_margin)
+            .intersect(bounds);
+
+        let mut ui = Ui::new(
+            ctx.clone(),
+            self.layer_id,
+            self.layer_id.id,
+            max_rect,
+            clip_rect,
+        );
+        ui.set_enabled(self.enabled);
+        ui.set_visible(!self.temporarily_invisible);
+        ui
+    }
+
+    #[allow(clippy::needless_pass_by_value)] // intentional to swallow up `content_ui`.
+    pub(crate) fn end(self, ctx: &Context, content_ui: Ui) -> Response {
+        let Prepared {
+            layer_id,
+            mut state,
+            move_response,
+            enabled: _,
+            drag_bounds: _,
+            temporarily_invisible: _,
+        } = self;
+
+        state.size = content_ui.min_rect().size();
+
+        ctx.memory_mut(|m| m.areas.set_state(layer_id, state));
+
+        move_response
+    }
+}
+
+fn pointer_pressed_on_area(ctx: &Context, layer_id: LayerId) -> bool {
+    if let Some(pointer_pos) = ctx.pointer_interact_pos() {
+        let any_pressed = ctx.input(|i| i.pointer.any_pressed());
+        any_pressed && ctx.layer_id_at(pointer_pos) == Some(layer_id)
+    } else {
+        false
+    }
+}
+
+fn automatic_area_position(ctx: &Context) -> Pos2 {
+    let mut existing: Vec<Rect> = ctx.memory(|mem| {
+        mem.areas
+            .visible_windows()
+            .into_iter()
+            .map(State::rect)
+            .collect()
+    });
+    existing.sort_by_key(|r| r.left().round() as i32);
+
+    let available_rect = ctx.available_rect();
+
+    let spacing = 16.0;
+    let left = available_rect.left() + spacing;
+    let top = available_rect.top() + spacing;
+
+    if existing.is_empty() {
+        return pos2(left, top);
+    }
+
+    // Separate existing rectangles into columns:
+    let mut column_bbs = vec![existing[0]];
+
+    for &rect in &existing {
+        let current_column_bb = column_bbs.last_mut().unwrap();
+        if rect.left() < current_column_bb.right() {
+            // same column
+            *current_column_bb = current_column_bb.union(rect);
+        } else {
+            // new column
+            column_bbs.push(rect);
+        }
+    }
+
+    {
+        // Look for large spaces between columns (empty columns):
+        let mut x = left;
+        for col_bb in &column_bbs {
+            let available = col_bb.left() - x;
+            if available >= 300.0 {
+                return pos2(x, top);
+            }
+            x = col_bb.right() + spacing;
+        }
+    }
+
+    // Find first column with some available space at the bottom of it:
+    for col_bb in &column_bbs {
+        if col_bb.bottom() < available_rect.center().y {
+            return pos2(col_bb.left(), col_bb.bottom() + spacing);
+        }
+    }
+
+    // Maybe we can fit a new column?
+    let rightmost = column_bbs.last().unwrap().right();
+    if rightmost + 200.0 < available_rect.right() {
+        return pos2(rightmost + spacing, top);
+    }
+
+    // Ok, just put us in the column with the most space at the bottom:
+    let mut best_pos = pos2(left, column_bbs[0].bottom() + spacing);
+    for col_bb in &column_bbs {
+        let col_pos = pos2(col_bb.left(), col_bb.bottom() + spacing);
+        if col_pos.y < best_pos.y {
+            best_pos = col_pos;
+        }
+    }
+    best_pos
+}
diff --git a/egui/crates/egui/src/containers/collapsing_header.rs b/egui/crates/egui/src/containers/collapsing_header.rs
new file mode 100644
index 0000000..00f4ff7
--- /dev/null
+++ b/egui/crates/egui/src/containers/collapsing_header.rs
@@ -0,0 +1,681 @@
+use std::hash::Hash;
+
+use crate::*;
+use epaint::Shape;
+
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) struct InnerState {
+    open: bool,
+
+    /// Height of the region when open. Used for animations
+    #[cfg_attr(feature = "serde", serde(default))]
+    open_height: Option<f32>,
+}
+
+/// This is a a building block for building collapsing regions.
+///
+/// It is used by [`CollapsingHeader`] and [`Window`], but can also be used on its own.
+///
+/// See [`CollapsingState::show_header`] for how to show a collapsing header with a custom header.
+#[derive(Clone, Debug)]
+pub struct CollapsingState {
+    id: Id,
+    state: InnerState,
+}
+
+impl CollapsingState {
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        ctx.data_mut(|d| {
+            d.get_persisted::<InnerState>(id)
+                .map(|state| Self { id, state })
+        })
+    }
+
+    pub fn store(&self, ctx: &Context) {
+        ctx.data_mut(|d| d.insert_persisted(self.id, self.state));
+    }
+
+    pub fn id(&self) -> Id {
+        self.id
+    }
+
+    pub fn load_with_default_open(ctx: &Context, id: Id, default_open: bool) -> Self {
+        Self::load(ctx, id).unwrap_or(CollapsingState {
+            id,
+            state: InnerState {
+                open: default_open,
+                open_height: None,
+            },
+        })
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.state.open
+    }
+
+    pub fn set_open(&mut self, open: bool) {
+        self.state.open = open;
+    }
+
+    pub fn toggle(&mut self, ui: &Ui) {
+        self.state.open = !self.state.open;
+        ui.ctx().request_repaint();
+    }
+
+    /// 0 for closed, 1 for open, with tweening
+    pub fn openness(&self, ctx: &Context) -> f32 {
+        if ctx.memory(|mem| mem.everything_is_visible()) {
+            1.0
+        } else {
+            ctx.animate_bool(self.id, self.state.open)
+        }
+    }
+
+    /// Will toggle when clicked, etc.
+    pub(crate) fn show_default_button_with_size(
+        &mut self,
+        ui: &mut Ui,
+        button_size: Vec2,
+    ) -> Response {
+        let (_id, rect) = ui.allocate_space(button_size);
+        let response = ui.interact(rect, self.id, Sense::click());
+        if response.clicked() {
+            self.toggle(ui);
+        }
+        let openness = self.openness(ui.ctx());
+        paint_default_icon(ui, openness, &response);
+        response
+    }
+
+    /// Will toggle when clicked, etc.
+    fn show_default_button_indented(&mut self, ui: &mut Ui) -> Response {
+        self.show_button_indented(ui, paint_default_icon)
+    }
+
+    /// Will toggle when clicked, etc.
+    fn show_button_indented(
+        &mut self,
+        ui: &mut Ui,
+        icon_fn: impl FnOnce(&mut Ui, f32, &Response) + 'static,
+    ) -> Response {
+        let size = vec2(ui.spacing().indent, ui.spacing().icon_width);
+        let (_id, rect) = ui.allocate_space(size);
+        let response = ui.interact(rect, self.id, Sense::click());
+        if response.clicked() {
+            self.toggle(ui);
+        }
+
+        let (mut icon_rect, _) = ui.spacing().icon_rectangles(response.rect);
+        icon_rect.set_center(pos2(
+            response.rect.left() + ui.spacing().indent / 2.0,
+            response.rect.center().y,
+        ));
+        let openness = self.openness(ui.ctx());
+        let small_icon_response = response.clone().with_new_rect(icon_rect);
+        icon_fn(ui, openness, &small_icon_response);
+        response
+    }
+
+    /// Shows header and body (if expanded).
+    ///
+    /// The header will start with the default button in a horizontal layout, followed by whatever you add.
+    ///
+    /// Will also store the state.
+    ///
+    /// Returns the response of the collapsing button, the custom header, and the custom body.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// let id = ui.make_persistent_id("my_collapsing_header");
+    /// egui::collapsing_header::CollapsingState::load_with_default_open(ui.ctx(), id, false)
+    ///     .show_header(ui, |ui| {
+    ///         ui.label("Header"); // you can put checkboxes or whatever here
+    ///     })
+    ///     .body(|ui| ui.label("Body"));
+    /// # });
+    /// ```
+    pub fn show_header<HeaderRet>(
+        mut self,
+        ui: &mut Ui,
+        add_header: impl FnOnce(&mut Ui) -> HeaderRet,
+    ) -> HeaderResponse<'_, HeaderRet> {
+        let header_response = ui.horizontal(|ui| {
+            let prev_item_spacing = ui.spacing_mut().item_spacing;
+            ui.spacing_mut().item_spacing.x = 0.0; // the toggler button uses the full indent width
+            let collapser = self.show_default_button_indented(ui);
+            ui.spacing_mut().item_spacing = prev_item_spacing;
+            (collapser, add_header(ui))
+        });
+        HeaderResponse {
+            state: self,
+            ui,
+            toggle_button_response: header_response.inner.0,
+            header_response: InnerResponse {
+                response: header_response.response,
+                inner: header_response.inner.1,
+            },
+        }
+    }
+
+    /// Show body if we are open, with a nice animation between closed and open.
+    /// Indent the body to show it belongs to the header.
+    ///
+    /// Will also store the state.
+    pub fn show_body_indented<R>(
+        &mut self,
+        header_response: &Response,
+        ui: &mut Ui,
+        add_body: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let id = self.id;
+        self.show_body_unindented(ui, |ui| {
+            ui.indent(id, |ui| {
+                // make as wide as the header:
+                ui.expand_to_include_x(header_response.rect.right());
+                add_body(ui)
+            })
+            .inner
+        })
+    }
+
+    /// Show body if we are open, with a nice animation between closed and open.
+    /// Will also store the state.
+    pub fn show_body_unindented<R>(
+        &mut self,
+        ui: &mut Ui,
+        add_body: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let openness = self.openness(ui.ctx());
+        if openness <= 0.0 {
+            self.store(ui.ctx()); // we store any earlier toggling as promised in the docstring
+            None
+        } else if openness < 1.0 {
+            Some(ui.scope(|child_ui| {
+                let max_height = if self.state.open && self.state.open_height.is_none() {
+                    // First frame of expansion.
+                    // We don't know full height yet, but we will next frame.
+                    // Just use a placeholder value that shows some movement:
+                    10.0
+                } else {
+                    let full_height = self.state.open_height.unwrap_or_default();
+                    remap_clamp(openness, 0.0..=1.0, 0.0..=full_height)
+                };
+
+                let mut clip_rect = child_ui.clip_rect();
+                clip_rect.max.y = clip_rect.max.y.min(child_ui.max_rect().top() + max_height);
+                child_ui.set_clip_rect(clip_rect);
+
+                let ret = add_body(child_ui);
+
+                let mut min_rect = child_ui.min_rect();
+                self.state.open_height = Some(min_rect.height());
+                self.store(child_ui.ctx()); // remember the height
+
+                // Pretend children took up at most `max_height` space:
+                min_rect.max.y = min_rect.max.y.at_most(min_rect.top() + max_height);
+                child_ui.force_set_min_rect(min_rect);
+                ret
+            }))
+        } else {
+            let ret_response = ui.scope(add_body);
+            let full_size = ret_response.response.rect.size();
+            self.state.open_height = Some(full_size.y);
+            self.store(ui.ctx()); // remember the height
+            Some(ret_response)
+        }
+    }
+
+    /// Paint this [CollapsingState](CollapsingState)'s toggle button. Takes an [IconPainter](IconPainter) as the icon.
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// fn circle_icon(ui: &mut egui::Ui, openness: f32, response: &egui::Response) {
+    ///     let stroke = ui.style().interact(&response).fg_stroke;
+    ///     let radius = egui::lerp(2.0..=3.0, openness);
+    ///     ui.painter().circle_filled(response.rect.center(), radius, stroke.color);
+    /// }
+    ///
+    /// let mut state = egui::collapsing_header::CollapsingState::load_with_default_open(
+    ///     ui.ctx(),
+    ///     ui.make_persistent_id("my_collapsing_state"),
+    ///     false,
+    /// );
+    ///
+    /// let header_res = ui.horizontal(|ui| {
+    ///     ui.label("Header");
+    ///     state.show_toggle_button(ui, circle_icon);
+    /// });
+    ///
+    /// state.show_body_indented(&header_res.response, ui, |ui| ui.label("Body"));
+    /// # });
+    /// ```
+    pub fn show_toggle_button(
+        &mut self,
+        ui: &mut Ui,
+        icon_fn: impl FnOnce(&mut Ui, f32, &Response) + 'static,
+    ) -> Response {
+        self.show_button_indented(ui, icon_fn)
+    }
+}
+
+/// From [`CollapsingState::show_header`].
+#[must_use = "Remember to show the body"]
+pub struct HeaderResponse<'ui, HeaderRet> {
+    state: CollapsingState,
+    ui: &'ui mut Ui,
+    toggle_button_response: Response,
+    header_response: InnerResponse<HeaderRet>,
+}
+
+impl<'ui, HeaderRet> HeaderResponse<'ui, HeaderRet> {
+    /// Returns the response of the collapsing button, the custom header, and the custom body.
+    pub fn body<BodyRet>(
+        mut self,
+        add_body: impl FnOnce(&mut Ui) -> BodyRet,
+    ) -> (
+        Response,
+        InnerResponse<HeaderRet>,
+        Option<InnerResponse<BodyRet>>,
+    ) {
+        let body_response =
+            self.state
+                .show_body_indented(&self.header_response.response, self.ui, add_body);
+        (
+            self.toggle_button_response,
+            self.header_response,
+            body_response,
+        )
+    }
+
+    /// Returns the response of the collapsing button, the custom header, and the custom body, without indentation.
+    pub fn body_unindented<BodyRet>(
+        mut self,
+        add_body: impl FnOnce(&mut Ui) -> BodyRet,
+    ) -> (
+        Response,
+        InnerResponse<HeaderRet>,
+        Option<InnerResponse<BodyRet>>,
+    ) {
+        let body_response = self.state.show_body_unindented(self.ui, add_body);
+        (
+            self.toggle_button_response,
+            self.header_response,
+            body_response,
+        )
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Paint the arrow icon that indicated if the region is open or not
+pub fn paint_default_icon(ui: &mut Ui, openness: f32, response: &Response) {
+    let visuals = ui.style().interact(response);
+
+    let rect = response.rect;
+
+    // Draw a pointy triangle arrow:
+    let rect = Rect::from_center_size(rect.center(), vec2(rect.width(), rect.height()) * 0.75);
+    let rect = rect.expand(visuals.expansion);
+    let mut points = vec![rect.left_top(), rect.right_top(), rect.center_bottom()];
+    use std::f32::consts::TAU;
+    let rotation = emath::Rot2::from_angle(remap(openness, 0.0..=1.0, -TAU / 4.0..=0.0));
+    for p in &mut points {
+        *p = rect.center() + rotation * (*p - rect.center());
+    }
+
+    ui.painter().add(Shape::convex_polygon(
+        points,
+        visuals.fg_stroke.color,
+        Stroke::NONE,
+    ));
+}
+
+/// A function that paints an icon indicating if the region is open or not
+pub type IconPainter = Box<dyn FnOnce(&mut Ui, f32, &Response)>;
+
+/// A header which can be collapsed/expanded, revealing a contained [`Ui`] region.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// egui::CollapsingHeader::new("Heading")
+///     .show(ui, |ui| {
+///         ui.label("Body");
+///     });
+///
+/// // Short version:
+/// ui.collapsing("Heading", |ui| { ui.label("Body"); });
+/// # });
+/// ```
+///
+/// If you want to customize the header contents, see [`CollapsingState::show_header`].
+#[must_use = "You should call .show()"]
+pub struct CollapsingHeader {
+    text: WidgetText,
+    default_open: bool,
+    open: Option<bool>,
+    id_source: Id,
+    enabled: bool,
+    selectable: bool,
+    selected: bool,
+    show_background: bool,
+    icon: Option<IconPainter>,
+}
+
+impl CollapsingHeader {
+    /// The [`CollapsingHeader`] starts out collapsed unless you call `default_open`.
+    ///
+    /// The label is used as an [`Id`] source.
+    /// If the label is unique and static this is fine,
+    /// but if it changes or there are several [`CollapsingHeader`] with the same title
+    /// you need to provide a unique id source with [`Self::id_source`].
+    pub fn new(text: impl Into<WidgetText>) -> Self {
+        let text = text.into();
+        let id_source = Id::new(text.text());
+        Self {
+            text,
+            default_open: false,
+            open: None,
+            id_source,
+            enabled: true,
+            selectable: false,
+            selected: false,
+            show_background: false,
+            icon: None,
+        }
+    }
+
+    /// By default, the [`CollapsingHeader`] is collapsed.
+    /// Call `.default_open(true)` to change this.
+    pub fn default_open(mut self, open: bool) -> Self {
+        self.default_open = open;
+        self
+    }
+
+    /// Calling `.open(Some(true))` will make the collapsing header open this frame (or stay open).
+    ///
+    /// Calling `.open(Some(false))` will make the collapsing header close this frame (or stay closed).
+    ///
+    /// Calling `.open(None)` has no effect (default).
+    pub fn open(mut self, open: Option<bool>) -> Self {
+        self.open = open;
+        self
+    }
+
+    /// Explicitly set the source of the [`Id`] of this widget, instead of using title label.
+    /// This is useful if the title label is dynamic or not unique.
+    pub fn id_source(mut self, id_source: impl Hash) -> Self {
+        self.id_source = Id::new(id_source);
+        self
+    }
+
+    /// If you set this to `false`, the [`CollapsingHeader`] will be grayed out and un-clickable.
+    ///
+    /// This is a convenience for [`Ui::set_enabled`].
+    pub fn enabled(mut self, enabled: bool) -> Self {
+        self.enabled = enabled;
+        self
+    }
+
+    /// Can the [`CollapsingHeader`] be selected by clicking it? Default: `false`.
+    #[deprecated = "Use the more powerful egui::collapsing_header::CollapsingState::show_header"] // Deprecated in 2022-04-28, before egui 0.18
+    pub fn selectable(mut self, selectable: bool) -> Self {
+        self.selectable = selectable;
+        self
+    }
+
+    /// If you set this to 'true', the [`CollapsingHeader`] will be shown as selected.
+    ///
+    /// Example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// let mut selected = false;
+    /// let response = egui::CollapsingHeader::new("Select and open me")
+    ///     .selectable(true)
+    ///     .selected(selected)
+    ///     .show(ui, |ui| ui.label("Body"));
+    /// if response.header_response.clicked() {
+    ///     selected = true;
+    /// }
+    /// # });
+    /// ```
+    #[deprecated = "Use the more powerful egui::collapsing_header::CollapsingState::show_header"] // Deprecated in 2022-04-28, before egui 0.18
+    pub fn selected(mut self, selected: bool) -> Self {
+        self.selected = selected;
+        self
+    }
+
+    /// Should the [`CollapsingHeader`] show a background behind it? Default: `false`.
+    ///
+    /// To show it behind all [`CollapsingHeader`] you can just use:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.visuals_mut().collapsing_header_frame = true;
+    /// # });
+    /// ```
+    pub fn show_background(mut self, show_background: bool) -> Self {
+        self.show_background = show_background;
+        self
+    }
+
+    /// Use the provided function to render a different [`CollapsingHeader`] icon.
+    /// Defaults to a triangle that animates as the [`CollapsingHeader`] opens and closes.
+    ///
+    /// For example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// fn circle_icon(ui: &mut egui::Ui, openness: f32, response: &egui::Response) {
+    ///     let stroke = ui.style().interact(&response).fg_stroke;
+    ///     let radius = egui::lerp(2.0..=3.0, openness);
+    ///     ui.painter().circle_filled(response.rect.center(), radius, stroke.color);
+    /// }
+    ///
+    /// egui::CollapsingHeader::new("Circles")
+    ///   .icon(circle_icon)
+    ///   .show(ui, |ui| { ui.label("Hi!"); });
+    /// # });
+    /// ```
+    pub fn icon(mut self, icon_fn: impl FnOnce(&mut Ui, f32, &Response) + 'static) -> Self {
+        self.icon = Some(Box::new(icon_fn));
+        self
+    }
+}
+
+struct Prepared {
+    header_response: Response,
+    state: CollapsingState,
+    openness: f32,
+}
+
+impl CollapsingHeader {
+    fn begin(self, ui: &mut Ui) -> Prepared {
+        assert!(
+            ui.layout().main_dir().is_vertical(),
+            "Horizontal collapsing is unimplemented"
+        );
+        let Self {
+            icon,
+            text,
+            default_open,
+            open,
+            id_source,
+            enabled: _,
+            selectable,
+            selected,
+            show_background,
+        } = self;
+
+        // TODO(emilk): horizontal layout, with icon and text as labels. Insert background behind using Frame.
+
+        let id = ui.make_persistent_id(id_source);
+        let button_padding = ui.spacing().button_padding;
+
+        let available = ui.available_rect_before_wrap();
+        let text_pos = available.min + vec2(ui.spacing().indent, 0.0);
+        let wrap_width = available.right() - text_pos.x;
+        let wrap = Some(false);
+        let text = text.into_galley(ui, wrap, wrap_width, TextStyle::Button);
+        let text_max_x = text_pos.x + text.size().x;
+
+        let mut desired_width = text_max_x + button_padding.x - available.left();
+        if ui.visuals().collapsing_header_frame {
+            desired_width = desired_width.max(available.width()); // fill full width
+        }
+
+        let mut desired_size = vec2(desired_width, text.size().y + 2.0 * button_padding.y);
+        desired_size = desired_size.at_least(ui.spacing().interact_size);
+        let (_, rect) = ui.allocate_space(desired_size);
+
+        let mut header_response = ui.interact(rect, id, Sense::click());
+        let text_pos = pos2(
+            text_pos.x,
+            header_response.rect.center().y - text.size().y / 2.0,
+        );
+
+        let mut state = CollapsingState::load_with_default_open(ui.ctx(), id, default_open);
+        if let Some(open) = open {
+            if open != state.is_open() {
+                state.toggle(ui);
+                header_response.mark_changed();
+            }
+        } else if header_response.clicked() {
+            state.toggle(ui);
+            header_response.mark_changed();
+        }
+
+        header_response
+            .widget_info(|| WidgetInfo::labeled(WidgetType::CollapsingHeader, text.text()));
+
+        let openness = state.openness(ui.ctx());
+
+        if ui.is_rect_visible(rect) {
+            let visuals = ui.style().interact_selectable(&header_response, selected);
+
+            if ui.visuals().collapsing_header_frame || show_background {
+                ui.painter().add(epaint::RectShape {
+                    rect: header_response.rect.expand(visuals.expansion),
+                    rounding: visuals.rounding,
+                    fill: visuals.weak_bg_fill,
+                    stroke: visuals.bg_stroke,
+                    // stroke: Default::default(),
+                });
+            }
+
+            if selected || selectable && (header_response.hovered() || header_response.has_focus())
+            {
+                let rect = rect.expand(visuals.expansion);
+
+                ui.painter()
+                    .rect(rect, visuals.rounding, visuals.bg_fill, visuals.bg_stroke);
+            }
+
+            {
+                let (mut icon_rect, _) = ui.spacing().icon_rectangles(header_response.rect);
+                icon_rect.set_center(pos2(
+                    header_response.rect.left() + ui.spacing().indent / 2.0,
+                    header_response.rect.center().y,
+                ));
+                let icon_response = header_response.clone().with_new_rect(icon_rect);
+                if let Some(icon) = icon {
+                    icon(ui, openness, &icon_response);
+                } else {
+                    paint_default_icon(ui, openness, &icon_response);
+                }
+            }
+
+            text.paint_with_visuals(ui.painter(), text_pos, &visuals);
+        }
+
+        Prepared {
+            header_response,
+            state,
+            openness,
+        }
+    }
+
+    #[inline]
+    pub fn show<R>(
+        self,
+        ui: &mut Ui,
+        add_body: impl FnOnce(&mut Ui) -> R,
+    ) -> CollapsingResponse<R> {
+        self.show_dyn(ui, Box::new(add_body), true)
+    }
+
+    #[inline]
+    pub fn show_unindented<R>(
+        self,
+        ui: &mut Ui,
+        add_body: impl FnOnce(&mut Ui) -> R,
+    ) -> CollapsingResponse<R> {
+        self.show_dyn(ui, Box::new(add_body), false)
+    }
+
+    fn show_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_body: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+        indented: bool,
+    ) -> CollapsingResponse<R> {
+        // Make sure body is bellow header,
+        // and make sure it is one unit (necessary for putting a [`CollapsingHeader`] in a grid).
+        ui.vertical(|ui| {
+            ui.set_enabled(self.enabled);
+
+            let Prepared {
+                header_response,
+                mut state,
+                openness,
+            } = self.begin(ui); // show the header
+
+            let ret_response = if indented {
+                state.show_body_indented(&header_response, ui, add_body)
+            } else {
+                state.show_body_unindented(ui, add_body)
+            };
+
+            if let Some(ret_response) = ret_response {
+                CollapsingResponse {
+                    header_response,
+                    body_response: Some(ret_response.response),
+                    body_returned: Some(ret_response.inner),
+                    openness,
+                }
+            } else {
+                CollapsingResponse {
+                    header_response,
+                    body_response: None,
+                    body_returned: None,
+                    openness,
+                }
+            }
+        })
+        .inner
+    }
+}
+
+/// The response from showing a [`CollapsingHeader`].
+pub struct CollapsingResponse<R> {
+    /// Response of the actual clickable header.
+    pub header_response: Response,
+
+    /// None iff collapsed.
+    pub body_response: Option<Response>,
+
+    /// None iff collapsed.
+    pub body_returned: Option<R>,
+
+    /// 0.0 if fully closed, 1.0 if fully open, and something in-between while animating.
+    pub openness: f32,
+}
+
+impl<R> CollapsingResponse<R> {
+    /// Was the [`CollapsingHeader`] fully closed (and not being animated)?
+    pub fn fully_closed(&self) -> bool {
+        self.openness <= 0.0
+    }
+
+    /// Was the [`CollapsingHeader`] fully open (and not being animated)?
+    pub fn fully_open(&self) -> bool {
+        self.openness >= 1.0
+    }
+}
diff --git a/egui/crates/egui/src/containers/combo_box.rs b/egui/crates/egui/src/containers/combo_box.rs
new file mode 100644
index 0000000..7bc12c7
--- /dev/null
+++ b/egui/crates/egui/src/containers/combo_box.rs
@@ -0,0 +1,429 @@
+use epaint::Shape;
+
+use crate::{style::WidgetVisuals, *};
+
+/// Indicate whether or not a popup will be shown above or below the box.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AboveOrBelow {
+    Above,
+    Below,
+}
+
+/// A function that paints the [`ComboBox`] icon
+pub type IconPainter = Box<dyn FnOnce(&Ui, Rect, &WidgetVisuals, bool, AboveOrBelow)>;
+
+/// A drop-down selection menu with a descriptive label.
+///
+/// ```
+/// # #[derive(Debug, PartialEq)]
+/// # enum Enum { First, Second, Third }
+/// # let mut selected = Enum::First;
+/// # egui::__run_test_ui(|ui| {
+/// egui::ComboBox::from_label("Select one!")
+///     .selected_text(format!("{:?}", selected))
+///     .show_ui(ui, |ui| {
+///         ui.selectable_value(&mut selected, Enum::First, "First");
+///         ui.selectable_value(&mut selected, Enum::Second, "Second");
+///         ui.selectable_value(&mut selected, Enum::Third, "Third");
+///     }
+/// );
+/// # });
+/// ```
+#[must_use = "You should call .show*"]
+pub struct ComboBox {
+    id_source: Id,
+    label: Option<WidgetText>,
+    selected_text: WidgetText,
+    width: Option<f32>,
+    icon: Option<IconPainter>,
+    wrap_enabled: bool,
+}
+
+impl ComboBox {
+    /// Create new [`ComboBox`] with id and label
+    pub fn new(id_source: impl std::hash::Hash, label: impl Into<WidgetText>) -> Self {
+        Self {
+            id_source: Id::new(id_source),
+            label: Some(label.into()),
+            selected_text: Default::default(),
+            width: None,
+            icon: None,
+            wrap_enabled: false,
+        }
+    }
+
+    /// Label shown next to the combo box
+    pub fn from_label(label: impl Into<WidgetText>) -> Self {
+        let label = label.into();
+        Self {
+            id_source: Id::new(label.text()),
+            label: Some(label),
+            selected_text: Default::default(),
+            width: None,
+            icon: None,
+            wrap_enabled: false,
+        }
+    }
+
+    /// Without label.
+    pub fn from_id_source(id_source: impl std::hash::Hash) -> Self {
+        Self {
+            id_source: Id::new(id_source),
+            label: Default::default(),
+            selected_text: Default::default(),
+            width: None,
+            icon: None,
+            wrap_enabled: false,
+        }
+    }
+
+    /// Set the outer width of the button and menu.
+    pub fn width(mut self, width: f32) -> Self {
+        self.width = Some(width);
+        self
+    }
+
+    /// What we show as the currently selected value
+    pub fn selected_text(mut self, selected_text: impl Into<WidgetText>) -> Self {
+        self.selected_text = selected_text.into();
+        self
+    }
+
+    /// Use the provided function to render a different [`ComboBox`] icon.
+    /// Defaults to a triangle that expands when the cursor is hovering over the [`ComboBox`].
+    ///
+    /// For example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let text = "Selected text";
+    /// pub fn filled_triangle(
+    ///     ui: &egui::Ui,
+    ///     rect: egui::Rect,
+    ///     visuals: &egui::style::WidgetVisuals,
+    ///     _is_open: bool,
+    ///     _above_or_below: egui::AboveOrBelow,
+    /// ) {
+    ///     let rect = egui::Rect::from_center_size(
+    ///         rect.center(),
+    ///         egui::vec2(rect.width() * 0.6, rect.height() * 0.4),
+    ///     );
+    ///     ui.painter().add(egui::Shape::convex_polygon(
+    ///         vec![rect.left_top(), rect.right_top(), rect.center_bottom()],
+    ///         visuals.fg_stroke.color,
+    ///         visuals.fg_stroke,
+    ///     ));
+    /// }
+    ///
+    /// egui::ComboBox::from_id_source("my-combobox")
+    ///     .selected_text(text)
+    ///     .icon(filled_triangle)
+    ///     .show_ui(ui, |_ui| {});
+    /// # });
+    /// ```
+    pub fn icon(
+        mut self,
+        icon_fn: impl FnOnce(&Ui, Rect, &WidgetVisuals, bool, AboveOrBelow) + 'static,
+    ) -> Self {
+        self.icon = Some(Box::new(icon_fn));
+        self
+    }
+
+    /// Controls whether text wrap is used for the selected text
+    pub fn wrap(mut self, wrap: bool) -> Self {
+        self.wrap_enabled = wrap;
+        self
+    }
+
+    /// Show the combo box, with the given ui code for the menu contents.
+    ///
+    /// Returns `InnerResponse { inner: None }` if the combo box is closed.
+    pub fn show_ui<R>(
+        self,
+        ui: &mut Ui,
+        menu_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<Option<R>> {
+        self.show_ui_dyn(ui, Box::new(menu_contents))
+    }
+
+    fn show_ui_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        menu_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<Option<R>> {
+        let Self {
+            id_source,
+            label,
+            selected_text,
+            width,
+            icon,
+            wrap_enabled,
+        } = self;
+
+        let button_id = ui.make_persistent_id(id_source);
+
+        ui.horizontal(|ui| {
+            let mut ir = combo_box_dyn(
+                ui,
+                button_id,
+                selected_text,
+                menu_contents,
+                icon,
+                wrap_enabled,
+                width,
+            );
+            if let Some(label) = label {
+                ir.response
+                    .widget_info(|| WidgetInfo::labeled(WidgetType::ComboBox, label.text()));
+                ir.response |= ui.label(label);
+            } else {
+                ir.response
+                    .widget_info(|| WidgetInfo::labeled(WidgetType::ComboBox, ""));
+            }
+            ir
+        })
+        .inner
+    }
+
+    /// Show a list of items with the given selected index.
+    ///
+    ///
+    /// ```
+    /// # #[derive(Debug, PartialEq)]
+    /// # enum Enum { First, Second, Third }
+    /// # let mut selected = Enum::First;
+    /// # egui::__run_test_ui(|ui| {
+    /// let alternatives = ["a", "b", "c", "d"];
+    /// let mut selected = 2;
+    /// egui::ComboBox::from_label("Select one!").show_index(
+    ///     ui,
+    ///     &mut selected,
+    ///     alternatives.len(),
+    ///     |i| alternatives[i]
+    /// );
+    /// # });
+    /// ```
+    pub fn show_index<Text: Into<WidgetText>>(
+        self,
+        ui: &mut Ui,
+        selected: &mut usize,
+        len: usize,
+        get: impl Fn(usize) -> Text,
+    ) -> Response {
+        let slf = self.selected_text(get(*selected));
+
+        let mut changed = false;
+
+        let mut response = slf
+            .show_ui(ui, |ui| {
+                for i in 0..len {
+                    if ui.selectable_label(i == *selected, get(i)).clicked() {
+                        *selected = i;
+                        changed = true;
+                    }
+                }
+            })
+            .response;
+
+        if changed {
+            response.mark_changed();
+        }
+        response
+    }
+}
+
+fn combo_box_dyn<'c, R>(
+    ui: &mut Ui,
+    button_id: Id,
+    selected_text: WidgetText,
+    menu_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    icon: Option<IconPainter>,
+    wrap_enabled: bool,
+    width: Option<f32>,
+) -> InnerResponse<Option<R>> {
+    let popup_id = button_id.with("popup");
+
+    let is_popup_open = ui.memory(|m| m.is_popup_open(popup_id));
+
+    let popup_height = ui.memory(|m| m.areas.get(popup_id).map_or(100.0, |state| state.size.y));
+
+    let above_or_below =
+        if ui.next_widget_position().y + ui.spacing().interact_size.y + popup_height
+            < ui.ctx().screen_rect().bottom()
+        {
+            AboveOrBelow::Below
+        } else {
+            AboveOrBelow::Above
+        };
+
+    let margin = ui.spacing().button_padding;
+    let button_response = button_frame(ui, button_id, is_popup_open, Sense::click(), |ui| {
+        let icon_spacing = ui.spacing().icon_spacing;
+        // We don't want to change width when user selects something new
+        let full_minimum_width = if wrap_enabled {
+            // Currently selected value's text will be wrapped if needed, so occupy the available width.
+            ui.available_width()
+        } else {
+            // Occupy at least the minimum width assigned to ComboBox.
+            let width = width.unwrap_or_else(|| ui.spacing().combo_width);
+            width - 2.0 * margin.x
+        };
+        let icon_size = Vec2::splat(ui.spacing().icon_width);
+        let wrap_width = if wrap_enabled {
+            // Use the available width, currently selected value's text will be wrapped if exceeds this value.
+            ui.available_width() - icon_spacing - icon_size.x
+        } else {
+            // Use all the width necessary to display the currently selected value's text.
+            f32::INFINITY
+        };
+
+        let galley =
+            selected_text.into_galley(ui, Some(wrap_enabled), wrap_width, TextStyle::Button);
+
+        // The width necessary to contain the whole widget with the currently selected value's text.
+        let width = if wrap_enabled {
+            full_minimum_width
+        } else {
+            // Occupy at least the minimum width needed to contain the widget with the currently selected value's text.
+            galley.size().x + icon_spacing + icon_size.x
+        };
+
+        // Case : wrap_enabled : occupy all the available width.
+        // Case : !wrap_enabled : occupy at least the minimum width assigned to Slider and ComboBox,
+        // increase if the currently selected value needs additional horizontal space to fully display its text (up to wrap_width (f32::INFINITY)).
+        let width = width.at_least(full_minimum_width);
+        let height = galley.size().y.max(icon_size.y);
+
+        let (_, rect) = ui.allocate_space(Vec2::new(width, height));
+        let button_rect = ui.min_rect().expand2(ui.spacing().button_padding);
+        let response = ui.interact(button_rect, button_id, Sense::click());
+        // response.active |= is_popup_open;
+
+        if ui.is_rect_visible(rect) {
+            let icon_rect = Align2::RIGHT_CENTER.align_size_within_rect(icon_size, rect);
+            let visuals = if is_popup_open {
+                &ui.visuals().widgets.open
+            } else {
+                ui.style().interact(&response)
+            };
+
+            if let Some(icon) = icon {
+                icon(
+                    ui,
+                    icon_rect.expand(visuals.expansion),
+                    visuals,
+                    is_popup_open,
+                    above_or_below,
+                );
+            } else {
+                paint_default_icon(
+                    ui.painter(),
+                    icon_rect.expand(visuals.expansion),
+                    visuals,
+                    above_or_below,
+                );
+            }
+
+            let text_rect = Align2::LEFT_CENTER.align_size_within_rect(galley.size(), rect);
+            galley.paint_with_visuals(ui.painter(), text_rect.min, visuals);
+        }
+    });
+
+    if button_response.clicked() {
+        ui.memory_mut(|mem| mem.toggle_popup(popup_id));
+    }
+    let inner = crate::popup::popup_above_or_below_widget(
+        ui,
+        popup_id,
+        &button_response,
+        above_or_below,
+        |ui| {
+            ScrollArea::vertical()
+                .max_height(ui.spacing().combo_height)
+                .show(ui, menu_contents)
+                .inner
+        },
+    );
+
+    InnerResponse {
+        inner,
+        response: button_response,
+    }
+}
+
+fn button_frame(
+    ui: &mut Ui,
+    id: Id,
+    is_popup_open: bool,
+    sense: Sense,
+    add_contents: impl FnOnce(&mut Ui),
+) -> Response {
+    let where_to_put_background = ui.painter().add(Shape::Noop);
+
+    let margin = ui.spacing().button_padding;
+    let interact_size = ui.spacing().interact_size;
+
+    let mut outer_rect = ui.available_rect_before_wrap();
+    outer_rect.set_height(outer_rect.height().at_least(interact_size.y));
+
+    let inner_rect = outer_rect.shrink2(margin);
+    let mut content_ui = ui.child_ui(inner_rect, *ui.layout());
+    add_contents(&mut content_ui);
+
+    let mut outer_rect = content_ui.min_rect().expand2(margin);
+    outer_rect.set_height(outer_rect.height().at_least(interact_size.y));
+
+    let response = ui.interact(outer_rect, id, sense);
+
+    if ui.is_rect_visible(outer_rect) {
+        let visuals = if is_popup_open {
+            &ui.visuals().widgets.open
+        } else {
+            ui.style().interact(&response)
+        };
+
+        ui.painter().set(
+            where_to_put_background,
+            epaint::RectShape {
+                rect: outer_rect.expand(visuals.expansion),
+                rounding: visuals.rounding,
+                fill: visuals.weak_bg_fill,
+                stroke: visuals.bg_stroke,
+            },
+        );
+    }
+
+    ui.advance_cursor_after_rect(outer_rect);
+
+    response
+}
+
+fn paint_default_icon(
+    painter: &Painter,
+    rect: Rect,
+    visuals: &WidgetVisuals,
+    above_or_below: AboveOrBelow,
+) {
+    let rect = Rect::from_center_size(
+        rect.center(),
+        vec2(rect.width() * 0.7, rect.height() * 0.45),
+    );
+
+    match above_or_below {
+        AboveOrBelow::Above => {
+            // Upward pointing triangle
+            painter.add(Shape::convex_polygon(
+                vec![rect.left_bottom(), rect.right_bottom(), rect.center_top()],
+                visuals.fg_stroke.color,
+                Stroke::NONE,
+            ));
+        }
+        AboveOrBelow::Below => {
+            // Downward pointing triangle
+            painter.add(Shape::convex_polygon(
+                vec![rect.left_top(), rect.right_top(), rect.center_bottom()],
+                visuals.fg_stroke.color,
+                Stroke::NONE,
+            ));
+        }
+    }
+}
diff --git a/egui/crates/egui/src/containers/frame.rs b/egui/crates/egui/src/containers/frame.rs
new file mode 100644
index 0000000..fa1caee
--- /dev/null
+++ b/egui/crates/egui/src/containers/frame.rs
@@ -0,0 +1,288 @@
+//! Frame container
+
+use crate::{layers::ShapeIdx, style::Margin, *};
+use epaint::*;
+
+/// Add a background, frame and/or margin to a rectangular background of a [`Ui`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// egui::Frame::none()
+///     .fill(egui::Color32::RED)
+///     .show(ui, |ui| {
+///         ui.label("Label with red background");
+///     });
+/// # });
+/// ```
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[must_use = "You should call .show()"]
+pub struct Frame {
+    /// Margin within the painted frame.
+    pub inner_margin: Margin,
+
+    /// Margin outside the painted frame.
+    pub outer_margin: Margin,
+
+    pub rounding: Rounding,
+
+    pub shadow: Shadow,
+
+    pub fill: Color32,
+
+    pub stroke: Stroke,
+}
+
+impl Frame {
+    pub fn none() -> Self {
+        Self::default()
+    }
+
+    /// For when you want to group a few widgets together within a frame.
+    pub fn group(style: &Style) -> Self {
+        Self {
+            inner_margin: Margin::same(6.0), // same and symmetric looks best in corners when nesting groups
+            rounding: style.visuals.widgets.noninteractive.rounding,
+            stroke: style.visuals.widgets.noninteractive.bg_stroke,
+            ..Default::default()
+        }
+    }
+
+    pub fn side_top_panel(style: &Style) -> Self {
+        Self {
+            inner_margin: Margin::symmetric(8.0, 2.0),
+            fill: style.visuals.panel_fill,
+            ..Default::default()
+        }
+    }
+
+    pub fn central_panel(style: &Style) -> Self {
+        Self {
+            inner_margin: Margin::same(8.0),
+            fill: style.visuals.panel_fill,
+            ..Default::default()
+        }
+    }
+
+    pub fn window(style: &Style) -> Self {
+        Self {
+            inner_margin: style.spacing.window_margin,
+            rounding: style.visuals.window_rounding,
+            shadow: style.visuals.window_shadow,
+            fill: style.visuals.window_fill(),
+            stroke: style.visuals.window_stroke(),
+            ..Default::default()
+        }
+    }
+
+    pub fn menu(style: &Style) -> Self {
+        Self {
+            inner_margin: style.spacing.menu_margin,
+            rounding: style.visuals.menu_rounding,
+            shadow: style.visuals.popup_shadow,
+            fill: style.visuals.window_fill(),
+            stroke: style.visuals.window_stroke(),
+            ..Default::default()
+        }
+    }
+
+    pub fn popup(style: &Style) -> Self {
+        Self {
+            inner_margin: style.spacing.menu_margin,
+            rounding: style.visuals.menu_rounding,
+            shadow: style.visuals.popup_shadow,
+            fill: style.visuals.window_fill(),
+            stroke: style.visuals.window_stroke(),
+            ..Default::default()
+        }
+    }
+
+    /// A canvas to draw on.
+    ///
+    /// In bright mode this will be very bright,
+    /// and in dark mode this will be very dark.
+    pub fn canvas(style: &Style) -> Self {
+        Self {
+            inner_margin: Margin::same(2.0),
+            rounding: style.visuals.widgets.noninteractive.rounding,
+            fill: style.visuals.extreme_bg_color,
+            stroke: style.visuals.window_stroke(),
+            ..Default::default()
+        }
+    }
+
+    /// A dark canvas to draw on.
+    pub fn dark_canvas(style: &Style) -> Self {
+        Self {
+            fill: Color32::from_black_alpha(250),
+            ..Self::canvas(style)
+        }
+    }
+}
+
+impl Frame {
+    #[inline]
+    pub fn fill(mut self, fill: Color32) -> Self {
+        self.fill = fill;
+        self
+    }
+
+    #[inline]
+    pub fn stroke(mut self, stroke: Stroke) -> Self {
+        self.stroke = stroke;
+        self
+    }
+
+    #[inline]
+    pub fn rounding(mut self, rounding: impl Into<Rounding>) -> Self {
+        self.rounding = rounding.into();
+        self
+    }
+
+    /// Margin within the painted frame.
+    #[inline]
+    pub fn inner_margin(mut self, inner_margin: impl Into<Margin>) -> Self {
+        self.inner_margin = inner_margin.into();
+        self
+    }
+
+    /// Margin outside the painted frame.
+    #[inline]
+    pub fn outer_margin(mut self, outer_margin: impl Into<Margin>) -> Self {
+        self.outer_margin = outer_margin.into();
+        self
+    }
+
+    #[deprecated = "Renamed inner_margin in egui 0.18"]
+    #[inline]
+    pub fn margin(self, margin: impl Into<Margin>) -> Self {
+        self.inner_margin(margin)
+    }
+
+    #[inline]
+    pub fn shadow(mut self, shadow: Shadow) -> Self {
+        self.shadow = shadow;
+        self
+    }
+
+    pub fn multiply_with_opacity(mut self, opacity: f32) -> Self {
+        self.fill = self.fill.linear_multiply(opacity);
+        self.stroke.color = self.stroke.color.linear_multiply(opacity);
+        self.shadow.color = self.shadow.color.linear_multiply(opacity);
+        self
+    }
+}
+
+impl Frame {
+    /// inner margin plus outer margin.
+    #[inline]
+    pub fn total_margin(&self) -> Margin {
+        self.inner_margin + self.outer_margin
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub struct Prepared {
+    pub frame: Frame,
+    where_to_put_background: ShapeIdx,
+    pub content_ui: Ui,
+}
+
+impl Frame {
+    pub fn begin(self, ui: &mut Ui) -> Prepared {
+        let where_to_put_background = ui.painter().add(Shape::Noop);
+        let outer_rect_bounds = ui.available_rect_before_wrap();
+
+        let mut inner_rect = outer_rect_bounds;
+        inner_rect.min += self.outer_margin.left_top() + self.inner_margin.left_top();
+        inner_rect.max -= self.outer_margin.right_bottom() + self.inner_margin.right_bottom();
+
+        // Make sure we don't shrink to the negative:
+        inner_rect.max.x = inner_rect.max.x.max(inner_rect.min.x);
+        inner_rect.max.y = inner_rect.max.y.max(inner_rect.min.y);
+
+        let content_ui = ui.child_ui(inner_rect, *ui.layout());
+
+        // content_ui.set_clip_rect(outer_rect_bounds.shrink(self.stroke.width * 0.5)); // Can't do this since we don't know final size yet
+
+        Prepared {
+            frame: self,
+            where_to_put_background,
+            content_ui,
+        }
+    }
+
+    pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        self.show_dyn(ui, Box::new(add_contents))
+    }
+
+    fn show_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let mut prepared = self.begin(ui);
+        let ret = add_contents(&mut prepared.content_ui);
+        let response = prepared.end(ui);
+        InnerResponse::new(ret, response)
+    }
+
+    pub fn paint(&self, outer_rect: Rect) -> Shape {
+        let Self {
+            inner_margin: _,
+            outer_margin: _,
+            rounding,
+            shadow,
+            fill,
+            stroke,
+        } = *self;
+
+        let frame_shape = Shape::Rect(epaint::RectShape {
+            rect: outer_rect,
+            rounding,
+            fill,
+            stroke,
+        });
+
+        if shadow == Default::default() {
+            frame_shape
+        } else {
+            let shadow = shadow.tessellate(outer_rect, rounding);
+            let shadow = Shape::Mesh(shadow);
+            Shape::Vec(vec![shadow, frame_shape])
+        }
+    }
+}
+
+impl Prepared {
+    fn paint_rect(&self) -> Rect {
+        let mut rect = self.content_ui.min_rect();
+        rect.min -= self.frame.inner_margin.left_top();
+        rect.max += self.frame.inner_margin.right_bottom();
+        rect
+    }
+
+    fn content_with_margin(&self) -> Rect {
+        let mut rect = self.content_ui.min_rect();
+        rect.min -= self.frame.inner_margin.left_top() + self.frame.outer_margin.left_top();
+        rect.max += self.frame.inner_margin.right_bottom() + self.frame.outer_margin.right_bottom();
+        rect
+    }
+
+    pub fn end(self, ui: &mut Ui) -> Response {
+        let paint_rect = self.paint_rect();
+
+        let Prepared {
+            frame,
+            where_to_put_background,
+            ..
+        } = self;
+
+        if ui.is_rect_visible(paint_rect) {
+            let shape = frame.paint(paint_rect);
+            ui.painter().set(where_to_put_background, shape);
+        }
+
+        ui.allocate_rect(self.content_with_margin(), Sense::hover())
+    }
+}
diff --git a/egui/crates/egui/src/containers/mod.rs b/egui/crates/egui/src/containers/mod.rs
new file mode 100644
index 0000000..53e8e7e
--- /dev/null
+++ b/egui/crates/egui/src/containers/mod.rs
@@ -0,0 +1,25 @@
+//! Containers are pieces of the UI which wraps other pieces of UI. Examples: [`Window`], [`ScrollArea`], [`Resize`], [`SidePanel`], etc.
+//!
+//! For instance, a [`Frame`] adds a frame and background to some contained UI.
+
+pub(crate) mod area;
+pub mod collapsing_header;
+mod combo_box;
+pub(crate) mod frame;
+pub mod panel;
+pub mod popup;
+pub(crate) mod resize;
+pub mod scroll_area;
+pub(crate) mod window;
+
+pub use {
+    area::Area,
+    collapsing_header::{CollapsingHeader, CollapsingResponse},
+    combo_box::*,
+    frame::Frame,
+    panel::{CentralPanel, SidePanel, TopBottomPanel},
+    popup::*,
+    resize::Resize,
+    scroll_area::ScrollArea,
+    window::Window,
+};
diff --git a/egui/crates/egui/src/containers/panel.rs b/egui/crates/egui/src/containers/panel.rs
new file mode 100644
index 0000000..d829ac2
--- /dev/null
+++ b/egui/crates/egui/src/containers/panel.rs
@@ -0,0 +1,1064 @@
+//! Panels are [`Ui`] regions taking up e.g. the left side of a [`Ui`] or screen.
+//!
+//! Panels can either be a child of a [`Ui`] (taking up a portion of the parent)
+//! or be top-level (taking up a portion of the whole screen).
+//!
+//! Together with [`Window`] and [`Area`]:s, top-level panels are
+//! the only places where you can put you widgets.
+//!
+//! The order in which you add panels matter!
+//! The first panel you add will always be the outermost, and the last you add will always be the innermost.
+//!
+//! You must never open one top-level panel from within another panel. Add one panel, then the next.
+//!
+//! ⚠ Always add any [`CentralPanel`] last.
+//!
+//! Add your [`Window`]:s after any top-level panels.
+
+use std::ops::RangeInclusive;
+
+use crate::*;
+
+/// State regarding panels.
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PanelState {
+    pub rect: Rect,
+}
+
+impl PanelState {
+    pub fn load(ctx: &Context, bar_id: Id) -> Option<Self> {
+        ctx.data_mut(|d| d.get_persisted(bar_id))
+    }
+
+    /// The size of the panel (from previous frame).
+    pub fn size(&self) -> Vec2 {
+        self.rect.size()
+    }
+
+    fn store(self, ctx: &Context, bar_id: Id) {
+        ctx.data_mut(|d| d.insert_persisted(bar_id, self));
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// [`Left`](Side::Left) or [`Right`](Side::Right)
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Side {
+    Left,
+    Right,
+}
+
+impl Side {
+    fn opposite(self) -> Self {
+        match self {
+            Side::Left => Self::Right,
+            Side::Right => Self::Left,
+        }
+    }
+
+    fn set_rect_width(self, rect: &mut Rect, width: f32) {
+        match self {
+            Side::Left => rect.max.x = rect.min.x + width,
+            Side::Right => rect.min.x = rect.max.x - width,
+        }
+    }
+
+    fn side_x(self, rect: Rect) -> f32 {
+        match self {
+            Side::Left => rect.left(),
+            Side::Right => rect.right(),
+        }
+    }
+}
+
+/// A panel that covers the entire left or right side of a [`Ui`] or screen.
+///
+/// The order in which you add panels matter!
+/// The first panel you add will always be the outermost, and the last you add will always be the innermost.
+///
+/// ⚠ Always add any [`CentralPanel`] last.
+///
+/// See the [module level docs](crate::containers::panel) for more details.
+///
+/// ```
+/// # egui::__run_test_ctx(|ctx| {
+/// egui::SidePanel::left("my_left_panel").show(ctx, |ui| {
+///    ui.label("Hello World!");
+/// });
+/// # });
+/// ```
+///
+/// See also [`TopBottomPanel`].
+#[must_use = "You should call .show()"]
+pub struct SidePanel {
+    side: Side,
+    id: Id,
+    frame: Option<Frame>,
+    resizable: bool,
+    show_separator_line: bool,
+    default_width: f32,
+    width_range: RangeInclusive<f32>,
+}
+
+impl SidePanel {
+    /// The id should be globally unique, e.g. `Id::new("my_left_panel")`.
+    pub fn left(id: impl Into<Id>) -> Self {
+        Self::new(Side::Left, id)
+    }
+
+    /// The id should be globally unique, e.g. `Id::new("my_right_panel")`.
+    pub fn right(id: impl Into<Id>) -> Self {
+        Self::new(Side::Right, id)
+    }
+
+    /// The id should be globally unique, e.g. `Id::new("my_panel")`.
+    pub fn new(side: Side, id: impl Into<Id>) -> Self {
+        Self {
+            side,
+            id: id.into(),
+            frame: None,
+            resizable: true,
+            show_separator_line: true,
+            default_width: 200.0,
+            width_range: 96.0..=f32::INFINITY,
+        }
+    }
+
+    /// Can panel be resized by dragging the edge of it?
+    ///
+    /// Default is `true`.
+    ///
+    /// If you want your panel to be resizable you also need a widget in it that
+    /// takes up more space as you resize it, such as:
+    /// * Wrapping text ([`Ui::horizontal_wrapped`]).
+    /// * A [`ScrollArea`].
+    /// * A [`Separator`].
+    /// * A [`TextEdit`].
+    /// * …
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.resizable = resizable;
+        self
+    }
+
+    /// Show a separator line, even when not interacting with it?
+    ///
+    /// Default: `true`.
+    pub fn show_separator_line(mut self, show_separator_line: bool) -> Self {
+        self.show_separator_line = show_separator_line;
+        self
+    }
+
+    /// The initial wrapping width of the [`SidePanel`].
+    pub fn default_width(mut self, default_width: f32) -> Self {
+        self.default_width = default_width;
+        self.width_range = self.width_range.start().at_most(default_width)
+            ..=self.width_range.end().at_least(default_width);
+        self
+    }
+
+    /// Minimum width of the panel.
+    pub fn min_width(mut self, min_width: f32) -> Self {
+        self.width_range = min_width..=self.width_range.end().at_least(min_width);
+        self
+    }
+
+    /// Maximum width of the panel.
+    pub fn max_width(mut self, max_width: f32) -> Self {
+        self.width_range = self.width_range.start().at_most(max_width)..=max_width;
+        self
+    }
+
+    /// The allowable width range for the panel.
+    pub fn width_range(mut self, width_range: RangeInclusive<f32>) -> Self {
+        self.default_width = clamp_to_range(self.default_width, width_range.clone());
+        self.width_range = width_range;
+        self
+    }
+
+    /// Enforce this exact width.
+    pub fn exact_width(mut self, width: f32) -> Self {
+        self.default_width = width;
+        self.width_range = width..=width;
+        self
+    }
+
+    /// Change the background color, margins, etc.
+    pub fn frame(mut self, frame: Frame) -> Self {
+        self.frame = Some(frame);
+        self
+    }
+}
+
+impl SidePanel {
+    /// Show the panel inside a [`Ui`].
+    pub fn show_inside<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.show_inside_dyn(ui, Box::new(add_contents))
+    }
+
+    /// Show the panel inside a [`Ui`].
+    fn show_inside_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let Self {
+            side,
+            id,
+            frame,
+            resizable,
+            show_separator_line,
+            default_width,
+            width_range,
+        } = self;
+
+        let available_rect = ui.available_rect_before_wrap();
+        let mut panel_rect = available_rect;
+        {
+            let mut width = default_width;
+            if let Some(state) = PanelState::load(ui.ctx(), id) {
+                width = state.rect.width();
+            }
+            width = clamp_to_range(width, width_range.clone()).at_most(available_rect.width());
+            side.set_rect_width(&mut panel_rect, width);
+            ui.ctx().check_for_id_clash(id, panel_rect, "SidePanel");
+        }
+
+        let mut resize_hover = false;
+        let mut is_resizing = false;
+        if resizable {
+            let resize_id = id.with("__resize");
+            if let Some(pointer) = ui.ctx().pointer_latest_pos() {
+                let we_are_on_top = ui
+                    .ctx()
+                    .layer_id_at(pointer)
+                    .map_or(true, |top_layer_id| top_layer_id == ui.layer_id());
+
+                let resize_x = side.opposite().side_x(panel_rect);
+                let mouse_over_resize_line = we_are_on_top
+                    && panel_rect.y_range().contains(&pointer.y)
+                    && (resize_x - pointer.x).abs()
+                        <= ui.style().interaction.resize_grab_radius_side;
+
+                if ui.input(|i| i.pointer.any_pressed() && i.pointer.any_down())
+                    && mouse_over_resize_line
+                {
+                    ui.memory_mut(|mem| mem.set_dragged_id(resize_id));
+                }
+                is_resizing = ui.memory(|mem| mem.is_being_dragged(resize_id));
+                if is_resizing {
+                    let width = (pointer.x - side.side_x(panel_rect)).abs();
+                    let width =
+                        clamp_to_range(width, width_range.clone()).at_most(available_rect.width());
+                    side.set_rect_width(&mut panel_rect, width);
+                }
+
+                let dragging_something_else =
+                    ui.input(|i| i.pointer.any_down() || i.pointer.any_pressed());
+                resize_hover = mouse_over_resize_line && !dragging_something_else;
+
+                if resize_hover || is_resizing {
+                    ui.ctx().set_cursor_icon(CursorIcon::ResizeHorizontal);
+                }
+            }
+        }
+
+        let mut panel_ui = ui.child_ui_with_id_source(panel_rect, Layout::top_down(Align::Min), id);
+        panel_ui.expand_to_include_rect(panel_rect);
+        let frame = frame.unwrap_or_else(|| Frame::side_top_panel(ui.style()));
+        let inner_response = frame.show(&mut panel_ui, |ui| {
+            ui.set_min_height(ui.max_rect().height()); // Make sure the frame fills the full height
+            ui.set_min_width(*width_range.start());
+            add_contents(ui)
+        });
+
+        let rect = inner_response.response.rect;
+
+        {
+            let mut cursor = ui.cursor();
+            match side {
+                Side::Left => {
+                    cursor.min.x = rect.max.x;
+                }
+                Side::Right => {
+                    cursor.max.x = rect.min.x;
+                }
+            }
+            ui.set_cursor(cursor);
+        }
+        ui.expand_to_include_rect(rect);
+
+        PanelState { rect }.store(ui.ctx(), id);
+
+        {
+            let stroke = if is_resizing {
+                ui.style().visuals.widgets.active.fg_stroke // highly visible
+            } else if resize_hover {
+                ui.style().visuals.widgets.hovered.fg_stroke // highly visible
+            } else if show_separator_line {
+                // TODO(emilk): distinguish resizable from non-resizable
+                ui.style().visuals.widgets.noninteractive.bg_stroke // dim
+            } else {
+                Stroke::NONE
+            };
+            // TODO(emilk): draw line on top of all panels in this ui when https://github.com/emilk/egui/issues/1516 is done
+            // In the meantime: nudge the line so its inside the panel, so it won't be covered by neighboring panel
+            // (hence the shrink).
+            let resize_x = side.opposite().side_x(rect.shrink(1.0));
+            let resize_x = ui.painter().round_to_pixel(resize_x);
+            ui.painter().vline(resize_x, rect.y_range(), stroke);
+        }
+
+        inner_response
+    }
+
+    /// Show the panel at the top level.
+    pub fn show<R>(
+        self,
+        ctx: &Context,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.show_dyn(ctx, Box::new(add_contents))
+    }
+
+    /// Show the panel at the top level.
+    fn show_dyn<'c, R>(
+        self,
+        ctx: &Context,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let layer_id = LayerId::background();
+        let side = self.side;
+        let available_rect = ctx.available_rect();
+        let clip_rect = ctx.screen_rect();
+        let mut panel_ui = Ui::new(ctx.clone(), layer_id, self.id, available_rect, clip_rect);
+
+        let inner_response = self.show_inside_dyn(&mut panel_ui, add_contents);
+        let rect = inner_response.response.rect;
+
+        match side {
+            Side::Left => ctx.frame_state_mut(|state| {
+                state.allocate_left_panel(Rect::from_min_max(available_rect.min, rect.max));
+            }),
+            Side::Right => ctx.frame_state_mut(|state| {
+                state.allocate_right_panel(Rect::from_min_max(rect.min, available_rect.max));
+            }),
+        }
+        inner_response
+    }
+
+    /// Show the panel if `is_expanded` is `true`,
+    /// otherwise don't show it, but with a nice animation between collapsed and expanded.
+    pub fn show_animated<R>(
+        self,
+        ctx: &Context,
+        is_expanded: bool,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let how_expanded = ctx.animate_bool(self.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            None
+        } else if how_expanded < 1.0 {
+            // Show a fake panel in this in-between animation state:
+            // TODO(emilk): move the panel out-of-screen instead of changing its width.
+            // Then we can actually paint it as it animates.
+            let expanded_width = PanelState::load(ctx, self.id)
+                .map_or(self.default_width, |state| state.rect.width());
+            let fake_width = how_expanded * expanded_width;
+            Self {
+                id: self.id.with("animating_panel"),
+                ..self
+            }
+            .resizable(false)
+            .exact_width(fake_width)
+            .show(ctx, |_ui| {});
+            None
+        } else {
+            // Show the real panel:
+            Some(self.show(ctx, add_contents))
+        }
+    }
+
+    /// Show the panel if `is_expanded` is `true`,
+    /// otherwise don't show it, but with a nice animation between collapsed and expanded.
+    pub fn show_animated_inside<R>(
+        self,
+        ui: &mut Ui,
+        is_expanded: bool,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let how_expanded = ui
+            .ctx()
+            .animate_bool(self.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            None
+        } else if how_expanded < 1.0 {
+            // Show a fake panel in this in-between animation state:
+            // TODO(emilk): move the panel out-of-screen instead of changing its width.
+            // Then we can actually paint it as it animates.
+            let expanded_width = PanelState::load(ui.ctx(), self.id)
+                .map_or(self.default_width, |state| state.rect.width());
+            let fake_width = how_expanded * expanded_width;
+            Self {
+                id: self.id.with("animating_panel"),
+                ..self
+            }
+            .resizable(false)
+            .exact_width(fake_width)
+            .show_inside(ui, |_ui| {});
+            None
+        } else {
+            // Show the real panel:
+            Some(self.show_inside(ui, add_contents))
+        }
+    }
+
+    /// Show either a collapsed or a expanded panel, with a nice animation between.
+    pub fn show_animated_between<R>(
+        ctx: &Context,
+        is_expanded: bool,
+        collapsed_panel: Self,
+        expanded_panel: Self,
+        add_contents: impl FnOnce(&mut Ui, f32) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let how_expanded = ctx.animate_bool(expanded_panel.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            Some(collapsed_panel.show(ctx, |ui| add_contents(ui, how_expanded)))
+        } else if how_expanded < 1.0 {
+            // Show animation:
+            let collapsed_width = PanelState::load(ctx, collapsed_panel.id)
+                .map_or(collapsed_panel.default_width, |state| state.rect.width());
+            let expanded_width = PanelState::load(ctx, expanded_panel.id)
+                .map_or(expanded_panel.default_width, |state| state.rect.width());
+            let fake_width = lerp(collapsed_width..=expanded_width, how_expanded);
+            Self {
+                id: expanded_panel.id.with("animating_panel"),
+                ..expanded_panel
+            }
+            .resizable(false)
+            .exact_width(fake_width)
+            .show(ctx, |ui| add_contents(ui, how_expanded));
+            None
+        } else {
+            Some(expanded_panel.show(ctx, |ui| add_contents(ui, how_expanded)))
+        }
+    }
+
+    /// Show either a collapsed or a expanded panel, with a nice animation between.
+    pub fn show_animated_between_inside<R>(
+        ui: &mut Ui,
+        is_expanded: bool,
+        collapsed_panel: Self,
+        expanded_panel: Self,
+        add_contents: impl FnOnce(&mut Ui, f32) -> R,
+    ) -> InnerResponse<R> {
+        let how_expanded = ui
+            .ctx()
+            .animate_bool(expanded_panel.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            collapsed_panel.show_inside(ui, |ui| add_contents(ui, how_expanded))
+        } else if how_expanded < 1.0 {
+            // Show animation:
+            let collapsed_width = PanelState::load(ui.ctx(), collapsed_panel.id)
+                .map_or(collapsed_panel.default_width, |state| state.rect.width());
+            let expanded_width = PanelState::load(ui.ctx(), expanded_panel.id)
+                .map_or(expanded_panel.default_width, |state| state.rect.width());
+            let fake_width = lerp(collapsed_width..=expanded_width, how_expanded);
+            Self {
+                id: expanded_panel.id.with("animating_panel"),
+                ..expanded_panel
+            }
+            .resizable(false)
+            .exact_width(fake_width)
+            .show_inside(ui, |ui| add_contents(ui, how_expanded))
+        } else {
+            expanded_panel.show_inside(ui, |ui| add_contents(ui, how_expanded))
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// [`Top`](TopBottomSide::Top) or [`Bottom`](TopBottomSide::Bottom)
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TopBottomSide {
+    Top,
+    Bottom,
+}
+
+impl TopBottomSide {
+    fn opposite(self) -> Self {
+        match self {
+            TopBottomSide::Top => Self::Bottom,
+            TopBottomSide::Bottom => Self::Top,
+        }
+    }
+
+    fn set_rect_height(self, rect: &mut Rect, height: f32) {
+        match self {
+            TopBottomSide::Top => rect.max.y = rect.min.y + height,
+            TopBottomSide::Bottom => rect.min.y = rect.max.y - height,
+        }
+    }
+
+    fn side_y(self, rect: Rect) -> f32 {
+        match self {
+            TopBottomSide::Top => rect.top(),
+            TopBottomSide::Bottom => rect.bottom(),
+        }
+    }
+}
+
+/// A panel that covers the entire top or bottom of a [`Ui`] or screen.
+///
+/// The order in which you add panels matter!
+/// The first panel you add will always be the outermost, and the last you add will always be the innermost.
+///
+/// ⚠ Always add any [`CentralPanel`] last.
+///
+/// See the [module level docs](crate::containers::panel) for more details.
+///
+/// ```
+/// # egui::__run_test_ctx(|ctx| {
+/// egui::TopBottomPanel::top("my_panel").show(ctx, |ui| {
+///    ui.label("Hello World!");
+/// });
+/// # });
+/// ```
+///
+/// See also [`SidePanel`].
+#[must_use = "You should call .show()"]
+pub struct TopBottomPanel {
+    side: TopBottomSide,
+    id: Id,
+    frame: Option<Frame>,
+    resizable: bool,
+    show_separator_line: bool,
+    default_height: Option<f32>,
+    height_range: RangeInclusive<f32>,
+}
+
+impl TopBottomPanel {
+    /// The id should be globally unique, e.g. `Id::new("my_top_panel")`.
+    pub fn top(id: impl Into<Id>) -> Self {
+        Self::new(TopBottomSide::Top, id)
+    }
+
+    /// The id should be globally unique, e.g. `Id::new("my_bottom_panel")`.
+    pub fn bottom(id: impl Into<Id>) -> Self {
+        Self::new(TopBottomSide::Bottom, id)
+    }
+
+    /// The id should be globally unique, e.g. `Id::new("my_panel")`.
+    pub fn new(side: TopBottomSide, id: impl Into<Id>) -> Self {
+        Self {
+            side,
+            id: id.into(),
+            frame: None,
+            resizable: false,
+            show_separator_line: true,
+            default_height: None,
+            height_range: 20.0..=f32::INFINITY,
+        }
+    }
+
+    /// Can panel be resized by dragging the edge of it?
+    ///
+    /// Default is `false`.
+    ///
+    /// If you want your panel to be resizable you also need a widget in it that
+    /// takes up more space as you resize it, such as:
+    /// * Wrapping text ([`Ui::horizontal_wrapped`]).
+    /// * A [`ScrollArea`].
+    /// * A [`Separator`].
+    /// * A [`TextEdit`].
+    /// * …
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.resizable = resizable;
+        self
+    }
+
+    /// Show a separator line, even when not interacting with it?
+    ///
+    /// Default: `true`.
+    pub fn show_separator_line(mut self, show_separator_line: bool) -> Self {
+        self.show_separator_line = show_separator_line;
+        self
+    }
+
+    /// The initial height of the [`SidePanel`].
+    /// Defaults to [`style::Spacing::interact_size`].y.
+    pub fn default_height(mut self, default_height: f32) -> Self {
+        self.default_height = Some(default_height);
+        self.height_range = self.height_range.start().at_most(default_height)
+            ..=self.height_range.end().at_least(default_height);
+        self
+    }
+
+    /// Minimum height of the panel.
+    pub fn min_height(mut self, min_height: f32) -> Self {
+        self.height_range = min_height..=self.height_range.end().at_least(min_height);
+        self
+    }
+
+    /// Maximum height of the panel.
+    pub fn max_height(mut self, max_height: f32) -> Self {
+        self.height_range = self.height_range.start().at_most(max_height)..=max_height;
+        self
+    }
+
+    /// The allowable height range for the panel.
+    pub fn height_range(mut self, height_range: RangeInclusive<f32>) -> Self {
+        self.default_height = self
+            .default_height
+            .map(|default_height| clamp_to_range(default_height, height_range.clone()));
+        self.height_range = height_range;
+        self
+    }
+
+    /// Enforce this exact height.
+    pub fn exact_height(mut self, height: f32) -> Self {
+        self.default_height = Some(height);
+        self.height_range = height..=height;
+        self
+    }
+
+    /// Change the background color, margins, etc.
+    pub fn frame(mut self, frame: Frame) -> Self {
+        self.frame = Some(frame);
+        self
+    }
+}
+
+impl TopBottomPanel {
+    /// Show the panel inside a [`Ui`].
+    pub fn show_inside<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.show_inside_dyn(ui, Box::new(add_contents))
+    }
+
+    /// Show the panel inside a [`Ui`].
+    fn show_inside_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let Self {
+            side,
+            id,
+            frame,
+            resizable,
+            show_separator_line,
+            default_height,
+            height_range,
+        } = self;
+
+        let available_rect = ui.available_rect_before_wrap();
+        let mut panel_rect = available_rect;
+        {
+            let mut height = if let Some(state) = PanelState::load(ui.ctx(), id) {
+                state.rect.height()
+            } else {
+                default_height.unwrap_or_else(|| ui.style().spacing.interact_size.y)
+            };
+            height = clamp_to_range(height, height_range.clone()).at_most(available_rect.height());
+            side.set_rect_height(&mut panel_rect, height);
+            ui.ctx()
+                .check_for_id_clash(id, panel_rect, "TopBottomPanel");
+        }
+
+        let mut resize_hover = false;
+        let mut is_resizing = false;
+        if resizable {
+            let resize_id = id.with("__resize");
+            let latest_pos = ui.input(|i| i.pointer.latest_pos());
+            if let Some(pointer) = latest_pos {
+                let we_are_on_top = ui
+                    .ctx()
+                    .layer_id_at(pointer)
+                    .map_or(true, |top_layer_id| top_layer_id == ui.layer_id());
+
+                let resize_y = side.opposite().side_y(panel_rect);
+                let mouse_over_resize_line = we_are_on_top
+                    && panel_rect.x_range().contains(&pointer.x)
+                    && (resize_y - pointer.y).abs()
+                        <= ui.style().interaction.resize_grab_radius_side;
+
+                if ui.input(|i| i.pointer.any_pressed() && i.pointer.any_down())
+                    && mouse_over_resize_line
+                {
+                    ui.memory_mut(|mem| mem.interaction.drag_id = Some(resize_id));
+                }
+                is_resizing = ui.memory(|mem| mem.interaction.drag_id == Some(resize_id));
+                if is_resizing {
+                    let height = (pointer.y - side.side_y(panel_rect)).abs();
+                    let height = clamp_to_range(height, height_range.clone())
+                        .at_most(available_rect.height());
+                    side.set_rect_height(&mut panel_rect, height);
+                }
+
+                let dragging_something_else =
+                    ui.input(|i| i.pointer.any_down() || i.pointer.any_pressed());
+                resize_hover = mouse_over_resize_line && !dragging_something_else;
+
+                if resize_hover || is_resizing {
+                    ui.ctx().set_cursor_icon(CursorIcon::ResizeVertical);
+                }
+            }
+        }
+
+        let mut panel_ui = ui.child_ui_with_id_source(panel_rect, Layout::top_down(Align::Min), id);
+        panel_ui.expand_to_include_rect(panel_rect);
+        let frame = frame.unwrap_or_else(|| Frame::side_top_panel(ui.style()));
+        let inner_response = frame.show(&mut panel_ui, |ui| {
+            ui.set_min_width(ui.max_rect().width()); // Make the frame fill full width
+            ui.set_min_height(*height_range.start());
+            add_contents(ui)
+        });
+
+        let rect = inner_response.response.rect;
+
+        {
+            let mut cursor = ui.cursor();
+            match side {
+                TopBottomSide::Top => {
+                    cursor.min.y = rect.max.y;
+                }
+                TopBottomSide::Bottom => {
+                    cursor.max.y = rect.min.y;
+                }
+            }
+            ui.set_cursor(cursor);
+        }
+        ui.expand_to_include_rect(rect);
+
+        PanelState { rect }.store(ui.ctx(), id);
+
+        {
+            let stroke = if is_resizing {
+                ui.style().visuals.widgets.active.fg_stroke // highly visible
+            } else if resize_hover {
+                ui.style().visuals.widgets.hovered.fg_stroke // highly visible
+            } else if show_separator_line {
+                // TODO(emilk): distinguish resizable from non-resizable
+                ui.style().visuals.widgets.noninteractive.bg_stroke // dim
+            } else {
+                Stroke::NONE
+            };
+            // TODO(emilk): draw line on top of all panels in this ui when https://github.com/emilk/egui/issues/1516 is done
+            // In the meantime: nudge the line so its inside the panel, so it won't be covered by neighboring panel
+            // (hence the shrink).
+            let resize_y = side.opposite().side_y(rect.shrink(1.0));
+            let resize_y = ui.painter().round_to_pixel(resize_y);
+            ui.painter().hline(rect.x_range(), resize_y, stroke);
+        }
+
+        inner_response
+    }
+
+    /// Show the panel at the top level.
+    pub fn show<R>(
+        self,
+        ctx: &Context,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.show_dyn(ctx, Box::new(add_contents))
+    }
+
+    /// Show the panel at the top level.
+    fn show_dyn<'c, R>(
+        self,
+        ctx: &Context,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let layer_id = LayerId::background();
+        let available_rect = ctx.available_rect();
+        let side = self.side;
+
+        let clip_rect = ctx.screen_rect();
+        let mut panel_ui = Ui::new(ctx.clone(), layer_id, self.id, available_rect, clip_rect);
+
+        let inner_response = self.show_inside_dyn(&mut panel_ui, add_contents);
+        let rect = inner_response.response.rect;
+
+        match side {
+            TopBottomSide::Top => {
+                ctx.frame_state_mut(|state| {
+                    state.allocate_top_panel(Rect::from_min_max(available_rect.min, rect.max));
+                });
+            }
+            TopBottomSide::Bottom => {
+                ctx.frame_state_mut(|state| {
+                    state.allocate_bottom_panel(Rect::from_min_max(rect.min, available_rect.max));
+                });
+            }
+        }
+
+        inner_response
+    }
+
+    /// Show the panel if `is_expanded` is `true`,
+    /// otherwise don't show it, but with a nice animation between collapsed and expanded.
+    pub fn show_animated<R>(
+        self,
+        ctx: &Context,
+        is_expanded: bool,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let how_expanded = ctx.animate_bool(self.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            None
+        } else if how_expanded < 1.0 {
+            // Show a fake panel in this in-between animation state:
+            // TODO(emilk): move the panel out-of-screen instead of changing its height.
+            // Then we can actually paint it as it animates.
+            let expanded_height = PanelState::load(ctx, self.id)
+                .map(|state| state.rect.height())
+                .or(self.default_height)
+                .unwrap_or_else(|| ctx.style().spacing.interact_size.y);
+            let fake_height = how_expanded * expanded_height;
+            Self {
+                id: self.id.with("animating_panel"),
+                ..self
+            }
+            .resizable(false)
+            .exact_height(fake_height)
+            .show(ctx, |_ui| {});
+            None
+        } else {
+            // Show the real panel:
+            Some(self.show(ctx, add_contents))
+        }
+    }
+
+    /// Show the panel if `is_expanded` is `true`,
+    /// otherwise don't show it, but with a nice animation between collapsed and expanded.
+    pub fn show_animated_inside<R>(
+        self,
+        ui: &mut Ui,
+        is_expanded: bool,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let how_expanded = ui
+            .ctx()
+            .animate_bool(self.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            None
+        } else if how_expanded < 1.0 {
+            // Show a fake panel in this in-between animation state:
+            // TODO(emilk): move the panel out-of-screen instead of changing its height.
+            // Then we can actually paint it as it animates.
+            let expanded_height = PanelState::load(ui.ctx(), self.id)
+                .map(|state| state.rect.height())
+                .or(self.default_height)
+                .unwrap_or_else(|| ui.style().spacing.interact_size.y);
+            let fake_height = how_expanded * expanded_height;
+            Self {
+                id: self.id.with("animating_panel"),
+                ..self
+            }
+            .resizable(false)
+            .exact_height(fake_height)
+            .show_inside(ui, |_ui| {});
+            None
+        } else {
+            // Show the real panel:
+            Some(self.show_inside(ui, add_contents))
+        }
+    }
+
+    /// Show either a collapsed or a expanded panel, with a nice animation between.
+    pub fn show_animated_between<R>(
+        ctx: &Context,
+        is_expanded: bool,
+        collapsed_panel: Self,
+        expanded_panel: Self,
+        add_contents: impl FnOnce(&mut Ui, f32) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let how_expanded = ctx.animate_bool(expanded_panel.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            Some(collapsed_panel.show(ctx, |ui| add_contents(ui, how_expanded)))
+        } else if how_expanded < 1.0 {
+            // Show animation:
+            let collapsed_height = PanelState::load(ctx, collapsed_panel.id)
+                .map(|state| state.rect.height())
+                .or(collapsed_panel.default_height)
+                .unwrap_or_else(|| ctx.style().spacing.interact_size.y);
+
+            let expanded_height = PanelState::load(ctx, expanded_panel.id)
+                .map(|state| state.rect.height())
+                .or(expanded_panel.default_height)
+                .unwrap_or_else(|| ctx.style().spacing.interact_size.y);
+
+            let fake_height = lerp(collapsed_height..=expanded_height, how_expanded);
+            Self {
+                id: expanded_panel.id.with("animating_panel"),
+                ..expanded_panel
+            }
+            .resizable(false)
+            .exact_height(fake_height)
+            .show(ctx, |ui| add_contents(ui, how_expanded));
+            None
+        } else {
+            Some(expanded_panel.show(ctx, |ui| add_contents(ui, how_expanded)))
+        }
+    }
+
+    /// Show either a collapsed or a expanded panel, with a nice animation between.
+    pub fn show_animated_between_inside<R>(
+        ui: &mut Ui,
+        is_expanded: bool,
+        collapsed_panel: Self,
+        expanded_panel: Self,
+        add_contents: impl FnOnce(&mut Ui, f32) -> R,
+    ) -> InnerResponse<R> {
+        let how_expanded = ui
+            .ctx()
+            .animate_bool(expanded_panel.id.with("animation"), is_expanded);
+
+        if 0.0 == how_expanded {
+            collapsed_panel.show_inside(ui, |ui| add_contents(ui, how_expanded))
+        } else if how_expanded < 1.0 {
+            // Show animation:
+            let collapsed_height = PanelState::load(ui.ctx(), collapsed_panel.id)
+                .map(|state| state.rect.height())
+                .or(collapsed_panel.default_height)
+                .unwrap_or_else(|| ui.style().spacing.interact_size.y);
+
+            let expanded_height = PanelState::load(ui.ctx(), expanded_panel.id)
+                .map(|state| state.rect.height())
+                .or(expanded_panel.default_height)
+                .unwrap_or_else(|| ui.style().spacing.interact_size.y);
+
+            let fake_height = lerp(collapsed_height..=expanded_height, how_expanded);
+            Self {
+                id: expanded_panel.id.with("animating_panel"),
+                ..expanded_panel
+            }
+            .resizable(false)
+            .exact_height(fake_height)
+            .show_inside(ui, |ui| add_contents(ui, how_expanded))
+        } else {
+            expanded_panel.show_inside(ui, |ui| add_contents(ui, how_expanded))
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A panel that covers the remainder of the screen,
+/// i.e. whatever area is left after adding other panels.
+///
+/// The order in which you add panels matter!
+/// The first panel you add will always be the outermost, and the last you add will always be the innermost.
+///
+/// ⚠ [`CentralPanel`] must be added after all other panels!
+///
+/// NOTE: Any [`Window`]s and [`Area`]s will cover the top-level [`CentralPanel`].
+///
+/// See the [module level docs](crate::containers::panel) for more details.
+///
+/// ```
+/// # egui::__run_test_ctx(|ctx| {
+/// egui::TopBottomPanel::top("my_panel").show(ctx, |ui| {
+///    ui.label("Hello World! From `TopBottomPanel`, that must be before `CentralPanel`!");
+/// });
+/// egui::CentralPanel::default().show(ctx, |ui| {
+///    ui.label("Hello World!");
+/// });
+/// # });
+/// ```
+#[must_use = "You should call .show()"]
+#[derive(Default)]
+pub struct CentralPanel {
+    frame: Option<Frame>,
+}
+
+impl CentralPanel {
+    /// Change the background color, margins, etc.
+    pub fn frame(mut self, frame: Frame) -> Self {
+        self.frame = Some(frame);
+        self
+    }
+}
+
+impl CentralPanel {
+    /// Show the panel inside a [`Ui`].
+    pub fn show_inside<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.show_inside_dyn(ui, Box::new(add_contents))
+    }
+
+    /// Show the panel inside a [`Ui`].
+    fn show_inside_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let Self { frame } = self;
+
+        let panel_rect = ui.available_rect_before_wrap();
+        let mut panel_ui = ui.child_ui(panel_rect, Layout::top_down(Align::Min));
+
+        let frame = frame.unwrap_or_else(|| Frame::central_panel(ui.style()));
+        frame.show(&mut panel_ui, |ui| {
+            ui.expand_to_include_rect(ui.max_rect()); // Expand frame to include it all
+            add_contents(ui)
+        })
+    }
+
+    /// Show the panel at the top level.
+    pub fn show<R>(
+        self,
+        ctx: &Context,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.show_dyn(ctx, Box::new(add_contents))
+    }
+
+    /// Show the panel at the top level.
+    fn show_dyn<'c, R>(
+        self,
+        ctx: &Context,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let available_rect = ctx.available_rect();
+        let layer_id = LayerId::background();
+        let id = Id::new("central_panel");
+
+        let clip_rect = ctx.screen_rect();
+        let mut panel_ui = Ui::new(ctx.clone(), layer_id, id, available_rect, clip_rect);
+
+        let inner_response = self.show_inside_dyn(&mut panel_ui, add_contents);
+
+        // Only inform ctx about what we actually used, so we can shrink the native window to fit.
+        ctx.frame_state_mut(|state| state.allocate_central_panel(inner_response.response.rect));
+
+        inner_response
+    }
+}
+
+fn clamp_to_range(x: f32, range: RangeInclusive<f32>) -> f32 {
+    x.clamp(
+        range.start().min(*range.end()),
+        range.start().max(*range.end()),
+    )
+}
diff --git a/egui/crates/egui/src/containers/popup.rs b/egui/crates/egui/src/containers/popup.rs
new file mode 100644
index 0000000..e4ad1b1
--- /dev/null
+++ b/egui/crates/egui/src/containers/popup.rs
@@ -0,0 +1,378 @@
+//! Show popup windows, tooltips, context menus etc.
+
+use crate::*;
+
+// ----------------------------------------------------------------------------
+
+/// Same state for all tooltips.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct TooltipState {
+    last_common_id: Option<Id>,
+    individual_ids_and_sizes: ahash::HashMap<usize, (Id, Vec2)>,
+}
+
+impl TooltipState {
+    pub fn load(ctx: &Context) -> Option<Self> {
+        ctx.data_mut(|d| d.get_temp(Id::null()))
+    }
+
+    fn store(self, ctx: &Context) {
+        ctx.data_mut(|d| d.insert_temp(Id::null(), self));
+    }
+
+    fn individual_tooltip_size(&self, common_id: Id, index: usize) -> Option<Vec2> {
+        if self.last_common_id == Some(common_id) {
+            Some(self.individual_ids_and_sizes.get(&index)?.1)
+        } else {
+            None
+        }
+    }
+
+    fn set_individual_tooltip(
+        &mut self,
+        common_id: Id,
+        index: usize,
+        individual_id: Id,
+        size: Vec2,
+    ) {
+        if self.last_common_id != Some(common_id) {
+            self.last_common_id = Some(common_id);
+            self.individual_ids_and_sizes.clear();
+        }
+
+        self.individual_ids_and_sizes
+            .insert(index, (individual_id, size));
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Show a tooltip at the current pointer position (if any).
+///
+/// Most of the time it is easier to use [`Response::on_hover_ui`].
+///
+/// See also [`show_tooltip_text`].
+///
+/// Returns `None` if the tooltip could not be placed.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// if ui.ui_contains_pointer() {
+///     egui::show_tooltip(ui.ctx(), egui::Id::new("my_tooltip"), |ui| {
+///         ui.label("Helpful text");
+///     });
+/// }
+/// # });
+/// ```
+pub fn show_tooltip<R>(
+    ctx: &Context,
+    id: Id,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    show_tooltip_at_pointer(ctx, id, add_contents)
+}
+
+/// Show a tooltip at the current pointer position (if any).
+///
+/// Most of the time it is easier to use [`Response::on_hover_ui`].
+///
+/// See also [`show_tooltip_text`].
+///
+/// Returns `None` if the tooltip could not be placed.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// if ui.ui_contains_pointer() {
+///     egui::show_tooltip_at_pointer(ui.ctx(), egui::Id::new("my_tooltip"), |ui| {
+///         ui.label("Helpful text");
+///     });
+/// }
+/// # });
+/// ```
+pub fn show_tooltip_at_pointer<R>(
+    ctx: &Context,
+    id: Id,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    let suggested_pos = ctx
+        .input(|i| i.pointer.hover_pos())
+        .map(|pointer_pos| pointer_pos + vec2(16.0, 16.0));
+    show_tooltip_at(ctx, id, suggested_pos, add_contents)
+}
+
+/// Show a tooltip under the given area.
+///
+/// If the tooltip does not fit under the area, it tries to place it above it instead.
+pub fn show_tooltip_for<R>(
+    ctx: &Context,
+    id: Id,
+    rect: &Rect,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    let expanded_rect = rect.expand2(vec2(2.0, 4.0));
+    let (above, position) = if ctx.input(|i| i.any_touches()) {
+        (true, expanded_rect.left_top())
+    } else {
+        (false, expanded_rect.left_bottom())
+    };
+    show_tooltip_at_avoid_dyn(
+        ctx,
+        id,
+        Some(position),
+        above,
+        expanded_rect,
+        Box::new(add_contents),
+    )
+}
+
+/// Show a tooltip at the given position.
+///
+/// Returns `None` if the tooltip could not be placed.
+pub fn show_tooltip_at<R>(
+    ctx: &Context,
+    id: Id,
+    suggested_position: Option<Pos2>,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    let above = false;
+    show_tooltip_at_avoid_dyn(
+        ctx,
+        id,
+        suggested_position,
+        above,
+        Rect::NOTHING,
+        Box::new(add_contents),
+    )
+}
+
+fn show_tooltip_at_avoid_dyn<'c, R>(
+    ctx: &Context,
+    individual_id: Id,
+    suggested_position: Option<Pos2>,
+    above: bool,
+    mut avoid_rect: Rect,
+    add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+) -> Option<R> {
+    let spacing = 4.0;
+
+    // if there are multiple tooltips open they should use the same common_id for the `tooltip_size` caching to work.
+    let mut frame_state =
+        ctx.frame_state(|fs| fs.tooltip_state)
+            .unwrap_or(crate::frame_state::TooltipFrameState {
+                common_id: individual_id,
+                rect: Rect::NOTHING,
+                count: 0,
+            });
+
+    let mut position = if frame_state.rect.is_positive() {
+        avoid_rect = avoid_rect.union(frame_state.rect);
+        if above {
+            frame_state.rect.left_top() - spacing * Vec2::Y
+        } else {
+            frame_state.rect.left_bottom() + spacing * Vec2::Y
+        }
+    } else if let Some(position) = suggested_position {
+        position
+    } else if ctx.memory(|mem| mem.everything_is_visible()) {
+        Pos2::ZERO
+    } else {
+        return None; // No good place for a tooltip :(
+    };
+
+    let mut long_state = TooltipState::load(ctx).unwrap_or_default();
+    let expected_size =
+        long_state.individual_tooltip_size(frame_state.common_id, frame_state.count);
+    let expected_size = expected_size.unwrap_or_else(|| vec2(64.0, 32.0));
+
+    if above {
+        position.y -= expected_size.y;
+    }
+
+    position = position.at_most(ctx.screen_rect().max - expected_size);
+
+    // check if we intersect the avoid_rect
+    {
+        let new_rect = Rect::from_min_size(position, expected_size);
+
+        // Note: We use shrink so that we don't get false positives when the rects just touch
+        if new_rect.shrink(1.0).intersects(avoid_rect) {
+            if above {
+                // place below instead:
+                position = avoid_rect.left_bottom() + spacing * Vec2::Y;
+            } else {
+                // place above instead:
+                position = Pos2::new(position.x, avoid_rect.min.y - expected_size.y - spacing);
+            }
+        }
+    }
+
+    let position = position.at_least(ctx.screen_rect().min);
+
+    let area_id = frame_state.common_id.with(frame_state.count);
+
+    let InnerResponse { inner, response } =
+        show_tooltip_area_dyn(ctx, area_id, position, add_contents);
+
+    long_state.set_individual_tooltip(
+        frame_state.common_id,
+        frame_state.count,
+        individual_id,
+        response.rect.size(),
+    );
+    long_state.store(ctx);
+
+    frame_state.count += 1;
+    frame_state.rect = frame_state.rect.union(response.rect);
+    ctx.frame_state_mut(|fs| fs.tooltip_state = Some(frame_state));
+
+    Some(inner)
+}
+
+/// Show some text at the current pointer position (if any).
+///
+/// Most of the time it is easier to use [`Response::on_hover_text`].
+///
+/// See also [`show_tooltip`].
+///
+/// Returns `None` if the tooltip could not be placed.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// if ui.ui_contains_pointer() {
+///     egui::show_tooltip_text(ui.ctx(), egui::Id::new("my_tooltip"), "Helpful text");
+/// }
+/// # });
+/// ```
+pub fn show_tooltip_text(ctx: &Context, id: Id, text: impl Into<WidgetText>) -> Option<()> {
+    show_tooltip(ctx, id, |ui| {
+        crate::widgets::Label::new(text).ui(ui);
+    })
+}
+
+/// Show a pop-over window.
+fn show_tooltip_area_dyn<'c, R>(
+    ctx: &Context,
+    area_id: Id,
+    window_pos: Pos2,
+    add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+) -> InnerResponse<R> {
+    use containers::*;
+    Area::new(area_id)
+        .order(Order::Tooltip)
+        .fixed_pos(window_pos)
+        .constrain(true)
+        .interactable(false)
+        .drag_bounds(ctx.screen_rect())
+        .show(ctx, |ui| {
+            Frame::popup(&ctx.style())
+                .show(ui, |ui| {
+                    ui.set_max_width(ui.spacing().tooltip_width);
+                    add_contents(ui)
+                })
+                .inner
+        })
+}
+
+/// Was this popup visible last frame?
+pub fn was_tooltip_open_last_frame(ctx: &Context, tooltip_id: Id) -> bool {
+    if let Some(state) = TooltipState::load(ctx) {
+        if let Some(common_id) = state.last_common_id {
+            for (count, (individual_id, _size)) in &state.individual_ids_and_sizes {
+                if *individual_id == tooltip_id {
+                    let area_id = common_id.with(count);
+                    let layer_id = LayerId::new(Order::Tooltip, area_id);
+                    if ctx.memory(|mem| mem.areas.visible_last_frame(&layer_id)) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}
+
+/// Helper for [`popup_above_or_below_widget`].
+pub fn popup_below_widget<R>(
+    ui: &Ui,
+    popup_id: Id,
+    widget_response: &Response,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    popup_above_or_below_widget(
+        ui,
+        popup_id,
+        widget_response,
+        AboveOrBelow::Below,
+        add_contents,
+    )
+}
+
+/// Shows a popup above or below another widget.
+///
+/// Useful for drop-down menus (combo boxes) or suggestion menus under text fields.
+///
+/// The opened popup will have the same width as the parent.
+///
+/// You must open the popup with [`Memory::open_popup`] or  [`Memory::toggle_popup`].
+///
+/// Returns `None` if the popup is not open.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// let response = ui.button("Open popup");
+/// let popup_id = ui.make_persistent_id("my_unique_id");
+/// if response.clicked() {
+///     ui.memory_mut(|mem| mem.toggle_popup(popup_id));
+/// }
+/// let below = egui::AboveOrBelow::Below;
+/// egui::popup::popup_above_or_below_widget(ui, popup_id, &response, below, |ui| {
+///     ui.set_min_width(200.0); // if you want to control the size
+///     ui.label("Some more info, or things you can select:");
+///     ui.label("…");
+/// });
+/// # });
+/// ```
+pub fn popup_above_or_below_widget<R>(
+    ui: &Ui,
+    popup_id: Id,
+    widget_response: &Response,
+    above_or_below: AboveOrBelow,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    if ui.memory(|mem| mem.is_popup_open(popup_id)) {
+        let (pos, pivot) = match above_or_below {
+            AboveOrBelow::Above => (widget_response.rect.left_top(), Align2::LEFT_BOTTOM),
+            AboveOrBelow::Below => (widget_response.rect.left_bottom(), Align2::LEFT_TOP),
+        };
+
+        let inner = Area::new(popup_id)
+            .order(Order::Foreground)
+            .constrain(true)
+            .fixed_pos(pos)
+            .pivot(pivot)
+            .show(ui.ctx(), |ui| {
+                // Note: we use a separate clip-rect for this area, so the popup can be outside the parent.
+                // See https://github.com/emilk/egui/issues/825
+                let frame = Frame::popup(ui.style());
+                let frame_margin = frame.total_margin();
+                frame
+                    .show(ui, |ui| {
+                        ui.with_layout(Layout::top_down_justified(Align::LEFT), |ui| {
+                            ui.set_width(widget_response.rect.width() - frame_margin.sum().x);
+                            add_contents(ui)
+                        })
+                        .inner
+                    })
+                    .inner
+            })
+            .inner;
+
+        if ui.input(|i| i.key_pressed(Key::Escape)) || widget_response.clicked_elsewhere() {
+            ui.memory_mut(|mem| mem.close_popup());
+        }
+        Some(inner)
+    } else {
+        None
+    }
+}
diff --git a/egui/crates/egui/src/containers/resize.rs b/egui/crates/egui/src/containers/resize.rs
new file mode 100644
index 0000000..befb51a
--- /dev/null
+++ b/egui/crates/egui/src/containers/resize.rs
@@ -0,0 +1,351 @@
+use crate::*;
+
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) struct State {
+    /// This is the size that the user has picked by dragging the resize handles.
+    /// This may be smaller and/or larger than the actual size.
+    /// For instance, the user may have tried to shrink too much (not fitting the contents).
+    /// Or the user requested a large area, but the content don't need that much space.
+    pub(crate) desired_size: Vec2,
+
+    /// Actual size of content last frame
+    last_content_size: Vec2,
+
+    /// Externally requested size (e.g. by Window) for the next frame
+    pub(crate) requested_size: Option<Vec2>,
+}
+
+impl State {
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        ctx.data_mut(|d| d.get_persisted(id))
+    }
+
+    pub fn store(self, ctx: &Context, id: Id) {
+        ctx.data_mut(|d| d.insert_persisted(id, self));
+    }
+}
+
+/// A region that can be resized by dragging the bottom right corner.
+#[derive(Clone, Copy, Debug)]
+#[must_use = "You should call .show()"]
+pub struct Resize {
+    id: Option<Id>,
+    id_source: Option<Id>,
+
+    /// If false, we are no enabled
+    resizable: bool,
+
+    pub(crate) min_size: Vec2,
+    pub(crate) max_size: Vec2,
+
+    default_size: Vec2,
+
+    with_stroke: bool,
+}
+
+impl Default for Resize {
+    fn default() -> Self {
+        Self {
+            id: None,
+            id_source: None,
+            resizable: true,
+            min_size: Vec2::splat(16.0),
+            max_size: Vec2::splat(f32::INFINITY),
+            default_size: vec2(320.0, 128.0), // TODO(emilk): preferred size of [`Resize`] area.
+            with_stroke: true,
+        }
+    }
+}
+
+impl Resize {
+    /// Assign an explicit and globally unique id.
+    pub fn id(mut self, id: Id) -> Self {
+        self.id = Some(id);
+        self
+    }
+
+    /// A source for the unique [`Id`], e.g. `.id_source("second_resize_area")` or `.id_source(loop_index)`.
+    pub fn id_source(mut self, id_source: impl std::hash::Hash) -> Self {
+        self.id_source = Some(Id::new(id_source));
+        self
+    }
+
+    /// Preferred / suggested width. Actual width will depend on contents.
+    ///
+    /// Examples:
+    /// * if the contents is text, this will decide where we break long lines.
+    /// * if the contents is a canvas, this decides the width of it,
+    /// * if the contents is some buttons, this is ignored and we will auto-size.
+    pub fn default_width(mut self, width: f32) -> Self {
+        self.default_size.x = width;
+        self
+    }
+
+    /// Preferred / suggested height. Actual height will depend on contents.
+    ///
+    /// Examples:
+    /// * if the contents is a [`ScrollArea`] then this decides the maximum size.
+    /// * if the contents is a canvas, this decides the height of it,
+    /// * if the contents is text and buttons, then the `default_height` is ignored
+    ///   and the height is picked automatically..
+    pub fn default_height(mut self, height: f32) -> Self {
+        self.default_size.y = height;
+        self
+    }
+
+    pub fn default_size(mut self, default_size: impl Into<Vec2>) -> Self {
+        self.default_size = default_size.into();
+        self
+    }
+
+    /// Won't shrink to smaller than this
+    pub fn min_size(mut self, min_size: impl Into<Vec2>) -> Self {
+        self.min_size = min_size.into();
+        self
+    }
+
+    /// Won't shrink to smaller than this
+    pub fn min_width(mut self, min_width: f32) -> Self {
+        self.min_size.x = min_width;
+        self
+    }
+
+    /// Won't shrink to smaller than this
+    pub fn min_height(mut self, min_height: f32) -> Self {
+        self.min_size.y = min_height;
+        self
+    }
+
+    /// Won't expand to larger than this
+    pub fn max_size(mut self, max_size: impl Into<Vec2>) -> Self {
+        self.max_size = max_size.into();
+        self
+    }
+
+    /// Can you resize it with the mouse?
+    /// Note that a window can still auto-resize
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.resizable = resizable;
+        self
+    }
+
+    pub fn is_resizable(&self) -> bool {
+        self.resizable
+    }
+
+    /// Not manually resizable, just takes the size of its contents.
+    /// Text will not wrap, but will instead make your window width expand.
+    pub fn auto_sized(self) -> Self {
+        self.min_size(Vec2::ZERO)
+            .default_size(Vec2::splat(f32::INFINITY))
+            .resizable(false)
+    }
+
+    pub fn fixed_size(mut self, size: impl Into<Vec2>) -> Self {
+        let size = size.into();
+        self.default_size = size;
+        self.min_size = size;
+        self.max_size = size;
+        self.resizable = false;
+        self
+    }
+
+    pub fn with_stroke(mut self, with_stroke: bool) -> Self {
+        self.with_stroke = with_stroke;
+        self
+    }
+}
+
+struct Prepared {
+    id: Id,
+    state: State,
+    corner_response: Option<Response>,
+    content_ui: Ui,
+}
+
+impl Resize {
+    fn begin(&mut self, ui: &mut Ui) -> Prepared {
+        let position = ui.available_rect_before_wrap().min;
+        let id = self.id.unwrap_or_else(|| {
+            let id_source = self.id_source.unwrap_or_else(|| Id::new("resize"));
+            ui.make_persistent_id(id_source)
+        });
+
+        let mut state = State::load(ui.ctx(), id).unwrap_or_else(|| {
+            ui.ctx().request_repaint(); // counter frame delay
+
+            let default_size = self
+                .default_size
+                .at_least(self.min_size)
+                .at_most(self.max_size)
+                .at_most(
+                    ui.ctx().screen_rect().size() - ui.spacing().window_margin.sum(), // hack for windows
+                );
+
+            State {
+                desired_size: default_size,
+                last_content_size: vec2(0.0, 0.0),
+                requested_size: None,
+            }
+        });
+
+        state.desired_size = state
+            .desired_size
+            .at_least(self.min_size)
+            .at_most(self.max_size);
+
+        let mut user_requested_size = state.requested_size.take();
+
+        let corner_response = if self.resizable {
+            // Resize-corner:
+            let corner_size = Vec2::splat(ui.visuals().resize_corner_size);
+            let corner_rect =
+                Rect::from_min_size(position + state.desired_size - corner_size, corner_size);
+            let corner_response = ui.interact(corner_rect, id.with("corner"), Sense::drag());
+
+            if let Some(pointer_pos) = corner_response.interact_pointer_pos() {
+                user_requested_size =
+                    Some(pointer_pos - position + 0.5 * corner_response.rect.size());
+            }
+
+            Some(corner_response)
+        } else {
+            None
+        };
+
+        if let Some(user_requested_size) = user_requested_size {
+            state.desired_size = user_requested_size;
+        } else {
+            // We are not being actively resized, so auto-expand to include size of last frame.
+            // This prevents auto-shrinking if the contents contain width-filling widgets (separators etc)
+            // but it makes a lot of interactions with [`Window`]s nicer.
+            state.desired_size = state.desired_size.max(state.last_content_size);
+        }
+
+        state.desired_size = state
+            .desired_size
+            .at_least(self.min_size)
+            .at_most(self.max_size);
+
+        // ------------------------------
+
+        let inner_rect = Rect::from_min_size(position, state.desired_size);
+
+        let mut content_clip_rect = inner_rect.expand(ui.visuals().clip_rect_margin);
+
+        // If we pull the resize handle to shrink, we want to TRY to shrink it.
+        // After laying out the contents, we might be much bigger.
+        // In those cases we don't want the clip_rect to be smaller, because
+        // then we will clip the contents of the region even thought the result gets larger. This is simply ugly!
+        // So we use the memory of last_content_size to make the clip rect large enough.
+        content_clip_rect.max = content_clip_rect.max.max(
+            inner_rect.min + state.last_content_size + Vec2::splat(ui.visuals().clip_rect_margin),
+        );
+
+        content_clip_rect = content_clip_rect.intersect(ui.clip_rect()); // Respect parent region
+
+        let mut content_ui = ui.child_ui(inner_rect, *ui.layout());
+        content_ui.set_clip_rect(content_clip_rect);
+
+        Prepared {
+            id,
+            state,
+            corner_response,
+            content_ui,
+        }
+    }
+
+    pub fn show<R>(mut self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> R {
+        let mut prepared = self.begin(ui);
+        let ret = add_contents(&mut prepared.content_ui);
+        self.end(ui, prepared);
+        ret
+    }
+
+    fn end(self, ui: &mut Ui, prepared: Prepared) {
+        let Prepared {
+            id,
+            mut state,
+            corner_response,
+            content_ui,
+        } = prepared;
+
+        state.last_content_size = content_ui.min_size();
+
+        // ------------------------------
+
+        let size = if self.with_stroke || self.resizable {
+            // We show how large we are,
+            // so we must follow the contents:
+
+            state.desired_size = state.desired_size.max(state.last_content_size);
+
+            // We are as large as we look
+            state.desired_size
+        } else {
+            // Probably a window.
+            state.last_content_size
+        };
+        ui.advance_cursor_after_rect(Rect::from_min_size(content_ui.min_rect().min, size));
+
+        // ------------------------------
+
+        if self.with_stroke && corner_response.is_some() {
+            let rect = Rect::from_min_size(content_ui.min_rect().left_top(), state.desired_size);
+            let rect = rect.expand(2.0); // breathing room for content
+            ui.painter().add(Shape::rect_stroke(
+                rect,
+                3.0,
+                ui.visuals().widgets.noninteractive.bg_stroke,
+            ));
+        }
+
+        if let Some(corner_response) = corner_response {
+            paint_resize_corner(ui, &corner_response);
+
+            if corner_response.hovered() || corner_response.dragged() {
+                ui.ctx().set_cursor_icon(CursorIcon::ResizeNwSe);
+            }
+        }
+
+        state.store(ui.ctx(), id);
+
+        if ui.ctx().style().debug.show_resize {
+            ui.ctx().debug_painter().debug_rect(
+                Rect::from_min_size(content_ui.min_rect().left_top(), state.desired_size),
+                Color32::GREEN,
+                "desired_size",
+            );
+            ui.ctx().debug_painter().debug_rect(
+                Rect::from_min_size(content_ui.min_rect().left_top(), state.last_content_size),
+                Color32::LIGHT_BLUE,
+                "last_content_size",
+            );
+        }
+    }
+}
+
+use epaint::Stroke;
+
+pub fn paint_resize_corner(ui: &mut Ui, response: &Response) {
+    let stroke = ui.style().interact(response).fg_stroke;
+    paint_resize_corner_with_style(ui, &response.rect, stroke, Align2::RIGHT_BOTTOM);
+}
+
+pub fn paint_resize_corner_with_style(ui: &mut Ui, rect: &Rect, stroke: Stroke, corner: Align2) {
+    let painter = ui.painter();
+    let cp = painter.round_pos_to_pixels(corner.pos_in_rect(rect));
+    let mut w = 2.0;
+
+    while w <= rect.width() && w <= rect.height() {
+        painter.line_segment(
+            [
+                pos2(cp.x - w * corner.x().to_sign(), cp.y),
+                pos2(cp.x, cp.y - w * corner.y().to_sign()),
+            ],
+            stroke,
+        );
+        w += 4.0;
+    }
+}
diff --git a/egui/crates/egui/src/containers/scroll_area.rs b/egui/crates/egui/src/containers/scroll_area.rs
new file mode 100644
index 0000000..2f67bf3
--- /dev/null
+++ b/egui/crates/egui/src/containers/scroll_area.rs
@@ -0,0 +1,924 @@
+//! Coordinate system names:
+//! * content: size of contents (generally large; that's why we want scroll bars)
+//! * outer: size of scroll area including scroll bar(s)
+//! * inner: excluding scroll bar(s). The area we clip the contents to.
+
+#![allow(clippy::needless_range_loop)]
+
+use crate::*;
+
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct State {
+    /// Positive offset means scrolling down/right
+    pub offset: Vec2,
+
+    /// Were the scroll bars visible last frame?
+    show_scroll: [bool; 2],
+
+    /// The content were to large to fit large frame.
+    content_is_too_large: [bool; 2],
+
+    /// Momentum, used for kinetic scrolling
+    #[cfg_attr(feature = "serde", serde(skip))]
+    vel: Vec2,
+
+    /// Mouse offset relative to the top of the handle when started moving the handle.
+    scroll_start_offset_from_top_left: [Option<f32>; 2],
+
+    /// Is the scroll sticky. This is true while scroll handle is in the end position
+    /// and remains that way until the user moves the scroll_handle. Once unstuck (false)
+    /// it remains false until the scroll touches the end position, which reenables stickiness.
+    scroll_stuck_to_end: [bool; 2],
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            offset: Vec2::ZERO,
+            show_scroll: [false; 2],
+            content_is_too_large: [false; 2],
+            vel: Vec2::ZERO,
+            scroll_start_offset_from_top_left: [None; 2],
+            scroll_stuck_to_end: [true; 2],
+        }
+    }
+}
+
+impl State {
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        ctx.data_mut(|d| d.get_persisted(id))
+    }
+
+    pub fn store(self, ctx: &Context, id: Id) {
+        ctx.data_mut(|d| d.insert_persisted(id, self));
+    }
+}
+
+pub struct ScrollAreaOutput<R> {
+    /// What the user closure returned.
+    pub inner: R,
+
+    /// [`Id`] of the [`ScrollArea`].
+    pub id: Id,
+
+    /// The current state of the scroll area.
+    pub state: State,
+
+    /// The size of the content. If this is larger than [`Self::inner_rect`],
+    /// then there was need for scrolling.
+    pub content_size: Vec2,
+
+    /// Where on the screen the content is (excludes scroll bars).
+    pub inner_rect: Rect,
+}
+
+/// Indicate whether the horizontal and vertical scroll bars must be always visible, hidden or visible when needed.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ScrollBarVisibility {
+    AlwaysVisible,
+    VisibleWhenNeeded,
+    AlwaysHidden,
+}
+
+/// Add vertical and/or horizontal scrolling to a contained [`Ui`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// egui::ScrollArea::vertical().show(ui, |ui| {
+///     // Add a lot of widgets here.
+/// });
+/// # });
+/// ```
+///
+/// You can scroll to an element using [`Response::scroll_to_me`], [`Ui::scroll_to_cursor`] and [`Ui::scroll_to_rect`].
+#[derive(Clone, Debug)]
+#[must_use = "You should call .show()"]
+pub struct ScrollArea {
+    /// Do we have horizontal/vertical scrolling?
+    has_bar: [bool; 2],
+    auto_shrink: [bool; 2],
+    max_size: Vec2,
+    min_scrolled_size: Vec2,
+    scroll_bar_visibility: ScrollBarVisibility,
+    id_source: Option<Id>,
+    offset_x: Option<f32>,
+    offset_y: Option<f32>,
+
+    /// If false, we ignore scroll events.
+    scrolling_enabled: bool,
+    drag_to_scroll: bool,
+
+    /// If true for vertical or horizontal the scroll wheel will stick to the
+    /// end position until user manually changes position. It will become true
+    /// again once scroll handle makes contact with end.
+    stick_to_end: [bool; 2],
+}
+
+impl ScrollArea {
+    /// Create a horizontal scroll area.
+    pub fn horizontal() -> Self {
+        Self::new([true, false])
+    }
+
+    /// Create a vertical scroll area.
+    pub fn vertical() -> Self {
+        Self::new([false, true])
+    }
+
+    /// Create a bi-directional (horizontal and vertical) scroll area.
+    pub fn both() -> Self {
+        Self::new([true, true])
+    }
+
+    /// Create a scroll area where both direction of scrolling is disabled.
+    /// It's unclear why you would want to do this.
+    pub fn neither() -> Self {
+        Self::new([false, false])
+    }
+
+    /// Create a scroll area where you decide which axis has scrolling enabled.
+    /// For instance, `ScrollArea::new([true, false])` enables horizontal scrolling.
+    pub fn new(has_bar: [bool; 2]) -> Self {
+        Self {
+            has_bar,
+            auto_shrink: [true; 2],
+            max_size: Vec2::INFINITY,
+            min_scrolled_size: Vec2::splat(64.0),
+            scroll_bar_visibility: ScrollBarVisibility::VisibleWhenNeeded,
+            id_source: None,
+            offset_x: None,
+            offset_y: None,
+            scrolling_enabled: true,
+            drag_to_scroll: true,
+            stick_to_end: [false; 2],
+        }
+    }
+
+    /// The maximum width of the outer frame of the scroll area.
+    ///
+    /// Use `f32::INFINITY` if you want the scroll area to expand to fit the surrounding [`Ui`] (default).
+    ///
+    /// See also [`Self::auto_shrink`].
+    pub fn max_width(mut self, max_width: f32) -> Self {
+        self.max_size.x = max_width;
+        self
+    }
+
+    /// The maximum height of the outer frame of the scroll area.
+    ///
+    /// Use `f32::INFINITY` if you want the scroll area to expand to fit the surrounding [`Ui`] (default).
+    ///
+    /// See also [`Self::auto_shrink`].
+    pub fn max_height(mut self, max_height: f32) -> Self {
+        self.max_size.y = max_height;
+        self
+    }
+
+    /// The minimum width of a horizontal scroll area which requires scroll bars.
+    ///
+    /// The [`ScrollArea`] will only become smaller than this if the content is smaller than this
+    /// (and so we don't require scroll bars).
+    ///
+    /// Default: `64.0`.
+    pub fn min_scrolled_width(mut self, min_scrolled_width: f32) -> Self {
+        self.min_scrolled_size.x = min_scrolled_width;
+        self
+    }
+
+    /// The minimum height of a vertical scroll area which requires scroll bars.
+    ///
+    /// The [`ScrollArea`] will only become smaller than this if the content is smaller than this
+    /// (and so we don't require scroll bars).
+    ///
+    /// Default: `64.0`.
+    pub fn min_scrolled_height(mut self, min_scrolled_height: f32) -> Self {
+        self.min_scrolled_size.y = min_scrolled_height;
+        self
+    }
+
+    /// Set the visibility of both horizontal and vertical scroll bars.
+    ///
+    /// With `ScrollBarVisibility::VisibleWhenNeeded` (default), the scroll bar will be visible only when needed.
+    pub fn scroll_bar_visibility(mut self, scroll_bar_visibility: ScrollBarVisibility) -> Self {
+        self.scroll_bar_visibility = scroll_bar_visibility;
+        self
+    }
+
+    /// A source for the unique [`Id`], e.g. `.id_source("second_scroll_area")` or `.id_source(loop_index)`.
+    pub fn id_source(mut self, id_source: impl std::hash::Hash) -> Self {
+        self.id_source = Some(Id::new(id_source));
+        self
+    }
+
+    /// Set the horizontal and vertical scroll offset position.
+    ///
+    /// Positive offset means scrolling down/right.
+    ///
+    /// See also: [`Self::vertical_scroll_offset`], [`Self::horizontal_scroll_offset`],
+    /// [`Ui::scroll_to_cursor`](crate::ui::Ui::scroll_to_cursor) and
+    /// [`Response::scroll_to_me`](crate::Response::scroll_to_me)
+    pub fn scroll_offset(mut self, offset: Vec2) -> Self {
+        self.offset_x = Some(offset.x);
+        self.offset_y = Some(offset.y);
+        self
+    }
+
+    /// Set the vertical scroll offset position.
+    ///
+    /// Positive offset means scrolling down.
+    ///
+    /// See also: [`Self::scroll_offset`], [`Ui::scroll_to_cursor`](crate::ui::Ui::scroll_to_cursor) and
+    /// [`Response::scroll_to_me`](crate::Response::scroll_to_me)
+    pub fn vertical_scroll_offset(mut self, offset: f32) -> Self {
+        self.offset_y = Some(offset);
+        self
+    }
+
+    /// Set the horizontal scroll offset position.
+    ///
+    /// Positive offset means scrolling right.
+    ///
+    /// See also: [`Self::scroll_offset`], [`Ui::scroll_to_cursor`](crate::ui::Ui::scroll_to_cursor) and
+    /// [`Response::scroll_to_me`](crate::Response::scroll_to_me)
+    pub fn horizontal_scroll_offset(mut self, offset: f32) -> Self {
+        self.offset_x = Some(offset);
+        self
+    }
+
+    /// Turn on/off scrolling on the horizontal axis.
+    pub fn hscroll(mut self, hscroll: bool) -> Self {
+        self.has_bar[0] = hscroll;
+        self
+    }
+
+    /// Turn on/off scrolling on the vertical axis.
+    pub fn vscroll(mut self, vscroll: bool) -> Self {
+        self.has_bar[1] = vscroll;
+        self
+    }
+
+    /// Turn on/off scrolling on the horizontal/vertical axes.
+    pub fn scroll2(mut self, has_bar: [bool; 2]) -> Self {
+        self.has_bar = has_bar;
+        self
+    }
+
+    /// Control the scrolling behavior.
+    ///
+    /// * If `true` (default), the scroll area will respond to user scrolling.
+    /// * If `false`, the scroll area will not respond to user scrolling.
+    ///
+    /// This can be used, for example, to optionally freeze scrolling while the user
+    /// is typing text in a [`TextEdit`] widget contained within the scroll area.
+    ///
+    /// This controls both scrolling directions.
+    pub fn enable_scrolling(mut self, enable: bool) -> Self {
+        self.scrolling_enabled = enable;
+        self
+    }
+
+    /// Can the user drag the scroll area to scroll?
+    ///
+    /// This is useful for touch screens.
+    ///
+    /// If `true`, the [`ScrollArea`] will sense drags.
+    ///
+    /// Default: `true`.
+    pub fn drag_to_scroll(mut self, drag_to_scroll: bool) -> Self {
+        self.drag_to_scroll = drag_to_scroll;
+        self
+    }
+
+    /// For each axis, should the containing area shrink if the content is small?
+    ///
+    /// * If `true`, egui will add blank space outside the scroll area.
+    /// * If `false`, egui will add blank space inside the scroll area.
+    ///
+    /// Default: `[true; 2]`.
+    pub fn auto_shrink(mut self, auto_shrink: [bool; 2]) -> Self {
+        self.auto_shrink = auto_shrink;
+        self
+    }
+
+    pub(crate) fn has_any_bar(&self) -> bool {
+        self.has_bar[0] || self.has_bar[1]
+    }
+
+    /// The scroll handle will stick to the rightmost position even while the content size
+    /// changes dynamically. This can be useful to simulate text scrollers coming in from right
+    /// hand side. The scroll handle remains stuck until user manually changes position. Once "unstuck"
+    /// it will remain focused on whatever content viewport the user left it on. If the scroll
+    /// handle is dragged all the way to the right it will again become stuck and remain there
+    /// until manually pulled from the end position.
+    pub fn stick_to_right(mut self, stick: bool) -> Self {
+        self.stick_to_end[0] = stick;
+        self
+    }
+
+    /// The scroll handle will stick to the bottom position even while the content size
+    /// changes dynamically. This can be useful to simulate terminal UIs or log/info scrollers.
+    /// The scroll handle remains stuck until user manually changes position. Once "unstuck"
+    /// it will remain focused on whatever content viewport the user left it on. If the scroll
+    /// handle is dragged to the bottom it will again become stuck and remain there until manually
+    /// pulled from the end position.
+    pub fn stick_to_bottom(mut self, stick: bool) -> Self {
+        self.stick_to_end[1] = stick;
+        self
+    }
+}
+
+struct Prepared {
+    id: Id,
+    state: State,
+    has_bar: [bool; 2],
+    auto_shrink: [bool; 2],
+    /// How much horizontal and vertical space are used up by the
+    /// width of the vertical bar, and the height of the horizontal bar?
+    current_bar_use: Vec2,
+    scroll_bar_visibility: ScrollBarVisibility,
+    /// Where on the screen the content is (excludes scroll bars).
+    inner_rect: Rect,
+    content_ui: Ui,
+    /// Relative coordinates: the offset and size of the view of the inner UI.
+    /// `viewport.min == ZERO` means we scrolled to the top.
+    viewport: Rect,
+    scrolling_enabled: bool,
+    stick_to_end: [bool; 2],
+}
+
+impl ScrollArea {
+    fn begin(self, ui: &mut Ui) -> Prepared {
+        let Self {
+            has_bar,
+            auto_shrink,
+            max_size,
+            min_scrolled_size,
+            scroll_bar_visibility,
+            id_source,
+            offset_x,
+            offset_y,
+            scrolling_enabled,
+            drag_to_scroll,
+            stick_to_end,
+        } = self;
+
+        let ctx = ui.ctx().clone();
+
+        let id_source = id_source.unwrap_or_else(|| Id::new("scroll_area"));
+        let id = ui.make_persistent_id(id_source);
+        ui.ctx().check_for_id_clash(
+            id,
+            Rect::from_min_size(ui.available_rect_before_wrap().min, Vec2::ZERO),
+            "ScrollArea",
+        );
+        let mut state = State::load(&ctx, id).unwrap_or_default();
+
+        state.offset.x = offset_x.unwrap_or(state.offset.x);
+        state.offset.y = offset_y.unwrap_or(state.offset.y);
+
+        let max_scroll_bar_width = max_scroll_bar_width_with_margin(ui);
+
+        let current_hscroll_bar_height = if !has_bar[0] {
+            0.0
+        } else if scroll_bar_visibility == ScrollBarVisibility::AlwaysVisible {
+            max_scroll_bar_width
+        } else {
+            max_scroll_bar_width * ui.ctx().animate_bool(id.with("h"), state.show_scroll[0])
+        };
+
+        let current_vscroll_bar_width = if !has_bar[1] {
+            0.0
+        } else if scroll_bar_visibility == ScrollBarVisibility::AlwaysVisible {
+            max_scroll_bar_width
+        } else {
+            max_scroll_bar_width * ui.ctx().animate_bool(id.with("v"), state.show_scroll[1])
+        };
+
+        let current_bar_use = vec2(current_vscroll_bar_width, current_hscroll_bar_height);
+
+        let available_outer = ui.available_rect_before_wrap();
+
+        let outer_size = available_outer.size().at_most(max_size);
+
+        let inner_size = {
+            let mut inner_size = outer_size - current_bar_use;
+
+            // Don't go so far that we shrink to zero.
+            // In particular, if we put a [`ScrollArea`] inside of a [`ScrollArea`], the inner
+            // one shouldn't collapse into nothingness.
+            // See https://github.com/emilk/egui/issues/1097
+            for d in 0..2 {
+                if has_bar[d] {
+                    inner_size[d] = inner_size[d].max(min_scrolled_size[d]);
+                }
+            }
+            inner_size
+        };
+
+        let inner_rect = Rect::from_min_size(available_outer.min, inner_size);
+
+        let mut content_max_size = inner_size;
+
+        if true {
+            // Tell the inner Ui to *try* to fit the content without needing to scroll,
+            // i.e. better to wrap text and shrink images than showing a horizontal scrollbar!
+        } else {
+            // Tell the inner Ui to use as much space as possible, we can scroll to see it!
+            for d in 0..2 {
+                if has_bar[d] {
+                    content_max_size[d] = f32::INFINITY;
+                }
+            }
+        }
+
+        let content_max_rect = Rect::from_min_size(inner_rect.min - state.offset, content_max_size);
+        let mut content_ui = ui.child_ui(content_max_rect, *ui.layout());
+
+        {
+            // Clip the content, but only when we really need to:
+            let clip_rect_margin = ui.visuals().clip_rect_margin;
+            let scroll_bar_inner_margin = ui.spacing().scroll_bar_inner_margin;
+            let mut content_clip_rect = ui.clip_rect();
+            for d in 0..2 {
+                if has_bar[d] {
+                    if state.content_is_too_large[d] {
+                        content_clip_rect.min[d] = inner_rect.min[d] - clip_rect_margin;
+                        content_clip_rect.max[d] = inner_rect.max[d] + clip_rect_margin;
+                    }
+
+                    if state.show_scroll[d] {
+                        // Make sure content doesn't cover scroll bars
+                        let tiny_gap = 1.0;
+                        content_clip_rect.max[1 - d] =
+                            inner_rect.max[1 - d] + scroll_bar_inner_margin - tiny_gap;
+                    }
+                } else {
+                    // Nice handling of forced resizing beyond the possible:
+                    content_clip_rect.max[d] = ui.clip_rect().max[d] - current_bar_use[d];
+                }
+            }
+            // Make sure we din't accidentally expand the clip rect
+            content_clip_rect = content_clip_rect.intersect(ui.clip_rect());
+            content_ui.set_clip_rect(content_clip_rect);
+        }
+
+        let viewport = Rect::from_min_size(Pos2::ZERO + state.offset, inner_size);
+
+        if (scrolling_enabled && drag_to_scroll)
+            && (state.content_is_too_large[0] || state.content_is_too_large[1])
+        {
+            // Drag contents to scroll (for touch screens mostly).
+            // We must do this BEFORE adding content to the `ScrollArea`,
+            // or we will steal input from the widgets we contain.
+            let content_response = ui.interact(inner_rect, id.with("area"), Sense::drag());
+
+            if content_response.dragged() {
+                for d in 0..2 {
+                    if has_bar[d] {
+                        ui.input(|input| {
+                            state.offset[d] -= input.pointer.delta()[d];
+                            state.vel[d] = input.pointer.velocity()[d];
+                        });
+                        state.scroll_stuck_to_end[d] = false;
+                    } else {
+                        state.vel[d] = 0.0;
+                    }
+                }
+            } else {
+                let stop_speed = 20.0; // Pixels per second.
+                let friction_coeff = 1000.0; // Pixels per second squared.
+                let dt = ui.input(|i| i.unstable_dt);
+
+                let friction = friction_coeff * dt;
+                if friction > state.vel.length() || state.vel.length() < stop_speed {
+                    state.vel = Vec2::ZERO;
+                } else {
+                    state.vel -= friction * state.vel.normalized();
+                    // Offset has an inverted coordinate system compared to
+                    // the velocity, so we subtract it instead of adding it
+                    state.offset -= state.vel * dt;
+                    ui.ctx().request_repaint();
+                }
+            }
+        }
+
+        Prepared {
+            id,
+            state,
+            has_bar,
+            auto_shrink,
+            current_bar_use,
+            scroll_bar_visibility,
+            inner_rect,
+            content_ui,
+            viewport,
+            scrolling_enabled,
+            stick_to_end,
+        }
+    }
+
+    /// Show the [`ScrollArea`], and add the contents to the viewport.
+    ///
+    /// If the inner area can be very long, consider using [`Self::show_rows`] instead.
+    pub fn show<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> ScrollAreaOutput<R> {
+        self.show_viewport_dyn(ui, Box::new(|ui, _viewport| add_contents(ui)))
+    }
+
+    /// Efficiently show only the visible part of a large number of rows.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// let text_style = egui::TextStyle::Body;
+    /// let row_height = ui.text_style_height(&text_style);
+    /// // let row_height = ui.spacing().interact_size.y; // if you are adding buttons instead of labels.
+    /// let total_rows = 10_000;
+    /// egui::ScrollArea::vertical().show_rows(ui, row_height, total_rows, |ui, row_range| {
+    ///     for row in row_range {
+    ///         let text = format!("Row {}/{}", row + 1, total_rows);
+    ///         ui.label(text);
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn show_rows<R>(
+        self,
+        ui: &mut Ui,
+        row_height_sans_spacing: f32,
+        total_rows: usize,
+        add_contents: impl FnOnce(&mut Ui, std::ops::Range<usize>) -> R,
+    ) -> ScrollAreaOutput<R> {
+        let spacing = ui.spacing().item_spacing;
+        let row_height_with_spacing = row_height_sans_spacing + spacing.y;
+        self.show_viewport(ui, |ui, viewport| {
+            ui.set_height((row_height_with_spacing * total_rows as f32 - spacing.y).at_least(0.0));
+
+            let mut min_row = (viewport.min.y / row_height_with_spacing).floor() as usize;
+            let mut max_row = (viewport.max.y / row_height_with_spacing).ceil() as usize + 1;
+            if max_row > total_rows {
+                let diff = max_row.saturating_sub(min_row);
+                max_row = total_rows;
+                min_row = total_rows.saturating_sub(diff);
+            }
+
+            let y_min = ui.max_rect().top() + min_row as f32 * row_height_with_spacing;
+            let y_max = ui.max_rect().top() + max_row as f32 * row_height_with_spacing;
+
+            let rect = Rect::from_x_y_ranges(ui.max_rect().x_range(), y_min..=y_max);
+
+            ui.allocate_ui_at_rect(rect, |viewport_ui| {
+                viewport_ui.skip_ahead_auto_ids(min_row); // Make sure we get consistent IDs.
+                add_contents(viewport_ui, min_row..max_row)
+            })
+            .inner
+        })
+    }
+
+    /// This can be used to only paint the visible part of the contents.
+    ///
+    /// `add_contents` is given the viewport rectangle, which is the relative view of the content.
+    /// So if the passed rect has min = zero, then show the top left content (the user has not scrolled).
+    pub fn show_viewport<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui, Rect) -> R,
+    ) -> ScrollAreaOutput<R> {
+        self.show_viewport_dyn(ui, Box::new(add_contents))
+    }
+
+    fn show_viewport_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_contents: Box<dyn FnOnce(&mut Ui, Rect) -> R + 'c>,
+    ) -> ScrollAreaOutput<R> {
+        let mut prepared = self.begin(ui);
+        let id = prepared.id;
+        let inner_rect = prepared.inner_rect;
+        let inner = add_contents(&mut prepared.content_ui, prepared.viewport);
+        let (content_size, state) = prepared.end(ui);
+        ScrollAreaOutput {
+            inner,
+            id,
+            state,
+            content_size,
+            inner_rect,
+        }
+    }
+}
+
+impl Prepared {
+    /// Returns content size and state
+    fn end(self, ui: &mut Ui) -> (Vec2, State) {
+        let Prepared {
+            id,
+            mut state,
+            inner_rect,
+            has_bar,
+            auto_shrink,
+            mut current_bar_use,
+            scroll_bar_visibility,
+            content_ui,
+            viewport: _,
+            scrolling_enabled,
+            stick_to_end,
+        } = self;
+
+        let content_size = content_ui.min_size();
+
+        for d in 0..2 {
+            if has_bar[d] {
+                // We take the scroll target so only this ScrollArea will use it:
+                let scroll_target = content_ui
+                    .ctx()
+                    .frame_state_mut(|state| state.scroll_target[d].take());
+                if let Some((scroll, align)) = scroll_target {
+                    let min = content_ui.min_rect().min[d];
+                    let clip_rect = content_ui.clip_rect();
+                    let visible_range = min..=min + clip_rect.size()[d];
+                    let start = *scroll.start();
+                    let end = *scroll.end();
+                    let clip_start = clip_rect.min[d];
+                    let clip_end = clip_rect.max[d];
+                    let mut spacing = ui.spacing().item_spacing[d];
+
+                    let delta = if let Some(align) = align {
+                        let center_factor = align.to_factor();
+
+                        let offset =
+                            lerp(scroll, center_factor) - lerp(visible_range, center_factor);
+
+                        // Depending on the alignment we need to add or subtract the spacing
+                        spacing *= remap(center_factor, 0.0..=1.0, -1.0..=1.0);
+
+                        offset + spacing - state.offset[d]
+                    } else if start < clip_start && end < clip_end {
+                        -(clip_start - start + spacing).min(clip_end - end - spacing)
+                    } else if end > clip_end && start > clip_start {
+                        (end - clip_end + spacing).min(start - clip_start - spacing)
+                    } else {
+                        // Ui is already in view, no need to adjust scroll.
+                        0.0
+                    };
+
+                    if delta != 0.0 {
+                        state.offset[d] += delta;
+                        ui.ctx().request_repaint();
+                    }
+                }
+            }
+        }
+
+        let inner_rect = {
+            // At this point this is the available size for the inner rect.
+            let mut inner_size = inner_rect.size();
+
+            for d in 0..2 {
+                inner_size[d] = match (has_bar[d], auto_shrink[d]) {
+                    (true, true) => inner_size[d].min(content_size[d]), // shrink scroll area if content is small
+                    (true, false) => inner_size[d], // let scroll area be larger than content; fill with blank space
+                    (false, true) => content_size[d], // Follow the content (expand/contract to fit it).
+                    (false, false) => inner_size[d].max(content_size[d]), // Expand to fit content
+                };
+            }
+
+            Rect::from_min_size(inner_rect.min, inner_size)
+        };
+
+        let outer_rect = Rect::from_min_size(inner_rect.min, inner_rect.size() + current_bar_use);
+
+        let content_is_too_large = [
+            content_size.x > inner_rect.width(),
+            content_size.y > inner_rect.height(),
+        ];
+
+        let max_offset = content_size - inner_rect.size();
+        if scrolling_enabled && ui.rect_contains_pointer(outer_rect) {
+            for d in 0..2 {
+                if has_bar[d] {
+                    let scroll_delta = ui.ctx().frame_state(|fs| fs.scroll_delta);
+
+                    let scrolling_up = state.offset[d] > 0.0 && scroll_delta[d] > 0.0;
+                    let scrolling_down = state.offset[d] < max_offset[d] && scroll_delta[d] < 0.0;
+
+                    if scrolling_up || scrolling_down {
+                        state.offset[d] -= scroll_delta[d];
+                        // Clear scroll delta so no parent scroll will use it.
+                        ui.ctx().frame_state_mut(|fs| fs.scroll_delta[d] = 0.0);
+                        state.scroll_stuck_to_end[d] = false;
+                    }
+                }
+            }
+        }
+
+        let show_scroll_this_frame = match scroll_bar_visibility {
+            ScrollBarVisibility::AlwaysVisible => [true, true],
+            ScrollBarVisibility::VisibleWhenNeeded => {
+                [content_is_too_large[0], content_is_too_large[1]]
+            }
+            ScrollBarVisibility::AlwaysHidden => [false, false],
+        };
+
+        let max_scroll_bar_width = max_scroll_bar_width_with_margin(ui);
+
+        // Avoid frame delay; start showing scroll bar right away:
+        if show_scroll_this_frame[0] && current_bar_use.y <= 0.0 {
+            current_bar_use.y = max_scroll_bar_width * ui.ctx().animate_bool(id.with("h"), true);
+        }
+        if show_scroll_this_frame[1] && current_bar_use.x <= 0.0 {
+            current_bar_use.x = max_scroll_bar_width * ui.ctx().animate_bool(id.with("v"), true);
+        }
+
+        for d in 0..2 {
+            let animation_t = current_bar_use[1 - d] / max_scroll_bar_width;
+
+            if animation_t == 0.0 {
+                continue;
+            }
+
+            // margin on either side of the scroll bar
+            let inner_margin = animation_t * ui.spacing().scroll_bar_inner_margin;
+            let outer_margin = animation_t * ui.spacing().scroll_bar_outer_margin;
+            let mut min_cross = inner_rect.max[1 - d] + inner_margin; // left of vertical scroll (d == 1)
+            let mut max_cross = outer_rect.max[1 - d] - outer_margin; // right of vertical scroll (d == 1)
+            let min_main = inner_rect.min[d]; // top of vertical scroll (d == 1)
+            let max_main = inner_rect.max[d]; // bottom of vertical scroll (d == 1)
+
+            if ui.clip_rect().max[1 - d] < max_cross + outer_margin {
+                // Move the scrollbar so it is visible. This is needed in some cases.
+                // For instance:
+                // * When we have a vertical-only scroll area in a top level panel,
+                //   and that panel is not wide enough for the contents.
+                // * When one ScrollArea is nested inside another, and the outer
+                //   is scrolled so that the scroll-bars of the inner ScrollArea (us)
+                //   is outside the clip rectangle.
+                // Really this should use the tighter clip_rect that ignores clip_rect_margin, but we don't store that.
+                // clip_rect_margin is quite a hack. It would be nice to get rid of it.
+                let width = max_cross - min_cross;
+                max_cross = ui.clip_rect().max[1 - d] - outer_margin;
+                min_cross = max_cross - width;
+            }
+
+            let outer_scroll_rect = if d == 0 {
+                Rect::from_min_max(
+                    pos2(inner_rect.left(), min_cross),
+                    pos2(inner_rect.right(), max_cross),
+                )
+            } else {
+                Rect::from_min_max(
+                    pos2(min_cross, inner_rect.top()),
+                    pos2(max_cross, inner_rect.bottom()),
+                )
+            };
+
+            // maybe force increase in offset to keep scroll stuck to end position
+            if stick_to_end[d] && state.scroll_stuck_to_end[d] {
+                state.offset[d] = content_size[d] - inner_rect.size()[d];
+            }
+
+            let from_content =
+                |content| remap_clamp(content, 0.0..=content_size[d], min_main..=max_main);
+
+            let handle_rect = if d == 0 {
+                Rect::from_min_max(
+                    pos2(from_content(state.offset.x), min_cross),
+                    pos2(from_content(state.offset.x + inner_rect.width()), max_cross),
+                )
+            } else {
+                Rect::from_min_max(
+                    pos2(min_cross, from_content(state.offset.y)),
+                    pos2(
+                        max_cross,
+                        from_content(state.offset.y + inner_rect.height()),
+                    ),
+                )
+            };
+
+            let interact_id = id.with(d);
+            let sense = if self.scrolling_enabled {
+                Sense::click_and_drag()
+            } else {
+                Sense::hover()
+            };
+            let response = ui.interact(outer_scroll_rect, interact_id, sense);
+
+            if let Some(pointer_pos) = response.interact_pointer_pos() {
+                let scroll_start_offset_from_top_left = state.scroll_start_offset_from_top_left[d]
+                    .get_or_insert_with(|| {
+                        if handle_rect.contains(pointer_pos) {
+                            pointer_pos[d] - handle_rect.min[d]
+                        } else {
+                            let handle_top_pos_at_bottom = max_main - handle_rect.size()[d];
+                            // Calculate the new handle top position, centering the handle on the mouse.
+                            let new_handle_top_pos = (pointer_pos[d] - handle_rect.size()[d] / 2.0)
+                                .clamp(min_main, handle_top_pos_at_bottom);
+                            pointer_pos[d] - new_handle_top_pos
+                        }
+                    });
+
+                let new_handle_top = pointer_pos[d] - *scroll_start_offset_from_top_left;
+                state.offset[d] = remap(new_handle_top, min_main..=max_main, 0.0..=content_size[d]);
+
+                // some manual action taken, scroll not stuck
+                state.scroll_stuck_to_end[d] = false;
+            } else {
+                state.scroll_start_offset_from_top_left[d] = None;
+            }
+
+            let unbounded_offset = state.offset[d];
+            state.offset[d] = state.offset[d].max(0.0);
+            state.offset[d] = state.offset[d].min(max_offset[d]);
+
+            if state.offset[d] != unbounded_offset {
+                state.vel[d] = 0.0;
+            }
+
+            if ui.is_rect_visible(outer_scroll_rect) {
+                // Avoid frame-delay by calculating a new handle rect:
+                let mut handle_rect = if d == 0 {
+                    Rect::from_min_max(
+                        pos2(from_content(state.offset.x), min_cross),
+                        pos2(from_content(state.offset.x + inner_rect.width()), max_cross),
+                    )
+                } else {
+                    Rect::from_min_max(
+                        pos2(min_cross, from_content(state.offset.y)),
+                        pos2(
+                            max_cross,
+                            from_content(state.offset.y + inner_rect.height()),
+                        ),
+                    )
+                };
+                let min_handle_size = ui.spacing().scroll_handle_min_length;
+                if handle_rect.size()[d] < min_handle_size {
+                    handle_rect = Rect::from_center_size(
+                        handle_rect.center(),
+                        if d == 0 {
+                            vec2(min_handle_size, handle_rect.size().y)
+                        } else {
+                            vec2(handle_rect.size().x, min_handle_size)
+                        },
+                    );
+                }
+
+                let visuals = if scrolling_enabled {
+                    ui.style().interact(&response)
+                } else {
+                    &ui.style().visuals.widgets.inactive
+                };
+
+                ui.painter().add(epaint::Shape::rect_filled(
+                    outer_scroll_rect,
+                    visuals.rounding,
+                    ui.visuals().extreme_bg_color,
+                ));
+
+                ui.painter().add(epaint::Shape::rect_filled(
+                    handle_rect,
+                    visuals.rounding,
+                    visuals.bg_fill,
+                ));
+            }
+        }
+
+        ui.advance_cursor_after_rect(outer_rect);
+
+        if show_scroll_this_frame != state.show_scroll {
+            ui.ctx().request_repaint();
+        }
+
+        let available_offset = content_size - inner_rect.size();
+        state.offset = state.offset.min(available_offset);
+        state.offset = state.offset.max(Vec2::ZERO);
+
+        // Is scroll handle at end of content, or is there no scrollbar
+        // yet (not enough content), but sticking is requested? If so, enter sticky mode.
+        // Only has an effect if stick_to_end is enabled but we save in
+        // state anyway so that entering sticky mode at an arbitrary time
+        // has appropriate effect.
+        state.scroll_stuck_to_end = [
+            (state.offset[0] == available_offset[0])
+                || (self.stick_to_end[0] && available_offset[0] < 0.),
+            (state.offset[1] == available_offset[1])
+                || (self.stick_to_end[1] && available_offset[1] < 0.),
+        ];
+
+        state.show_scroll = show_scroll_this_frame;
+        state.content_is_too_large = content_is_too_large;
+
+        state.store(ui.ctx(), id);
+
+        (content_size, state)
+    }
+}
+
+/// Width of a vertical scrollbar, or height of a horizontal scroll bar
+fn max_scroll_bar_width_with_margin(ui: &Ui) -> f32 {
+    ui.spacing().scroll_bar_inner_margin
+        + ui.spacing().scroll_bar_width
+        + ui.spacing().scroll_bar_outer_margin
+}
diff --git a/egui/crates/egui/src/containers/window.rs b/egui/crates/egui/src/containers/window.rs
new file mode 100644
index 0000000..d5c3f68
--- /dev/null
+++ b/egui/crates/egui/src/containers/window.rs
@@ -0,0 +1,982 @@
+// WARNING: the code in here is horrible. It is a behemoth that needs breaking up into simpler parts.
+
+use crate::collapsing_header::CollapsingState;
+use crate::{widget_text::WidgetTextGalley, *};
+use epaint::*;
+
+use super::*;
+
+/// Builder for a floating window which can be dragged, closed, collapsed, resized and scrolled (off by default).
+///
+/// You can customize:
+/// * title
+/// * default, minimum, maximum and/or fixed size, collapsed/expanded
+/// * if the window has a scroll area (off by default)
+/// * if the window can be collapsed (minimized) to just the title bar (yes, by default)
+/// * if there should be a close button (none by default)
+///
+/// ```
+/// # egui::__run_test_ctx(|ctx| {
+/// egui::Window::new("My Window").show(ctx, |ui| {
+///    ui.label("Hello World!");
+/// });
+/// # });
+#[must_use = "You should call .show()"]
+pub struct Window<'open> {
+    title: WidgetText,
+    open: Option<&'open mut bool>,
+    area: Area,
+    frame: Option<Frame>,
+    resize: Resize,
+    scroll: ScrollArea,
+    collapsible: bool,
+    default_open: bool,
+    with_title_bar: bool,
+}
+
+impl<'open> Window<'open> {
+    /// The window title is used as a unique [`Id`] and must be unique, and should not change.
+    /// This is true even if you disable the title bar with `.title_bar(false)`.
+    /// If you need a changing title, you must call `window.id(…)` with a fixed id.
+    pub fn new(title: impl Into<WidgetText>) -> Self {
+        let title = title.into().fallback_text_style(TextStyle::Heading);
+        let area = Area::new(Id::new(title.text()));
+        Self {
+            title,
+            open: None,
+            area,
+            frame: None,
+            resize: Resize::default()
+                .with_stroke(false)
+                .min_size([96.0, 32.0])
+                .default_size([340.0, 420.0]), // Default inner size of a window
+            scroll: ScrollArea::neither(),
+            collapsible: true,
+            default_open: true,
+            with_title_bar: true,
+        }
+    }
+
+    /// Assign a unique id to the Window. Required if the title changes, or is shared with another window.
+    pub fn id(mut self, id: Id) -> Self {
+        self.area = self.area.id(id);
+        self
+    }
+
+    /// Call this to add a close-button to the window title bar.
+    ///
+    /// * If `*open == false`, the window will not be visible.
+    /// * If `*open == true`, the window will have a close button.
+    /// * If the close button is pressed, `*open` will be set to `false`.
+    pub fn open(mut self, open: &'open mut bool) -> Self {
+        self.open = Some(open);
+        self
+    }
+
+    /// If `false` the window will be grayed out and non-interactive.
+    pub fn enabled(mut self, enabled: bool) -> Self {
+        self.area = self.area.enabled(enabled);
+        self
+    }
+
+    /// If `false` the window will be non-interactive.
+    pub fn interactable(mut self, interactable: bool) -> Self {
+        self.area = self.area.interactable(interactable);
+        self
+    }
+
+    /// If `false` the window will be immovable.
+    pub fn movable(mut self, movable: bool) -> Self {
+        self.area = self.area.movable(movable);
+        self
+    }
+
+    /// Usage: `Window::new(…).mutate(|w| w.resize = w.resize.auto_expand_width(true))`
+    // TODO(emilk): I'm not sure this is a good interface for this.
+    pub fn mutate(mut self, mutate: impl Fn(&mut Self)) -> Self {
+        mutate(&mut self);
+        self
+    }
+
+    /// Usage: `Window::new(…).resize(|r| r.auto_expand_width(true))`
+    // TODO(emilk): I'm not sure this is a good interface for this.
+    pub fn resize(mut self, mutate: impl Fn(Resize) -> Resize) -> Self {
+        self.resize = mutate(self.resize);
+        self
+    }
+
+    /// Change the background color, margins, etc.
+    pub fn frame(mut self, frame: Frame) -> Self {
+        self.frame = Some(frame);
+        self
+    }
+
+    /// Set minimum width of the window.
+    pub fn min_width(mut self, min_width: f32) -> Self {
+        self.resize = self.resize.min_width(min_width);
+        self
+    }
+
+    /// Set minimum height of the window.
+    pub fn min_height(mut self, min_height: f32) -> Self {
+        self.resize = self.resize.min_height(min_height);
+        self
+    }
+
+    /// Set current position of the window.
+    /// If the window is movable it is up to you to keep track of where it moved to!
+    pub fn current_pos(mut self, current_pos: impl Into<Pos2>) -> Self {
+        self.area = self.area.current_pos(current_pos);
+        self
+    }
+
+    /// Set initial position of the window.
+    pub fn default_pos(mut self, default_pos: impl Into<Pos2>) -> Self {
+        self.area = self.area.default_pos(default_pos);
+        self
+    }
+
+    /// Sets the window position and prevents it from being dragged around.
+    pub fn fixed_pos(mut self, pos: impl Into<Pos2>) -> Self {
+        self.area = self.area.fixed_pos(pos);
+        self
+    }
+
+    /// Constrains this window to the screen bounds.
+    pub fn constrain(mut self, constrain: bool) -> Self {
+        self.area = self.area.constrain(constrain);
+        self
+    }
+
+    /// Where the "root" of the window is.
+    ///
+    /// For instance, if you set this to [`Align2::RIGHT_TOP`]
+    /// then [`Self::fixed_pos`] will set the position of the right-top
+    /// corner of the window.
+    ///
+    /// Default: [`Align2::LEFT_TOP`].
+    pub fn pivot(mut self, pivot: Align2) -> Self {
+        self.area = self.area.pivot(pivot);
+        self
+    }
+
+    /// Set anchor and distance.
+    ///
+    /// An anchor of `Align2::RIGHT_TOP` means "put the right-top corner of the window
+    /// in the right-top corner of the screen".
+    ///
+    /// The offset is added to the position, so e.g. an offset of `[-5.0, 5.0]`
+    /// would move the window left and down from the given anchor.
+    ///
+    /// Anchoring also makes the window immovable.
+    ///
+    /// It is an error to set both an anchor and a position.
+    pub fn anchor(mut self, align: Align2, offset: impl Into<Vec2>) -> Self {
+        self.area = self.area.anchor(align, offset);
+        self
+    }
+
+    /// Set initial collapsed state of the window
+    pub fn default_open(mut self, default_open: bool) -> Self {
+        self.default_open = default_open;
+        self
+    }
+
+    /// Set initial size of the window.
+    pub fn default_size(mut self, default_size: impl Into<Vec2>) -> Self {
+        self.resize = self.resize.default_size(default_size);
+        self
+    }
+
+    /// Set initial width of the window.
+    pub fn default_width(mut self, default_width: f32) -> Self {
+        self.resize = self.resize.default_width(default_width);
+        self
+    }
+
+    /// Set initial height of the window.
+    pub fn default_height(mut self, default_height: f32) -> Self {
+        self.resize = self.resize.default_height(default_height);
+        self
+    }
+
+    /// Sets the window size and prevents it from being resized by dragging its edges.
+    pub fn fixed_size(mut self, size: impl Into<Vec2>) -> Self {
+        self.resize = self.resize.fixed_size(size);
+        self
+    }
+
+    /// Set initial position and size of the window.
+    pub fn default_rect(self, rect: Rect) -> Self {
+        self.default_pos(rect.min).default_size(rect.size())
+    }
+
+    /// Sets the window pos and size and prevents it from being moved and resized by dragging its edges.
+    pub fn fixed_rect(self, rect: Rect) -> Self {
+        self.fixed_pos(rect.min).fixed_size(rect.size())
+    }
+
+    /// Can the user resize the window by dragging its edges?
+    /// Note that even if you set this to `false` the window may still auto-resize.
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.resize = self.resize.resizable(resizable);
+        self
+    }
+
+    /// Can the window be collapsed by clicking on its title?
+    pub fn collapsible(mut self, collapsible: bool) -> Self {
+        self.collapsible = collapsible;
+        self
+    }
+
+    /// Show title bar on top of the window?
+    /// If `false`, the window will not be collapsible nor have a close-button.
+    pub fn title_bar(mut self, title_bar: bool) -> Self {
+        self.with_title_bar = title_bar;
+        self
+    }
+
+    /// Not resizable, just takes the size of its contents.
+    /// Also disabled scrolling.
+    /// Text will not wrap, but will instead make your window width expand.
+    pub fn auto_sized(mut self) -> Self {
+        self.resize = self.resize.auto_sized();
+        self.scroll = ScrollArea::neither();
+        self
+    }
+
+    /// Enable/disable horizontal/vertical scrolling. `false` by default.
+    pub fn scroll2(mut self, scroll: [bool; 2]) -> Self {
+        self.scroll = self.scroll.scroll2(scroll);
+        self
+    }
+
+    /// Enable/disable horizontal scrolling. `false` by default.
+    pub fn hscroll(mut self, hscroll: bool) -> Self {
+        self.scroll = self.scroll.hscroll(hscroll);
+        self
+    }
+
+    /// Enable/disable vertical scrolling. `false` by default.
+    pub fn vscroll(mut self, vscroll: bool) -> Self {
+        self.scroll = self.scroll.vscroll(vscroll);
+        self
+    }
+
+    /// Constrain the area up to which the window can be dragged.
+    pub fn drag_bounds(mut self, bounds: Rect) -> Self {
+        self.area = self.area.drag_bounds(bounds);
+        self
+    }
+}
+
+impl<'open> Window<'open> {
+    /// Returns `None` if the window is not open (if [`Window::open`] was called with `&mut false`).
+    /// Returns `Some(InnerResponse { inner: None })` if the window is collapsed.
+    #[inline]
+    pub fn show<R>(
+        self,
+        ctx: &Context,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<Option<R>>> {
+        self.show_dyn(ctx, Box::new(add_contents))
+    }
+
+    fn show_dyn<'c, R>(
+        self,
+        ctx: &Context,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> Option<InnerResponse<Option<R>>> {
+        let Window {
+            title,
+            open,
+            area,
+            frame,
+            resize,
+            scroll,
+            collapsible,
+            default_open,
+            with_title_bar,
+        } = self;
+
+        let frame = frame.unwrap_or_else(|| Frame::window(&ctx.style()));
+
+        let is_explicitly_closed = matches!(open, Some(false));
+        let is_open = !is_explicitly_closed || ctx.memory(|mem| mem.everything_is_visible());
+        area.show_open_close_animation(ctx, &frame, is_open);
+
+        if !is_open {
+            return None;
+        }
+
+        let area_id = area.id;
+        let area_layer_id = area.layer();
+        let resize_id = area_id.with("resize");
+        let mut collapsing =
+            CollapsingState::load_with_default_open(ctx, area_id.with("collapsing"), default_open);
+
+        let is_collapsed = with_title_bar && !collapsing.is_open();
+        let possible = PossibleInteractions::new(&area, &resize, is_collapsed);
+
+        let area = area.movable(false); // We move it manually, or the area will move the window when we want to resize it
+        let resize = resize.resizable(false); // We move it manually
+        let mut resize = resize.id(resize_id);
+
+        let mut area = area.begin(ctx);
+
+        let title_content_spacing = 2.0 * ctx.style().spacing.item_spacing.y;
+
+        // First interact (move etc) to avoid frame delay:
+        let last_frame_outer_rect = area.state().rect();
+        let interaction = if possible.movable || possible.resizable() {
+            window_interaction(
+                ctx,
+                possible,
+                area_layer_id,
+                area_id.with("frame_resize"),
+                last_frame_outer_rect,
+            )
+            .and_then(|window_interaction| {
+                // Calculate roughly how much larger the window size is compared to the inner rect
+                let title_bar_height = if with_title_bar {
+                    let style = ctx.style();
+                    ctx.fonts(|f| title.font_height(f, &style)) + title_content_spacing
+                } else {
+                    0.0
+                };
+                let margins = frame.outer_margin.sum()
+                    + frame.inner_margin.sum()
+                    + vec2(0.0, title_bar_height);
+
+                interact(
+                    window_interaction,
+                    ctx,
+                    margins,
+                    area_layer_id,
+                    &mut area,
+                    resize_id,
+                )
+            })
+        } else {
+            None
+        };
+        let hover_interaction = resize_hover(ctx, possible, area_layer_id, last_frame_outer_rect);
+
+        let mut area_content_ui = area.content_ui(ctx);
+
+        let content_inner = {
+            // BEGIN FRAME --------------------------------
+            let frame_stroke = frame.stroke;
+            let mut frame = frame.begin(&mut area_content_ui);
+
+            let show_close_button = open.is_some();
+            let title_bar = if with_title_bar {
+                let title_bar = show_title_bar(
+                    &mut frame.content_ui,
+                    title,
+                    show_close_button,
+                    &mut collapsing,
+                    collapsible,
+                );
+                resize.min_size.x = resize.min_size.x.at_least(title_bar.rect.width()); // Prevent making window smaller than title bar width
+                Some(title_bar)
+            } else {
+                None
+            };
+
+            let (content_inner, content_response) = collapsing
+                .show_body_unindented(&mut frame.content_ui, |ui| {
+                    resize.show(ui, |ui| {
+                        if title_bar.is_some() {
+                            ui.add_space(title_content_spacing);
+                        }
+
+                        if scroll.has_any_bar() {
+                            scroll.show(ui, add_contents).inner
+                        } else {
+                            add_contents(ui)
+                        }
+                    })
+                })
+                .map_or((None, None), |ir| (Some(ir.inner), Some(ir.response)));
+
+            let outer_rect = frame.end(&mut area_content_ui).rect;
+            paint_resize_corner(&mut area_content_ui, &possible, outer_rect, frame_stroke);
+
+            // END FRAME --------------------------------
+
+            if let Some(title_bar) = title_bar {
+                title_bar.ui(
+                    &mut area_content_ui,
+                    outer_rect,
+                    &content_response,
+                    open,
+                    &mut collapsing,
+                    collapsible,
+                );
+            }
+
+            collapsing.store(ctx);
+
+            if let Some(interaction) = interaction {
+                paint_frame_interaction(
+                    &mut area_content_ui,
+                    outer_rect,
+                    interaction,
+                    ctx.style().visuals.widgets.active,
+                );
+            } else if let Some(hover_interaction) = hover_interaction {
+                if ctx.input(|i| i.pointer.has_pointer()) {
+                    paint_frame_interaction(
+                        &mut area_content_ui,
+                        outer_rect,
+                        hover_interaction,
+                        ctx.style().visuals.widgets.hovered,
+                    );
+                }
+            }
+            content_inner
+        };
+
+        {
+            let pos = ctx
+                .constrain_window_rect_to_area(area.state().rect(), area.drag_bounds())
+                .left_top();
+            area.state_mut().set_left_top_pos(pos);
+        }
+
+        let full_response = area.end(ctx, area_content_ui);
+
+        let inner_response = InnerResponse {
+            inner: content_inner,
+            response: full_response,
+        };
+        Some(inner_response)
+    }
+}
+
+fn paint_resize_corner(
+    ui: &mut Ui,
+    possible: &PossibleInteractions,
+    outer_rect: Rect,
+    stroke: Stroke,
+) {
+    let corner = if possible.resize_right && possible.resize_bottom {
+        Align2::RIGHT_BOTTOM
+    } else if possible.resize_left && possible.resize_bottom {
+        Align2::LEFT_BOTTOM
+    } else if possible.resize_left && possible.resize_top {
+        Align2::LEFT_TOP
+    } else if possible.resize_right && possible.resize_top {
+        Align2::RIGHT_TOP
+    } else {
+        return;
+    };
+
+    let corner_size = Vec2::splat(ui.visuals().resize_corner_size);
+    let corner_rect = corner.align_size_within_rect(corner_size, outer_rect);
+    let corner_rect = corner_rect.translate(-2.0 * corner.to_sign()); // move away from corner
+    crate::resize::paint_resize_corner_with_style(ui, &corner_rect, stroke, corner);
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, Debug)]
+struct PossibleInteractions {
+    movable: bool,
+    // Which sides can we drag to resize?
+    resize_left: bool,
+    resize_right: bool,
+    resize_top: bool,
+    resize_bottom: bool,
+}
+
+impl PossibleInteractions {
+    fn new(area: &Area, resize: &Resize, is_collapsed: bool) -> Self {
+        let movable = area.is_enabled() && area.is_movable();
+        let resizable = area.is_enabled() && resize.is_resizable() && !is_collapsed;
+        let pivot = area.get_pivot();
+        Self {
+            movable,
+            resize_left: resizable && (movable || pivot.x() != Align::LEFT),
+            resize_right: resizable && (movable || pivot.x() != Align::RIGHT),
+            resize_top: resizable && (movable || pivot.y() != Align::TOP),
+            resize_bottom: resizable && (movable || pivot.y() != Align::BOTTOM),
+        }
+    }
+
+    pub fn resizable(&self) -> bool {
+        self.resize_left || self.resize_right || self.resize_top || self.resize_bottom
+    }
+}
+
+/// Either a move or resize
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct WindowInteraction {
+    pub(crate) area_layer_id: LayerId,
+    pub(crate) start_rect: Rect,
+    pub(crate) left: bool,
+    pub(crate) right: bool,
+    pub(crate) top: bool,
+    pub(crate) bottom: bool,
+}
+
+impl WindowInteraction {
+    pub fn set_cursor(&self, ctx: &Context) {
+        if (self.left && self.top) || (self.right && self.bottom) {
+            ctx.set_cursor_icon(CursorIcon::ResizeNwSe);
+        } else if (self.right && self.top) || (self.left && self.bottom) {
+            ctx.set_cursor_icon(CursorIcon::ResizeNeSw);
+        } else if self.left || self.right {
+            ctx.set_cursor_icon(CursorIcon::ResizeHorizontal);
+        } else if self.bottom || self.top {
+            ctx.set_cursor_icon(CursorIcon::ResizeVertical);
+        }
+    }
+
+    pub fn is_resize(&self) -> bool {
+        self.left || self.right || self.top || self.bottom
+    }
+}
+
+fn interact(
+    window_interaction: WindowInteraction,
+    ctx: &Context,
+    margins: Vec2,
+    area_layer_id: LayerId,
+    area: &mut area::Prepared,
+    resize_id: Id,
+) -> Option<WindowInteraction> {
+    let new_rect = move_and_resize_window(ctx, &window_interaction)?;
+    let new_rect = ctx.round_rect_to_pixels(new_rect);
+
+    let new_rect = ctx.constrain_window_rect_to_area(new_rect, area.drag_bounds());
+
+    // TODO(emilk): add this to a Window state instead as a command "move here next frame"
+    area.state_mut().set_left_top_pos(new_rect.left_top());
+
+    if window_interaction.is_resize() {
+        if let Some(mut state) = resize::State::load(ctx, resize_id) {
+            state.requested_size = Some(new_rect.size() - margins);
+            state.store(ctx, resize_id);
+        }
+    }
+
+    ctx.memory_mut(|mem| mem.areas.move_to_top(area_layer_id));
+    Some(window_interaction)
+}
+
+fn move_and_resize_window(ctx: &Context, window_interaction: &WindowInteraction) -> Option<Rect> {
+    window_interaction.set_cursor(ctx);
+
+    // Only move/resize windows with primary mouse button:
+    if !ctx.input(|i| i.pointer.primary_down()) {
+        return None;
+    }
+
+    let pointer_pos = ctx.input(|i| i.pointer.interact_pos())?;
+    let mut rect = window_interaction.start_rect; // prevent drift
+
+    if window_interaction.is_resize() {
+        if window_interaction.left {
+            rect.min.x = ctx.round_to_pixel(pointer_pos.x);
+        } else if window_interaction.right {
+            rect.max.x = ctx.round_to_pixel(pointer_pos.x);
+        }
+
+        if window_interaction.top {
+            rect.min.y = ctx.round_to_pixel(pointer_pos.y);
+        } else if window_interaction.bottom {
+            rect.max.y = ctx.round_to_pixel(pointer_pos.y);
+        }
+    } else {
+        // Movement.
+
+        // We do window interaction first (to avoid frame delay),
+        // but we want anything interactive in the window (e.g. slider) to steal
+        // the drag from us. It is therefor important not to move the window the first frame,
+        // but instead let other widgets to the steal. HACK.
+        if !ctx.input(|i| i.pointer.any_pressed()) {
+            let press_origin = ctx.input(|i| i.pointer.press_origin())?;
+            let delta = pointer_pos - press_origin;
+            rect = rect.translate(delta);
+        }
+    }
+
+    Some(rect)
+}
+
+/// Returns `Some` if there is a move or resize
+fn window_interaction(
+    ctx: &Context,
+    possible: PossibleInteractions,
+    area_layer_id: LayerId,
+    id: Id,
+    rect: Rect,
+) -> Option<WindowInteraction> {
+    {
+        let drag_id = ctx.memory(|mem| mem.interaction.drag_id);
+
+        if drag_id.is_some() && drag_id != Some(id) {
+            return None;
+        }
+    }
+
+    let mut window_interaction = ctx.memory(|mem| mem.window_interaction);
+
+    if window_interaction.is_none() {
+        if let Some(hover_window_interaction) = resize_hover(ctx, possible, area_layer_id, rect) {
+            hover_window_interaction.set_cursor(ctx);
+            if ctx.input(|i| i.pointer.any_pressed() && i.pointer.primary_down()) {
+                ctx.memory_mut(|mem| {
+                    mem.interaction.drag_id = Some(id);
+                    mem.interaction.drag_is_window = true;
+                    window_interaction = Some(hover_window_interaction);
+                    mem.window_interaction = window_interaction;
+                });
+            }
+        }
+    }
+
+    if let Some(window_interaction) = window_interaction {
+        let is_active = ctx.memory_mut(|mem| mem.interaction.drag_id == Some(id));
+
+        if is_active && window_interaction.area_layer_id == area_layer_id {
+            return Some(window_interaction);
+        }
+    }
+
+    None
+}
+
+fn resize_hover(
+    ctx: &Context,
+    possible: PossibleInteractions,
+    area_layer_id: LayerId,
+    rect: Rect,
+) -> Option<WindowInteraction> {
+    let pointer = ctx.input(|i| i.pointer.interact_pos())?;
+
+    if ctx.input(|i| i.pointer.any_down() && !i.pointer.any_pressed()) {
+        return None; // already dragging (something)
+    }
+
+    if let Some(top_layer_id) = ctx.layer_id_at(pointer) {
+        if top_layer_id != area_layer_id && top_layer_id.order != Order::Background {
+            return None; // Another window is on top here
+        }
+    }
+
+    if ctx.memory(|mem| mem.interaction.drag_interest) {
+        // Another widget will become active if we drag here
+        return None;
+    }
+
+    let side_grab_radius = ctx.style().interaction.resize_grab_radius_side;
+    let corner_grab_radius = ctx.style().interaction.resize_grab_radius_corner;
+    if !rect.expand(side_grab_radius).contains(pointer) {
+        return None;
+    }
+
+    let mut left = possible.resize_left && (rect.left() - pointer.x).abs() <= side_grab_radius;
+    let mut right = possible.resize_right && (rect.right() - pointer.x).abs() <= side_grab_radius;
+    let mut top = possible.resize_top && (rect.top() - pointer.y).abs() <= side_grab_radius;
+    let mut bottom =
+        possible.resize_bottom && (rect.bottom() - pointer.y).abs() <= side_grab_radius;
+
+    if possible.resize_right
+        && possible.resize_bottom
+        && rect.right_bottom().distance(pointer) < corner_grab_radius
+    {
+        right = true;
+        bottom = true;
+    }
+    if possible.resize_right
+        && possible.resize_top
+        && rect.right_top().distance(pointer) < corner_grab_radius
+    {
+        right = true;
+        top = true;
+    }
+    if possible.resize_left
+        && possible.resize_top
+        && rect.left_top().distance(pointer) < corner_grab_radius
+    {
+        left = true;
+        top = true;
+    }
+    if possible.resize_left
+        && possible.resize_bottom
+        && rect.left_bottom().distance(pointer) < corner_grab_radius
+    {
+        left = true;
+        bottom = true;
+    }
+
+    let any_resize = left || right || top || bottom;
+
+    if !any_resize && !possible.movable {
+        return None;
+    }
+
+    if any_resize || possible.movable {
+        Some(WindowInteraction {
+            area_layer_id,
+            start_rect: rect,
+            left,
+            right,
+            top,
+            bottom,
+        })
+    } else {
+        None
+    }
+}
+
+/// Fill in parts of the window frame when we resize by dragging that part
+fn paint_frame_interaction(
+    ui: &mut Ui,
+    rect: Rect,
+    interaction: WindowInteraction,
+    visuals: style::WidgetVisuals,
+) {
+    use epaint::tessellator::path::add_circle_quadrant;
+
+    let rounding = ui.visuals().window_rounding;
+    let Rect { min, max } = rect;
+
+    let mut points = Vec::new();
+
+    if interaction.right && !interaction.bottom && !interaction.top {
+        points.push(pos2(max.x, min.y + rounding.ne));
+        points.push(pos2(max.x, max.y - rounding.se));
+    }
+    if interaction.right && interaction.bottom {
+        points.push(pos2(max.x, min.y + rounding.ne));
+        points.push(pos2(max.x, max.y - rounding.se));
+        add_circle_quadrant(
+            &mut points,
+            pos2(max.x - rounding.se, max.y - rounding.se),
+            rounding.se,
+            0.0,
+        );
+    }
+    if interaction.bottom {
+        points.push(pos2(max.x - rounding.se, max.y));
+        points.push(pos2(min.x + rounding.sw, max.y));
+    }
+    if interaction.left && interaction.bottom {
+        add_circle_quadrant(
+            &mut points,
+            pos2(min.x + rounding.sw, max.y - rounding.sw),
+            rounding.sw,
+            1.0,
+        );
+    }
+    if interaction.left {
+        points.push(pos2(min.x, max.y - rounding.sw));
+        points.push(pos2(min.x, min.y + rounding.nw));
+    }
+    if interaction.left && interaction.top {
+        add_circle_quadrant(
+            &mut points,
+            pos2(min.x + rounding.nw, min.y + rounding.nw),
+            rounding.nw,
+            2.0,
+        );
+    }
+    if interaction.top {
+        points.push(pos2(min.x + rounding.nw, min.y));
+        points.push(pos2(max.x - rounding.ne, min.y));
+    }
+    if interaction.right && interaction.top {
+        add_circle_quadrant(
+            &mut points,
+            pos2(max.x - rounding.ne, min.y + rounding.ne),
+            rounding.ne,
+            3.0,
+        );
+        points.push(pos2(max.x, min.y + rounding.ne));
+        points.push(pos2(max.x, max.y - rounding.se));
+    }
+    ui.painter().add(Shape::line(points, visuals.bg_stroke));
+}
+
+// ----------------------------------------------------------------------------
+
+struct TitleBar {
+    /// A title Id used for dragging windows
+    id: Id,
+
+    /// Prepared text in the title
+    title_galley: WidgetTextGalley,
+
+    /// Size of the title bar in a collapsed state (if window is collapsible),
+    /// which includes all necessary space for showing the expand button, the
+    /// title and the close button.
+    min_rect: Rect,
+
+    /// Size of the title bar in an expanded state. This size become known only
+    /// after expanding window and painting its content
+    rect: Rect,
+}
+
+fn show_title_bar(
+    ui: &mut Ui,
+    title: WidgetText,
+    show_close_button: bool,
+    collapsing: &mut CollapsingState,
+    collapsible: bool,
+) -> TitleBar {
+    let inner_response = ui.horizontal(|ui| {
+        let height = ui
+            .fonts(|fonts| title.font_height(fonts, ui.style()))
+            .max(ui.spacing().interact_size.y);
+        ui.set_min_height(height);
+
+        let item_spacing = ui.spacing().item_spacing;
+        let button_size = Vec2::splat(ui.spacing().icon_width);
+
+        let pad = (height - button_size.y) / 2.0; // calculated so that the icon is on the diagonal (if window padding is symmetrical)
+
+        if collapsible {
+            ui.add_space(pad);
+            collapsing.show_default_button_with_size(ui, button_size);
+        }
+
+        let title_galley = title.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Heading);
+
+        let minimum_width = if collapsible || show_close_button {
+            // If at least one button is shown we make room for both buttons (since title is centered):
+            2.0 * (pad + button_size.x + item_spacing.x) + title_galley.size().x
+        } else {
+            pad + title_galley.size().x + pad
+        };
+        let min_rect = Rect::from_min_size(ui.min_rect().min, vec2(minimum_width, height));
+        let id = ui.advance_cursor_after_rect(min_rect);
+
+        TitleBar {
+            id,
+            title_galley,
+            min_rect,
+            rect: Rect::NAN, // Will be filled in later
+        }
+    });
+
+    let title_bar = inner_response.inner;
+    let rect = inner_response.response.rect;
+
+    TitleBar { rect, ..title_bar }
+}
+
+impl TitleBar {
+    /// Finishes painting of the title bar when the window content size already known.
+    ///
+    /// # Parameters
+    ///
+    /// - `ui`:
+    /// - `outer_rect`:
+    /// - `content_response`: if `None`, window is collapsed at this frame, otherwise contains
+    ///   a result of rendering the window content
+    /// - `open`: if `None`, no "Close" button will be rendered, otherwise renders and processes
+    ///   the "Close" button and writes a `false` if window was closed
+    /// - `collapsing`: holds the current expanding state. Can be changed by double click on the
+    ///   title if `collapsible` is `true`
+    /// - `collapsible`: if `true`, double click on the title bar will be handled for a change
+    ///   of `collapsing` state
+    fn ui(
+        mut self,
+        ui: &mut Ui,
+        outer_rect: Rect,
+        content_response: &Option<Response>,
+        open: Option<&mut bool>,
+        collapsing: &mut CollapsingState,
+        collapsible: bool,
+    ) {
+        if let Some(content_response) = &content_response {
+            // Now we know how large we got to be:
+            self.rect.max.x = self.rect.max.x.max(content_response.rect.max.x);
+        }
+
+        if let Some(open) = open {
+            // Add close button now that we know our full width:
+            if self.close_button_ui(ui).clicked() {
+                *open = false;
+            }
+        }
+
+        let full_top_rect = Rect::from_x_y_ranges(self.rect.x_range(), self.min_rect.y_range());
+        let text_pos =
+            emath::align::center_size_in_rect(self.title_galley.size(), full_top_rect).left_top();
+        let text_pos = text_pos - self.title_galley.galley().rect.min.to_vec2();
+        let text_pos = text_pos - 1.5 * Vec2::Y; // HACK: center on x-height of text (looks better)
+        self.title_galley.paint_with_fallback_color(
+            ui.painter(),
+            text_pos,
+            ui.visuals().text_color(),
+        );
+
+        if let Some(content_response) = &content_response {
+            // paint separator between title and content:
+            let y = content_response.rect.top() + ui.spacing().item_spacing.y * 0.5;
+            // let y = lerp(self.rect.bottom()..=content_response.rect.top(), 0.5);
+            let stroke = ui.visuals().widgets.noninteractive.bg_stroke;
+            ui.painter().hline(outer_rect.x_range(), y, stroke);
+        }
+
+        // Don't cover the close- and collapse buttons:
+        let double_click_rect = self.rect.shrink2(vec2(32.0, 0.0));
+
+        if ui
+            .interact(double_click_rect, self.id, Sense::click())
+            .double_clicked()
+            && collapsible
+        {
+            collapsing.toggle(ui);
+        }
+    }
+
+    /// Paints the "Close" button at the right side of the title bar
+    /// and processes clicks on it.
+    ///
+    /// The button is square and its size is determined by the
+    /// [`crate::style::Spacing::icon_width`] setting.
+    fn close_button_ui(&self, ui: &mut Ui) -> Response {
+        let button_size = Vec2::splat(ui.spacing().icon_width);
+        let pad = (self.rect.height() - button_size.y) / 2.0; // calculated so that the icon is on the diagonal (if window padding is symmetrical)
+        let button_rect = Rect::from_min_size(
+            pos2(
+                self.rect.right() - pad - button_size.x,
+                self.rect.center().y - 0.5 * button_size.y,
+            ),
+            button_size,
+        );
+
+        close_button(ui, button_rect)
+    }
+}
+
+/// Paints the "Close" button of the window and processes clicks on it.
+///
+/// The close button is just an `X` symbol painted by a current stroke
+/// for foreground elements (such as a label text).
+///
+/// # Parameters
+/// - `ui`:
+/// - `rect`: The rectangular area to fit the button in
+///
+/// Returns the result of a click on a button if it was pressed
+fn close_button(ui: &mut Ui, rect: Rect) -> Response {
+    let close_id = ui.auto_id_with("window_close_button");
+    let response = ui.interact(rect, close_id, Sense::click());
+    ui.expand_to_include_rect(response.rect);
+
+    let visuals = ui.style().interact(&response);
+    let rect = rect.shrink(2.0).expand(visuals.expansion);
+    let stroke = visuals.fg_stroke;
+    ui.painter() // paints \
+        .line_segment([rect.left_top(), rect.right_bottom()], stroke);
+    ui.painter() // paints /
+        .line_segment([rect.right_top(), rect.left_bottom()], stroke);
+    response
+}
diff --git a/egui/crates/egui/src/context.rs b/egui/crates/egui/src/context.rs
new file mode 100644
index 0000000..2feba93
--- /dev/null
+++ b/egui/crates/egui/src/context.rs
@@ -0,0 +1,1799 @@
+// #![warn(missing_docs)]
+use std::sync::Arc;
+
+use crate::{
+    animation_manager::AnimationManager, data::output::PlatformOutput, frame_state::FrameState,
+    input_state::*, layers::GraphicLayers, memory::Options, os::OperatingSystem,
+    output::FullOutput, util::IdTypeMap, TextureHandle, *,
+};
+use epaint::{mutex::*, stats::*, text::Fonts, TessellationOptions, *};
+
+// ----------------------------------------------------------------------------
+
+struct WrappedTextureManager(Arc<RwLock<epaint::TextureManager>>);
+
+impl Default for WrappedTextureManager {
+    fn default() -> Self {
+        let mut tex_mngr = epaint::textures::TextureManager::default();
+
+        // Will be filled in later
+        let font_id = tex_mngr.alloc(
+            "egui_font_texture".into(),
+            epaint::FontImage::new([0, 0]).into(),
+            Default::default(),
+        );
+        assert_eq!(font_id, TextureId::default());
+
+        Self(Arc::new(RwLock::new(tex_mngr)))
+    }
+}
+
+// ----------------------------------------------------------------------------
+#[derive(Default)]
+struct ContextImpl {
+    /// `None` until the start of the first frame.
+    fonts: Option<Fonts>,
+    memory: Memory,
+    animation_manager: AnimationManager,
+    tex_manager: WrappedTextureManager,
+
+    os: OperatingSystem,
+
+    input: InputState,
+
+    /// State that is collected during a frame and then cleared
+    frame_state: FrameState,
+
+    // The output of a frame:
+    graphics: GraphicLayers,
+    output: PlatformOutput,
+
+    paint_stats: PaintStats,
+
+    /// the duration backend will poll for new events, before forcing another egui update
+    /// even if there's no new events.
+    repaint_after: std::time::Duration,
+
+    /// While positive, keep requesting repaints. Decrement at the end of each frame.
+    repaint_requests: u32,
+    request_repaint_callback: Option<Box<dyn Fn() + Send + Sync>>,
+
+    /// used to suppress multiple calls to [`Self::request_repaint_callback`] during the same frame.
+    has_requested_repaint_this_frame: bool,
+
+    requested_repaint_last_frame: bool,
+
+    /// Written to during the frame.
+    layer_rects_this_frame: ahash::HashMap<LayerId, Vec<(Id, Rect)>>,
+
+    /// Read
+    layer_rects_prev_frame: ahash::HashMap<LayerId, Vec<(Id, Rect)>>,
+
+    #[cfg(feature = "accesskit")]
+    is_accesskit_enabled: bool,
+    #[cfg(feature = "accesskit")]
+    accesskit_node_classes: accesskit::NodeClassSet,
+}
+
+impl ContextImpl {
+    fn begin_frame_mut(&mut self, mut new_raw_input: RawInput) {
+        self.has_requested_repaint_this_frame = false; // allow new calls during the frame
+
+        if let Some(new_pixels_per_point) = self.memory.new_pixels_per_point.take() {
+            new_raw_input.pixels_per_point = Some(new_pixels_per_point);
+
+            // This is a bit hacky, but is required to avoid jitter:
+            let ratio = self.input.pixels_per_point / new_pixels_per_point;
+            let mut rect = self.input.screen_rect;
+            rect.min = (ratio * rect.min.to_vec2()).to_pos2();
+            rect.max = (ratio * rect.max.to_vec2()).to_pos2();
+            new_raw_input.screen_rect = Some(rect);
+        }
+
+        self.layer_rects_prev_frame = std::mem::take(&mut self.layer_rects_this_frame);
+
+        self.memory.begin_frame(&self.input, &new_raw_input);
+
+        self.input = std::mem::take(&mut self.input)
+            .begin_frame(new_raw_input, self.requested_repaint_last_frame);
+
+        self.frame_state.begin_frame(&self.input);
+
+        self.update_fonts_mut();
+
+        // Ensure we register the background area so panels and background ui can catch clicks:
+        let screen_rect = self.input.screen_rect();
+        self.memory.areas.set_state(
+            LayerId::background(),
+            containers::area::State {
+                pivot_pos: screen_rect.left_top(),
+                pivot: Align2::LEFT_TOP,
+                size: screen_rect.size(),
+                interactable: true,
+            },
+        );
+
+        #[cfg(feature = "accesskit")]
+        if self.is_accesskit_enabled {
+            use crate::frame_state::AccessKitFrameState;
+            let id = crate::accesskit_root_id();
+            let mut builder = accesskit::NodeBuilder::new(accesskit::Role::Window);
+            builder.set_transform(accesskit::Affine::scale(
+                self.input.pixels_per_point().into(),
+            ));
+            let mut node_builders = IdMap::default();
+            node_builders.insert(id, builder);
+            self.frame_state.accesskit_state = Some(AccessKitFrameState {
+                node_builders,
+                parent_stack: vec![id],
+            });
+        }
+    }
+
+    /// Load fonts unless already loaded.
+    fn update_fonts_mut(&mut self) {
+        let pixels_per_point = self.input.pixels_per_point();
+        let max_texture_side = self.input.max_texture_side;
+
+        if let Some(font_definitions) = self.memory.new_font_definitions.take() {
+            let fonts = Fonts::new(pixels_per_point, max_texture_side, font_definitions);
+            self.fonts = Some(fonts);
+        }
+
+        let fonts = self.fonts.get_or_insert_with(|| {
+            let font_definitions = FontDefinitions::default();
+            Fonts::new(pixels_per_point, max_texture_side, font_definitions)
+        });
+
+        fonts.begin_frame(pixels_per_point, max_texture_side);
+
+        if self.memory.options.preload_font_glyphs {
+            // Preload the most common characters for the most common fonts.
+            // This is not very important to do, but may a few GPU operations.
+            for font_id in self.memory.options.style.text_styles.values() {
+                fonts.lock().fonts.font(font_id).preload_common_characters();
+            }
+        }
+    }
+
+    #[cfg(feature = "accesskit")]
+    fn accesskit_node_builder(&mut self, id: Id) -> &mut accesskit::NodeBuilder {
+        let state = self.frame_state.accesskit_state.as_mut().unwrap();
+        let builders = &mut state.node_builders;
+        if let std::collections::hash_map::Entry::Vacant(entry) = builders.entry(id) {
+            entry.insert(Default::default());
+            let parent_id = state.parent_stack.last().unwrap();
+            let parent_builder = builders.get_mut(parent_id).unwrap();
+            parent_builder.push_child(id.accesskit_id());
+        }
+        builders.get_mut(&id).unwrap()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Your handle to egui.
+///
+/// This is the first thing you need when working with egui.
+/// Contains the [`InputState`], [`Memory`], [`PlatformOutput`], and more.
+///
+/// [`Context`] is cheap to clone, and any clones refers to the same mutable data
+/// ([`Context`] uses refcounting internally).
+///
+/// ## Locking
+/// All methods are marked `&self`; [`Context`] has interior mutability protected by an [`RwLock`].
+///
+/// To access parts of a `Context` you need to use some of the helper functions that take closures:
+///
+/// ```
+/// # let ctx = egui::Context::default();
+/// if ctx.input(|i| i.key_pressed(egui::Key::A)) {
+///     ctx.output_mut(|o| o.copied_text = "Hello!".to_string());
+/// }
+/// ```
+///
+/// Within such a closure you may NOT recursively lock the same [`Context`], as that can lead to a deadlock.
+/// Therefore it is important that any lock of [`Context`] is short-lived.
+///
+/// These are effectively transactional accesses.
+///
+/// [`Ui`] has many of the same accessor functions, and the same applies there.
+///
+/// ## Example:
+///
+/// ``` no_run
+/// # fn handle_platform_output(_: egui::PlatformOutput) {}
+/// # fn paint(textures_delta: egui::TexturesDelta, _: Vec<egui::ClippedPrimitive>) {}
+/// let mut ctx = egui::Context::default();
+///
+/// // Game loop:
+/// loop {
+///     let raw_input = egui::RawInput::default();
+///     let full_output = ctx.run(raw_input, |ctx| {
+///         egui::CentralPanel::default().show(&ctx, |ui| {
+///             ui.label("Hello world!");
+///             if ui.button("Click me").clicked() {
+///                 // take some action here
+///             }
+///         });
+///     });
+///     handle_platform_output(full_output.platform_output);
+///     let clipped_primitives = ctx.tessellate(full_output.shapes); // create triangles to paint
+///     paint(full_output.textures_delta, clipped_primitives);
+/// }
+/// ```
+#[derive(Clone)]
+pub struct Context(Arc<RwLock<ContextImpl>>);
+
+impl std::fmt::Debug for Context {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Context").finish_non_exhaustive()
+    }
+}
+
+impl std::cmp::PartialEq for Context {
+    fn eq(&self, other: &Context) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl Default for Context {
+    fn default() -> Self {
+        Self(Arc::new(RwLock::new(ContextImpl {
+            // Start with painting an extra frame to compensate for some widgets
+            // that take two frames before they "settle":
+            repaint_requests: 1,
+            ..ContextImpl::default()
+        })))
+    }
+}
+
+impl Context {
+    // Do read-only (shared access) transaction on Context
+    fn read<R>(&self, reader: impl FnOnce(&ContextImpl) -> R) -> R {
+        reader(&self.0.read())
+    }
+
+    // Do read-write (exclusive access) transaction on Context
+    fn write<R>(&self, writer: impl FnOnce(&mut ContextImpl) -> R) -> R {
+        writer(&mut self.0.write())
+    }
+
+    /// Run the ui code for one frame.
+    ///
+    /// Put your widgets into a [`SidePanel`], [`TopBottomPanel`], [`CentralPanel`], [`Window`] or [`Area`].
+    ///
+    /// This will modify the internal reference to point to a new generation of [`Context`].
+    /// Any old clones of this [`Context`] will refer to the old [`Context`], which will not get new input.
+    ///
+    /// You can alternatively run [`Self::begin_frame`] and [`Context::end_frame`].
+    ///
+    /// ```
+    /// // One egui context that you keep reusing:
+    /// let mut ctx = egui::Context::default();
+    ///
+    /// // Each frame:
+    /// let input = egui::RawInput::default();
+    /// let full_output = ctx.run(input, |ctx| {
+    ///     egui::CentralPanel::default().show(&ctx, |ui| {
+    ///         ui.label("Hello egui!");
+    ///     });
+    /// });
+    /// // handle full_output
+    /// ```
+    #[must_use]
+    pub fn run(&self, new_input: RawInput, run_ui: impl FnOnce(&Context)) -> FullOutput {
+        self.begin_frame(new_input);
+        run_ui(self);
+        self.end_frame()
+    }
+
+    /// An alternative to calling [`Self::run`].
+    ///
+    /// ```
+    /// // One egui context that you keep reusing:
+    /// let mut ctx = egui::Context::default();
+    ///
+    /// // Each frame:
+    /// let input = egui::RawInput::default();
+    /// ctx.begin_frame(input);
+    ///
+    /// egui::CentralPanel::default().show(&ctx, |ui| {
+    ///     ui.label("Hello egui!");
+    /// });
+    ///
+    /// let full_output = ctx.end_frame();
+    /// // handle full_output
+    /// ```
+    pub fn begin_frame(&self, new_input: RawInput) {
+        self.write(|ctx| ctx.begin_frame_mut(new_input));
+    }
+}
+
+/// ## Borrows parts of [`Context`]
+/// These functions all lock the [`Context`].
+/// Please see the documentation of [`Context`] for how locking works!
+impl Context {
+    /// Read-only access to [`InputState`].
+    ///
+    /// Note that this locks the [`Context`].
+    ///
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.input(|i| {
+    ///     // ⚠️ Using `ctx` (even from other `Arc` reference) again here will lead to a dead-lock!
+    /// });
+    ///
+    /// if let Some(pos) = ctx.input(|i| i.pointer.hover_pos()) {
+    ///     // This is fine!
+    /// }
+    /// ```
+    #[inline]
+    pub fn input<R>(&self, reader: impl FnOnce(&InputState) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.input))
+    }
+
+    /// Read-write access to [`InputState`].
+    #[inline]
+    pub fn input_mut<R>(&self, writer: impl FnOnce(&mut InputState) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.input))
+    }
+
+    /// Read-only access to [`Memory`].
+    #[inline]
+    pub fn memory<R>(&self, reader: impl FnOnce(&Memory) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.memory))
+    }
+
+    /// Read-write access to [`Memory`].
+    #[inline]
+    pub fn memory_mut<R>(&self, writer: impl FnOnce(&mut Memory) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.memory))
+    }
+
+    /// Read-only access to [`IdTypeMap`], which stores superficial widget state.
+    #[inline]
+    pub fn data<R>(&self, reader: impl FnOnce(&IdTypeMap) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.memory.data))
+    }
+
+    /// Read-write access to [`IdTypeMap`], which stores superficial widget state.
+    #[inline]
+    pub fn data_mut<R>(&self, writer: impl FnOnce(&mut IdTypeMap) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.memory.data))
+    }
+
+    /// Read-write access to [`GraphicLayers`], where painted [`crate::Shape`]s are written to.
+    #[inline]
+    pub(crate) fn graphics_mut<R>(&self, writer: impl FnOnce(&mut GraphicLayers) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.graphics))
+    }
+
+    /// Read-only access to [`PlatformOutput`].
+    ///
+    /// This is what egui outputs each frame.
+    ///
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::Progress);
+    /// ```
+    #[inline]
+    pub fn output<R>(&self, reader: impl FnOnce(&PlatformOutput) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.output))
+    }
+
+    /// Read-write access to [`PlatformOutput`].
+    #[inline]
+    pub fn output_mut<R>(&self, writer: impl FnOnce(&mut PlatformOutput) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.output))
+    }
+
+    /// Read-only access to [`FrameState`].
+    #[inline]
+    pub(crate) fn frame_state<R>(&self, reader: impl FnOnce(&FrameState) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.frame_state))
+    }
+
+    /// Read-write access to [`FrameState`].
+    #[inline]
+    pub(crate) fn frame_state_mut<R>(&self, writer: impl FnOnce(&mut FrameState) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.frame_state))
+    }
+
+    /// Read-only access to [`Fonts`].
+    ///
+    /// Not valid until first call to [`Context::run()`].
+    /// That's because since we don't know the proper `pixels_per_point` until then.
+    #[inline]
+    pub fn fonts<R>(&self, reader: impl FnOnce(&Fonts) -> R) -> R {
+        self.read(move |ctx| {
+            reader(
+                ctx.fonts
+                    .as_ref()
+                    .expect("No fonts available until first call to Context::run()"),
+            )
+        })
+    }
+
+    /// Read-write access to [`Fonts`].
+    #[inline]
+    pub fn fonts_mut<R>(&self, writer: impl FnOnce(&mut Option<Fonts>) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.fonts))
+    }
+
+    /// Read-only access to [`Options`].
+    #[inline]
+    pub fn options<R>(&self, reader: impl FnOnce(&Options) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.memory.options))
+    }
+
+    /// Read-write access to [`Options`].
+    #[inline]
+    pub fn options_mut<R>(&self, writer: impl FnOnce(&mut Options) -> R) -> R {
+        self.write(move |ctx| writer(&mut ctx.memory.options))
+    }
+
+    /// Read-only access to [`TessellationOptions`].
+    #[inline]
+    pub fn tessellation_options<R>(&self, reader: impl FnOnce(&TessellationOptions) -> R) -> R {
+        self.read(move |ctx| reader(&ctx.memory.options.tessellation_options))
+    }
+
+    /// Read-write access to [`TessellationOptions`].
+    #[inline]
+    pub fn tessellation_options_mut<R>(
+        &self,
+        writer: impl FnOnce(&mut TessellationOptions) -> R,
+    ) -> R {
+        self.write(move |ctx| writer(&mut ctx.memory.options.tessellation_options))
+    }
+}
+
+impl Context {
+    // ---------------------------------------------------------------------
+
+    /// If the given [`Id`] has been used previously the same frame at at different position,
+    /// then an error will be printed on screen.
+    ///
+    /// This function is already called for all widgets that do any interaction,
+    /// but you can call this from widgets that store state but that does not interact.
+    ///
+    /// The given [`Rect`] should be approximately where the widget will be.
+    /// The most important thing is that [`Rect::min`] is approximately correct,
+    /// because that's where the warning will be painted. If you don't know what size to pick, just pick [`Vec2::ZERO`].
+    pub fn check_for_id_clash(&self, id: Id, new_rect: Rect, what: &str) {
+        let prev_rect = self.frame_state_mut(move |state| state.used_ids.insert(id, new_rect));
+        if let Some(prev_rect) = prev_rect {
+            // it is ok to reuse the same ID for e.g. a frame around a widget,
+            // or to check for interaction with the same widget twice:
+            if prev_rect.expand(0.1).contains_rect(new_rect)
+                || new_rect.expand(0.1).contains_rect(prev_rect)
+            {
+                return;
+            }
+
+            let show_error = |widget_rect: Rect, text: String| {
+                let text = format!("🔥 {}", text);
+                let color = self.style().visuals.error_fg_color;
+                let painter = self.debug_painter();
+                painter.rect_stroke(widget_rect, 0.0, (1.0, color));
+
+                let below = widget_rect.bottom() + 32.0 < self.input(|i| i.screen_rect.bottom());
+
+                let text_rect = if below {
+                    painter.debug_text(
+                        widget_rect.left_bottom() + vec2(0.0, 2.0),
+                        Align2::LEFT_TOP,
+                        color,
+                        text,
+                    )
+                } else {
+                    painter.debug_text(
+                        widget_rect.left_top() - vec2(0.0, 2.0),
+                        Align2::LEFT_BOTTOM,
+                        color,
+                        text,
+                    )
+                };
+
+                if let Some(pointer_pos) = self.pointer_hover_pos() {
+                    if text_rect.contains(pointer_pos) {
+                        let tooltip_pos = if below {
+                            text_rect.left_bottom() + vec2(2.0, 4.0)
+                        } else {
+                            text_rect.left_top() + vec2(2.0, -4.0)
+                        };
+
+                        painter.error(
+                            tooltip_pos,
+                            format!("Widget is {} this text.\n\n\
+                             ID clashes happens when things like Windows or CollapsingHeaders share names,\n\
+                             or when things like Plot and Grid:s aren't given unique id_source:s.\n\n\
+                             Sometimes the solution is to use ui.push_id.",
+                             if below { "above" } else { "below" })
+                        );
+                    }
+                }
+            };
+
+            let id_str = id.short_debug_format();
+
+            if prev_rect.min.distance(new_rect.min) < 4.0 {
+                show_error(new_rect, format!("Double use of {} ID {}", what, id_str));
+            } else {
+                show_error(prev_rect, format!("First use of {} ID {}", what, id_str));
+                show_error(new_rect, format!("Second use of {} ID {}", what, id_str));
+            }
+        }
+    }
+
+    // ---------------------------------------------------------------------
+
+    /// Use `ui.interact` instead
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn interact(
+        &self,
+        clip_rect: Rect,
+        item_spacing: Vec2,
+        layer_id: LayerId,
+        id: Id,
+        rect: Rect,
+        sense: Sense,
+        enabled: bool,
+    ) -> Response {
+        let gap = 0.1; // Just to make sure we don't accidentally hover two things at once (a small eps should be sufficient).
+
+        // Make it easier to click things:
+        let interact_rect = rect.expand2(
+            (0.5 * item_spacing - Vec2::splat(gap))
+                .at_least(Vec2::splat(0.0))
+                .at_most(Vec2::splat(5.0)),
+        );
+
+        // Respect clip rectangle when interacting
+        let interact_rect = clip_rect.intersect(interact_rect);
+        let mut hovered = self.rect_contains_pointer(layer_id, interact_rect);
+
+        // This solves the problem of overlapping widgets.
+        // Whichever widget is added LAST (=on top) gets the input:
+        if interact_rect.is_positive() && sense.interactive() {
+            if self.style().debug.show_interactive_widgets {
+                Self::layer_painter(self, LayerId::debug()).rect(
+                    interact_rect,
+                    0.0,
+                    Color32::YELLOW.additive().linear_multiply(0.005),
+                    Stroke::new(1.0, Color32::YELLOW.additive().linear_multiply(0.05)),
+                );
+            }
+            let mut show_blocking_widget = None;
+
+            self.write(|ctx| {
+                ctx.layer_rects_this_frame
+                    .entry(layer_id)
+                    .or_default()
+                    .push((id, interact_rect));
+
+                if hovered {
+                    let pointer_pos = ctx.input.pointer.interact_pos();
+                    if let Some(pointer_pos) = pointer_pos {
+                        if let Some(rects) = ctx.layer_rects_prev_frame.get(&layer_id) {
+                            for &(prev_id, prev_rect) in rects.iter().rev() {
+                                if prev_id == id {
+                                    break; // there is no other interactive widget covering us at the pointer position.
+                                }
+                                if prev_rect.contains(pointer_pos) {
+                                    // Another interactive widget is covering us at the pointer position,
+                                    // so we aren't hovered.
+
+                                    if ctx.memory.options.style.debug.show_blocking_widget {
+                                        // Store the rects to use them outside the write() call to
+                                        // avoid deadlock
+                                        show_blocking_widget = Some((interact_rect, prev_rect));
+                                    }
+
+                                    hovered = false;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+
+            if let Some((interact_rect, prev_rect)) = show_blocking_widget {
+                Self::layer_painter(self, LayerId::debug()).debug_rect(
+                    interact_rect,
+                    Color32::GREEN,
+                    "Covered",
+                );
+                Self::layer_painter(self, LayerId::debug()).debug_rect(
+                    prev_rect,
+                    Color32::LIGHT_BLUE,
+                    "On top",
+                );
+            }
+        }
+
+        self.interact_with_hovered(layer_id, id, rect, sense, enabled, hovered)
+    }
+
+    /// You specify if a thing is hovered, and the function gives a [`Response`].
+    pub(crate) fn interact_with_hovered(
+        &self,
+        layer_id: LayerId,
+        id: Id,
+        rect: Rect,
+        sense: Sense,
+        enabled: bool,
+        hovered: bool,
+    ) -> Response {
+        let hovered = hovered && enabled; // can't even hover disabled widgets
+
+        let highlighted = self.frame_state(|fs| fs.highlight_this_frame.contains(&id));
+
+        let mut response = Response {
+            ctx: self.clone(),
+            layer_id,
+            id,
+            rect,
+            sense,
+            enabled,
+            hovered,
+            highlighted,
+            clicked: Default::default(),
+            double_clicked: Default::default(),
+            triple_clicked: Default::default(),
+            dragged: false,
+            drag_released: false,
+            is_pointer_button_down_on: false,
+            interact_pointer_pos: None,
+            changed: false, // must be set by the widget itself
+        };
+
+        if !enabled || !sense.focusable || !layer_id.allow_interaction() {
+            // Not interested or allowed input:
+            self.memory_mut(|mem| mem.surrender_focus(id));
+            return response;
+        }
+
+        self.check_for_id_clash(id, rect, "widget");
+
+        #[cfg(feature = "accesskit")]
+        if sense.focusable {
+            // Make sure anything that can receive focus has an AccessKit node.
+            // TODO(mwcampbell): For nodes that are filled from widget info,
+            // some information is written to the node twice.
+            self.accesskit_node_builder(id, |builder| response.fill_accesskit_node_common(builder));
+        }
+
+        let clicked_elsewhere = response.clicked_elsewhere();
+        self.write(|ctx| {
+            let memory = &mut ctx.memory;
+            let input = &mut ctx.input;
+
+            if sense.focusable {
+                memory.interested_in_focus(id);
+            }
+
+            if sense.click
+                && memory.has_focus(response.id)
+                && (input.key_pressed(Key::Space) || input.key_pressed(Key::Enter))
+            {
+                // Space/enter works like a primary click for e.g. selected buttons
+                response.clicked[PointerButton::Primary as usize] = true;
+            }
+
+            #[cfg(feature = "accesskit")]
+            {
+                if sense.click
+                    && input.has_accesskit_action_request(response.id, accesskit::Action::Default)
+                {
+                    response.clicked[PointerButton::Primary as usize] = true;
+                }
+            }
+
+            if sense.click || sense.drag {
+                memory.interaction.click_interest |= hovered && sense.click;
+                memory.interaction.drag_interest |= hovered && sense.drag;
+
+                response.dragged = memory.interaction.drag_id == Some(id);
+                response.is_pointer_button_down_on =
+                    memory.interaction.click_id == Some(id) || response.dragged;
+
+                for pointer_event in &input.pointer.pointer_events {
+                    match pointer_event {
+                        PointerEvent::Moved(_) => {}
+                        PointerEvent::Pressed { .. } => {
+                            if hovered {
+                                if sense.click && memory.interaction.click_id.is_none() {
+                                    // potential start of a click
+                                    memory.interaction.click_id = Some(id);
+                                    response.is_pointer_button_down_on = true;
+                                }
+
+                                // HACK: windows have low priority on dragging.
+                                // This is so that if you drag a slider in a window,
+                                // the slider will steal the drag away from the window.
+                                // This is needed because we do window interaction first (to prevent frame delay),
+                                // and then do content layout.
+                                if sense.drag
+                                    && (memory.interaction.drag_id.is_none()
+                                        || memory.interaction.drag_is_window)
+                                {
+                                    // potential start of a drag
+                                    memory.interaction.drag_id = Some(id);
+                                    memory.interaction.drag_is_window = false;
+                                    memory.window_interaction = None; // HACK: stop moving windows (if any)
+                                    response.is_pointer_button_down_on = true;
+                                    response.dragged = true;
+                                }
+                            }
+                        }
+                        PointerEvent::Released { click, button } => {
+                            response.drag_released = response.dragged;
+                            response.dragged = false;
+
+                            if hovered && response.is_pointer_button_down_on {
+                                if let Some(click) = click {
+                                    let clicked = hovered && response.is_pointer_button_down_on;
+                                    response.clicked[*button as usize] = clicked;
+                                    response.double_clicked[*button as usize] =
+                                        clicked && click.is_double();
+                                    response.triple_clicked[*button as usize] =
+                                        clicked && click.is_triple();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if response.is_pointer_button_down_on {
+                response.interact_pointer_pos = input.pointer.interact_pos();
+            }
+
+            if input.pointer.any_down() {
+                response.hovered &= response.is_pointer_button_down_on; // we don't hover widgets while interacting with *other* widgets
+            }
+
+            if memory.has_focus(response.id) && clicked_elsewhere {
+                memory.surrender_focus(id);
+            }
+
+            if response.dragged() && !memory.has_focus(response.id) {
+                // e.g.: remove focus from a widget when you drag something else
+                memory.stop_text_input();
+            }
+        });
+
+        response
+    }
+
+    /// Get a full-screen painter for a new or existing layer
+    pub fn layer_painter(&self, layer_id: LayerId) -> Painter {
+        let screen_rect = self.screen_rect();
+        Painter::new(self.clone(), layer_id, screen_rect)
+    }
+
+    /// Paint on top of everything else
+    pub fn debug_painter(&self) -> Painter {
+        Self::layer_painter(self, LayerId::debug())
+    }
+
+    /// What operating system are we running on?
+    ///
+    /// When compiling natively, this is
+    /// figured out from the `target_os`.
+    ///
+    /// For web, this can be figured out from the user-agent,
+    /// and is done so by [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+    pub fn os(&self) -> OperatingSystem {
+        self.read(|ctx| ctx.os)
+    }
+
+    /// Set the operating system we are running on.
+    ///
+    /// If you are writing wasm-based integration for egui you
+    /// may want to set this based on e.g. the user-agent.
+    pub fn set_os(&self, os: OperatingSystem) {
+        self.write(|ctx| ctx.os = os);
+    }
+
+    /// Set the cursor icon.
+    ///
+    /// Equivalent to:
+    /// ```
+    /// # let ctx = egui::Context::default();
+    /// ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::PointingHand);
+    /// ```
+    pub fn set_cursor_icon(&self, cursor_icon: CursorIcon) {
+        self.output_mut(|o| o.cursor_icon = cursor_icon);
+    }
+
+    /// Format the given shortcut in a human-readable way (e.g. `Ctrl+Shift+X`).
+    ///
+    /// Can be used to get the text for [`Button::shortcut_text`].
+    pub fn format_shortcut(&self, shortcut: &KeyboardShortcut) -> String {
+        let os = self.os();
+
+        let is_mac = matches!(os, OperatingSystem::Mac | OperatingSystem::IOS);
+
+        let can_show_symbols = || {
+            let ModifierNames {
+                alt,
+                ctrl,
+                shift,
+                mac_cmd,
+                ..
+            } = ModifierNames::SYMBOLS;
+
+            let font_id = TextStyle::Body.resolve(&self.style());
+            self.fonts(|f| {
+                let mut lock = f.lock();
+                let font = lock.fonts.font(&font_id);
+                font.has_glyphs(alt)
+                    && font.has_glyphs(ctrl)
+                    && font.has_glyphs(shift)
+                    && font.has_glyphs(mac_cmd)
+            })
+        };
+
+        if is_mac && can_show_symbols() {
+            shortcut.format(&ModifierNames::SYMBOLS, is_mac)
+        } else {
+            shortcut.format(&ModifierNames::NAMES, is_mac)
+        }
+    }
+
+    /// Call this if there is need to repaint the UI, i.e. if you are showing an animation.
+    ///
+    /// If this is called at least once in a frame, then there will be another frame right after this.
+    /// Call as many times as you wish, only one repaint will be issued.
+    ///
+    /// If called from outside the UI thread, the UI thread will wake up and run,
+    /// provided the egui integration has set that up via [`Self::set_request_repaint_callback`]
+    /// (this will work on `eframe`).
+    pub fn request_repaint(&self) {
+        // request two frames of repaint, just to cover some corner cases (frame delays):
+        self.write(|ctx| {
+            ctx.repaint_requests = 2;
+            if let Some(callback) = &ctx.request_repaint_callback {
+                if !ctx.has_requested_repaint_this_frame {
+                    (callback)();
+                    ctx.has_requested_repaint_this_frame = true;
+                }
+            }
+        });
+    }
+
+    /// Request repaint after the specified duration elapses in the case of no new input
+    /// events being received.
+    ///
+    /// The function can be multiple times, but only the *smallest* duration will be considered.
+    /// So, if the function is called two times with `1 second` and `2 seconds`, egui will repaint
+    /// after `1 second`
+    ///
+    /// This is primarily useful for applications who would like to save battery by avoiding wasted
+    /// redraws when the app is not in focus. But sometimes the GUI of the app might become stale
+    /// and outdated if it is not updated for too long.
+    ///
+    /// Lets say, something like a stop watch widget that displays the time in seconds. You would waste
+    /// resources repainting multiple times within the same second (when you have no input),
+    /// just calculate the difference of duration between current time and next second change,
+    /// and call this function, to make sure that you are displaying the latest updated time, but
+    /// not wasting resources on needless repaints within the same second.
+    ///
+    /// NOTE: only works if called before `Context::end_frame()`. to force egui to update,
+    /// use `Context::request_repaint()` instead.
+    ///
+    /// ### Quirk:
+    /// Duration begins at the next frame. lets say for example that its a very inefficient app
+    /// and takes 500 milliseconds per frame at 2 fps. The widget / user might want a repaint in
+    /// next 500 milliseconds. Now, app takes 1000 ms per frame (1 fps) because the backend event
+    /// timeout takes 500 milliseconds AFTER the vsync swap buffer.
+    /// So, its not that we are requesting repaint within X duration. We are rather timing out
+    /// during app idle time where we are not receiving any new input events.
+    pub fn request_repaint_after(&self, duration: std::time::Duration) {
+        // Maybe we can check if duration is ZERO, and call self.request_repaint()?
+        self.write(|ctx| ctx.repaint_after = ctx.repaint_after.min(duration));
+    }
+
+    /// For integrations: this callback will be called when an egui user calls [`Self::request_repaint`].
+    ///
+    /// This lets you wake up a sleeping UI thread.
+    ///
+    /// Note that only one callback can be set. Any new call overrides the previous callback.
+    pub fn set_request_repaint_callback(&self, callback: impl Fn() + Send + Sync + 'static) {
+        let callback = Box::new(callback);
+        self.write(|ctx| ctx.request_repaint_callback = Some(callback));
+    }
+
+    /// Tell `egui` which fonts to use.
+    ///
+    /// The default `egui` fonts only support latin and cyrillic alphabets,
+    /// but you can call this to install additional fonts that support e.g. korean characters.
+    ///
+    /// The new fonts will become active at the start of the next frame.
+    pub fn set_fonts(&self, font_definitions: FontDefinitions) {
+        let update_fonts = self.fonts_mut(|fonts| {
+            if let Some(current_fonts) = fonts {
+                // NOTE: this comparison is expensive since it checks TTF data for equality
+                current_fonts.lock().fonts.definitions() != &font_definitions
+            } else {
+                true
+            }
+        });
+
+        if update_fonts {
+            self.memory_mut(|mem| mem.new_font_definitions = Some(font_definitions));
+        }
+    }
+
+    /// The [`Style`] used by all subsequent windows, panels etc.
+    pub fn style(&self) -> Arc<Style> {
+        self.options(|opt| opt.style.clone())
+    }
+
+    /// The [`Style`] used by all new windows, panels etc.
+    ///
+    /// You can also use [`Ui::style_mut`] to change the style of a single [`Ui`].
+    ///
+    /// Example:
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// let mut style: egui::Style = (*ctx.style()).clone();
+    /// style.spacing.item_spacing = egui::vec2(10.0, 20.0);
+    /// ctx.set_style(style);
+    /// ```
+    pub fn set_style(&self, style: impl Into<Arc<Style>>) {
+        self.options_mut(|opt| opt.style = style.into());
+    }
+
+    /// The [`Visuals`] used by all subsequent windows, panels etc.
+    ///
+    /// You can also use [`Ui::visuals_mut`] to change the visuals of a single [`Ui`].
+    ///
+    /// Example:
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.set_visuals(egui::Visuals::light()); // Switch to light mode
+    /// ```
+    pub fn set_visuals(&self, visuals: crate::Visuals) {
+        self.options_mut(|opt| std::sync::Arc::make_mut(&mut opt.style).visuals = visuals);
+    }
+
+    /// The number of physical pixels for each logical point.
+    #[inline(always)]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.input(|i| i.pixels_per_point())
+    }
+
+    /// Set the number of physical pixels for each logical point.
+    /// Will become active at the start of the next frame.
+    ///
+    /// Note that this may be overwritten by input from the integration via [`RawInput::pixels_per_point`].
+    /// For instance, when using `eframe` on web, the browsers native zoom level will always be used.
+    pub fn set_pixels_per_point(&self, pixels_per_point: f32) {
+        if pixels_per_point != self.pixels_per_point() {
+            self.request_repaint();
+            self.memory_mut(|mem| mem.new_pixels_per_point = Some(pixels_per_point));
+        }
+    }
+
+    /// Useful for pixel-perfect rendering
+    pub(crate) fn round_to_pixel(&self, point: f32) -> f32 {
+        let pixels_per_point = self.pixels_per_point();
+        (point * pixels_per_point).round() / pixels_per_point
+    }
+
+    /// Useful for pixel-perfect rendering
+    pub(crate) fn round_pos_to_pixels(&self, pos: Pos2) -> Pos2 {
+        pos2(self.round_to_pixel(pos.x), self.round_to_pixel(pos.y))
+    }
+
+    /// Useful for pixel-perfect rendering
+    pub(crate) fn round_vec_to_pixels(&self, vec: Vec2) -> Vec2 {
+        vec2(self.round_to_pixel(vec.x), self.round_to_pixel(vec.y))
+    }
+
+    /// Useful for pixel-perfect rendering
+    pub(crate) fn round_rect_to_pixels(&self, rect: Rect) -> Rect {
+        Rect {
+            min: self.round_pos_to_pixels(rect.min),
+            max: self.round_pos_to_pixels(rect.max),
+        }
+    }
+
+    /// Allocate a texture.
+    ///
+    /// In order to display an image you must convert it to a texture using this function.
+    ///
+    /// Make sure to only call this once for each image, i.e. NOT in your main GUI code.
+    ///
+    /// The given name can be useful for later debugging, and will be visible if you call [`Self::texture_ui`].
+    ///
+    /// For how to load an image, see [`ImageData`] and [`ColorImage::from_rgba_unmultiplied`].
+    ///
+    /// ```
+    /// struct MyImage {
+    ///     texture: Option<egui::TextureHandle>,
+    /// }
+    ///
+    /// impl MyImage {
+    ///     fn ui(&mut self, ui: &mut egui::Ui) {
+    ///         let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+    ///             // Load the texture only once.
+    ///             ui.ctx().load_texture(
+    ///                 "my-image",
+    ///                 egui::ColorImage::example(),
+    ///                 Default::default()
+    ///             )
+    ///         });
+    ///
+    ///         // Show the image:
+    ///         ui.image(texture, texture.size_vec2());
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Se also [`crate::ImageData`], [`crate::Ui::image`] and [`crate::ImageButton`].
+    pub fn load_texture(
+        &self,
+        name: impl Into<String>,
+        image: impl Into<ImageData>,
+        options: TextureOptions,
+    ) -> TextureHandle {
+        let name = name.into();
+        let image = image.into();
+        let max_texture_side = self.input(|i| i.max_texture_side);
+        crate::egui_assert!(
+            image.width() <= max_texture_side && image.height() <= max_texture_side,
+            "Texture {:?} has size {}x{}, but the maximum texture side is {}",
+            name,
+            image.width(),
+            image.height(),
+            max_texture_side
+        );
+        let tex_mngr = self.tex_manager();
+        let tex_id = tex_mngr.write().alloc(name, image, options);
+        TextureHandle::new(tex_mngr, tex_id)
+    }
+
+    /// Low-level texture manager.
+    ///
+    /// In general it is easier to use [`Self::load_texture`] and [`TextureHandle`].
+    ///
+    /// You can show stats about the allocated textures using [`Self::texture_ui`].
+    pub fn tex_manager(&self) -> Arc<RwLock<epaint::textures::TextureManager>> {
+        self.read(|ctx| ctx.tex_manager.0.clone())
+    }
+
+    // ---------------------------------------------------------------------
+
+    /// Constrain the position of a window/area so it fits within the provided boundary.
+    ///
+    /// If area is `None`, will constrain to [`Self::available_rect`].
+    pub(crate) fn constrain_window_rect_to_area(&self, window: Rect, area: Option<Rect>) -> Rect {
+        let mut area = area.unwrap_or_else(|| self.available_rect());
+
+        if window.width() > area.width() {
+            // Allow overlapping side bars.
+            // This is important for small screens, e.g. mobiles running the web demo.
+            let screen_rect = self.screen_rect();
+            (area.min.x, area.max.x) = (screen_rect.min.x, screen_rect.max.x);
+        }
+        if window.height() > area.height() {
+            // Allow overlapping top/bottom bars:
+            let screen_rect = self.screen_rect();
+            (area.min.y, area.max.y) = (screen_rect.min.y, screen_rect.max.y);
+        }
+
+        let mut pos = window.min;
+
+        // Constrain to screen, unless window is too large to fit:
+        let margin_x = (window.width() - area.width()).at_least(0.0);
+        let margin_y = (window.height() - area.height()).at_least(0.0);
+
+        pos.x = pos.x.at_most(area.right() + margin_x - window.width()); // move left if needed
+        pos.x = pos.x.at_least(area.left() - margin_x); // move right if needed
+        pos.y = pos.y.at_most(area.bottom() + margin_y - window.height()); // move right if needed
+        pos.y = pos.y.at_least(area.top() - margin_y); // move down if needed
+
+        pos = self.round_pos_to_pixels(pos);
+
+        Rect::from_min_size(pos, window.size())
+    }
+}
+
+impl Context {
+    /// Call at the end of each frame.
+    #[must_use]
+    pub fn end_frame(&self) -> FullOutput {
+        if self.input(|i| i.wants_repaint()) {
+            self.request_repaint();
+        }
+
+        let textures_delta = self.write(|ctx| {
+            ctx.memory.end_frame(&ctx.input, &ctx.frame_state.used_ids);
+
+            let font_image_delta = ctx.fonts.as_ref().unwrap().font_image_delta();
+            if let Some(font_image_delta) = font_image_delta {
+                ctx.tex_manager
+                    .0
+                    .write()
+                    .set(TextureId::default(), font_image_delta);
+            }
+
+            ctx.tex_manager.0.write().take_delta()
+        });
+
+        #[cfg_attr(not(feature = "accesskit"), allow(unused_mut))]
+        let mut platform_output: PlatformOutput = self.output_mut(|o| std::mem::take(o));
+
+        #[cfg(feature = "accesskit")]
+        {
+            let state = self.frame_state_mut(|fs| fs.accesskit_state.take());
+            if let Some(state) = state {
+                let has_focus = self.input(|i| i.raw.has_focus);
+                let root_id = crate::accesskit_root_id().accesskit_id();
+                let nodes = self.write(|ctx| {
+                    state
+                        .node_builders
+                        .into_iter()
+                        .map(|(id, builder)| {
+                            (
+                                id.accesskit_id(),
+                                builder.build(&mut ctx.accesskit_node_classes),
+                            )
+                        })
+                        .collect()
+                });
+                platform_output.accesskit_update = Some(accesskit::TreeUpdate {
+                    nodes,
+                    tree: Some(accesskit::Tree::new(root_id)),
+                    focus: has_focus.then(|| {
+                        let focus_id = self.memory(|mem| mem.interaction.focus.id);
+                        focus_id.map_or(root_id, |id| id.accesskit_id())
+                    }),
+                });
+            }
+        }
+
+        // if repaint_requests is greater than zero. just set the duration to zero for immediate
+        // repaint. if there's no repaint requests, then we can use the actual repaint_after instead.
+        let repaint_after = self.write(|ctx| {
+            if ctx.repaint_requests > 0 {
+                ctx.repaint_requests -= 1;
+                std::time::Duration::ZERO
+            } else {
+                ctx.repaint_after
+            }
+        });
+
+        self.write(|ctx| {
+            ctx.requested_repaint_last_frame = repaint_after.is_zero();
+
+            ctx.has_requested_repaint_this_frame = false; // allow new calls between frames
+
+            // make sure we reset the repaint_after duration.
+            // otherwise, if repaint_after is low, then any widget setting repaint_after next frame,
+            // will fail to overwrite the previous lower value. and thus, repaints will never
+            // go back to higher values.
+            ctx.repaint_after = std::time::Duration::MAX;
+        });
+        let shapes = self.drain_paint_lists();
+
+        FullOutput {
+            platform_output,
+            repaint_after,
+            textures_delta,
+            shapes,
+        }
+    }
+
+    fn drain_paint_lists(&self) -> Vec<ClippedShape> {
+        self.write(|ctx| ctx.graphics.drain(ctx.memory.areas.order()).collect())
+    }
+
+    /// Tessellate the given shapes into triangle meshes.
+    pub fn tessellate(&self, shapes: Vec<ClippedShape>) -> Vec<ClippedPrimitive> {
+        // A tempting optimization is to reuse the tessellation from last frame if the
+        // shapes are the same, but just comparing the shapes takes about 50% of the time
+        // it takes to tessellate them, so it is not a worth optimization.
+
+        // here we expect that we are the only user of context, since frame is ended
+        self.write(|ctx| {
+            let pixels_per_point = ctx.input.pixels_per_point();
+            let tessellation_options = ctx.memory.options.tessellation_options;
+            let texture_atlas = ctx
+                .fonts
+                .as_ref()
+                .expect("tessellate called before first call to Context::run()")
+                .texture_atlas();
+            let (font_tex_size, prepared_discs) = {
+                let atlas = texture_atlas.lock();
+                (atlas.size(), atlas.prepared_discs())
+            };
+
+            let paint_stats = PaintStats::from_shapes(&shapes);
+            let clipped_primitives = tessellator::tessellate_shapes(
+                pixels_per_point,
+                tessellation_options,
+                font_tex_size,
+                prepared_discs,
+                shapes,
+            );
+            ctx.paint_stats = paint_stats.with_clipped_primitives(&clipped_primitives);
+            clipped_primitives
+        })
+    }
+
+    // ---------------------------------------------------------------------
+
+    /// Position and size of the egui area.
+    pub fn screen_rect(&self) -> Rect {
+        self.input(|i| i.screen_rect())
+    }
+
+    /// How much space is still available after panels has been added.
+    ///
+    /// This is the "background" area, what egui doesn't cover with panels (but may cover with windows).
+    /// This is also the area to which windows are constrained.
+    pub fn available_rect(&self) -> Rect {
+        self.frame_state(|s| s.available_rect())
+    }
+
+    /// How much space is used by panels and windows.
+    pub fn used_rect(&self) -> Rect {
+        self.read(|ctx| {
+            let mut used = ctx.frame_state.used_by_panels;
+            for window in ctx.memory.areas.visible_windows() {
+                used = used.union(window.rect());
+            }
+            used
+        })
+    }
+
+    /// How much space is used by panels and windows.
+    ///
+    /// You can shrink your egui area to this size and still fit all egui components.
+    pub fn used_size(&self) -> Vec2 {
+        self.used_rect().max - Pos2::ZERO
+    }
+
+    // ---------------------------------------------------------------------
+
+    /// Is the pointer (mouse/touch) over any egui area?
+    pub fn is_pointer_over_area(&self) -> bool {
+        let pointer_pos = self.input(|i| i.pointer.interact_pos());
+        if let Some(pointer_pos) = pointer_pos {
+            if let Some(layer) = self.layer_id_at(pointer_pos) {
+                if layer.order == Order::Background {
+                    !self.frame_state(|state| state.unused_rect.contains(pointer_pos))
+                } else {
+                    true
+                }
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    /// True if egui is currently interested in the pointer (mouse or touch).
+    ///
+    /// Could be the pointer is hovering over a [`Window`] or the user is dragging a widget.
+    /// If `false`, the pointer is outside of any egui area and so
+    /// you may be interested in what it is doing (e.g. controlling your game).
+    /// Returns `false` if a drag started outside of egui and then moved over an egui area.
+    pub fn wants_pointer_input(&self) -> bool {
+        self.is_using_pointer()
+            || (self.is_pointer_over_area() && !self.input(|i| i.pointer.any_down()))
+    }
+
+    /// Is egui currently using the pointer position (e.g. dragging a slider)?
+    ///
+    /// NOTE: this will return `false` if the pointer is just hovering over an egui area.
+    pub fn is_using_pointer(&self) -> bool {
+        self.memory(|m| m.interaction.is_using_pointer())
+    }
+
+    /// If `true`, egui is currently listening on text input (e.g. typing text in a [`TextEdit`]).
+    pub fn wants_keyboard_input(&self) -> bool {
+        self.memory(|m| m.interaction.focus.focused().is_some())
+    }
+
+    /// Highlight this widget, to make it look like it is hovered, even if it isn't.
+    ///
+    /// The highlight takes on frame to take effect if you call this after the widget has been fully rendered.
+    ///
+    /// See also [`Response::highlight`].
+    pub fn highlight_widget(&self, id: Id) {
+        self.frame_state_mut(|fs| fs.highlight_next_frame.insert(id));
+    }
+}
+
+// Ergonomic methods to forward some calls often used in 'if let' without holding the borrow
+impl Context {
+    /// Latest reported pointer position.
+    ///
+    /// When tapping a touch screen, this will be `None`.
+    #[inline(always)]
+    pub fn pointer_latest_pos(&self) -> Option<Pos2> {
+        self.input(|i| i.pointer.latest_pos())
+    }
+
+    /// If it is a good idea to show a tooltip, where is pointer?
+    #[inline(always)]
+    pub fn pointer_hover_pos(&self) -> Option<Pos2> {
+        self.input(|i| i.pointer.hover_pos())
+    }
+
+    /// If you detect a click or drag and wants to know where it happened, use this.
+    ///
+    /// Latest position of the mouse, but ignoring any [`Event::PointerGone`]
+    /// if there were interactions this frame.
+    /// When tapping a touch screen, this will be the location of the touch.
+    #[inline(always)]
+    pub fn pointer_interact_pos(&self) -> Option<Pos2> {
+        self.input(|i| i.pointer.interact_pos())
+    }
+
+    /// Calls [`InputState::multi_touch`].
+    pub fn multi_touch(&self) -> Option<MultiTouchInfo> {
+        self.input(|i| i.multi_touch())
+    }
+}
+
+impl Context {
+    /// Move all the graphics at the given layer.
+    ///
+    /// Can be used to implement drag-and-drop (see relevant demo).
+    pub fn translate_layer(&self, layer_id: LayerId, delta: Vec2) {
+        if delta != Vec2::ZERO {
+            self.graphics_mut(|g| g.list(layer_id).translate(delta));
+        }
+    }
+
+    /// Top-most layer at the given position.
+    pub fn layer_id_at(&self, pos: Pos2) -> Option<LayerId> {
+        self.memory(|mem| {
+            mem.layer_id_at(pos, mem.options.style.interaction.resize_grab_radius_side)
+        })
+    }
+
+    /// Moves the given area to the top in its [`Order`].
+    ///
+    /// [`Area`]:s and [`Window`]:s also do this automatically when being clicked on or interacted with.
+    pub fn move_to_top(&self, layer_id: LayerId) {
+        self.memory_mut(|mem| mem.areas.move_to_top(layer_id));
+    }
+
+    pub(crate) fn rect_contains_pointer(&self, layer_id: LayerId, rect: Rect) -> bool {
+        rect.is_positive() && {
+            let pointer_pos = self.input(|i| i.pointer.interact_pos());
+            if let Some(pointer_pos) = pointer_pos {
+                rect.contains(pointer_pos) && self.layer_id_at(pointer_pos) == Some(layer_id)
+            } else {
+                false
+            }
+        }
+    }
+
+    // ---------------------------------------------------------------------
+
+    /// Whether or not to debug widget layout on hover.
+    pub fn debug_on_hover(&self) -> bool {
+        self.options(|opt| opt.style.debug.debug_on_hover)
+    }
+
+    /// Turn on/off whether or not to debug widget layout on hover.
+    pub fn set_debug_on_hover(&self, debug_on_hover: bool) {
+        let mut style = self.options(|opt| (*opt.style).clone());
+        style.debug.debug_on_hover = debug_on_hover;
+        self.set_style(style);
+    }
+}
+
+/// ## Animation
+impl Context {
+    /// Returns a value in the range [0, 1], to indicate "how on" this thing is.
+    ///
+    /// The first time called it will return `if value { 1.0 } else { 0.0 }`
+    /// Calling this with `value = true` will always yield a number larger than zero, quickly going towards one.
+    /// Calling this with `value = false` will always yield a number less than one, quickly going towards zero.
+    ///
+    /// The function will call [`Self::request_repaint()`] when appropriate.
+    ///
+    /// The animation time is taken from [`Style::animation_time`].
+    pub fn animate_bool(&self, id: Id, value: bool) -> f32 {
+        let animation_time = self.style().animation_time;
+        self.animate_bool_with_time(id, value, animation_time)
+    }
+
+    /// Like [`Self::animate_bool`] but allows you to control the animation time.
+    pub fn animate_bool_with_time(&self, id: Id, target_value: bool, animation_time: f32) -> f32 {
+        let animated_value = self.write(|ctx| {
+            ctx.animation_manager
+                .animate_bool(&ctx.input, animation_time, id, target_value)
+        });
+        let animation_in_progress = 0.0 < animated_value && animated_value < 1.0;
+        if animation_in_progress {
+            self.request_repaint();
+        }
+        animated_value
+    }
+
+    /// Smoothly animate an `f32` value.
+    ///
+    /// At the first call the value is written to memory.
+    /// When it is called with a new value, it linearly interpolates to it in the given time.
+    pub fn animate_value_with_time(&self, id: Id, target_value: f32, animation_time: f32) -> f32 {
+        let animated_value = self.write(|ctx| {
+            ctx.animation_manager
+                .animate_value(&ctx.input, animation_time, id, target_value)
+        });
+        let animation_in_progress = animated_value != target_value;
+        if animation_in_progress {
+            self.request_repaint();
+        }
+
+        animated_value
+    }
+
+    /// Clear memory of any animations.
+    pub fn clear_animations(&self) {
+        self.write(|ctx| ctx.animation_manager = Default::default());
+    }
+}
+
+impl Context {
+    pub fn settings_ui(&self, ui: &mut Ui) {
+        use crate::containers::*;
+
+        CollapsingHeader::new("🎑 Style")
+            .default_open(true)
+            .show(ui, |ui| {
+                self.style_ui(ui);
+            });
+
+        CollapsingHeader::new("✒ Painting")
+            .default_open(true)
+            .show(ui, |ui| {
+                let prev_tessellation_options = self.tessellation_options(|o| *o);
+                let mut tessellation_options = prev_tessellation_options;
+                tessellation_options.ui(ui);
+                ui.vertical_centered(|ui| reset_button(ui, &mut tessellation_options));
+                if tessellation_options != prev_tessellation_options {
+                    self.tessellation_options_mut(move |o| *o = tessellation_options);
+                }
+            });
+    }
+
+    pub fn inspection_ui(&self, ui: &mut Ui) {
+        use crate::containers::*;
+        crate::trace!(ui);
+
+        ui.label(format!("Is using pointer: {}", self.is_using_pointer()))
+            .on_hover_text(
+                "Is egui currently using the pointer actively (e.g. dragging a slider)?",
+            );
+        ui.label(format!("Wants pointer input: {}", self.wants_pointer_input()))
+            .on_hover_text("Is egui currently interested in the location of the pointer (either because it is in use, or because it is hovering over a window).");
+        ui.label(format!(
+            "Wants keyboard input: {}",
+            self.wants_keyboard_input()
+        ))
+        .on_hover_text("Is egui currently listening for text input?");
+        ui.label(format!(
+            "Keyboard focus widget: {}",
+            self.memory(|m| m.interaction.focus.focused())
+                .as_ref()
+                .map(Id::short_debug_format)
+                .unwrap_or_default()
+        ))
+        .on_hover_text("Is egui currently listening for text input?");
+
+        let pointer_pos = self
+            .pointer_hover_pos()
+            .map_or_else(String::new, |pos| format!("{:?}", pos));
+        ui.label(format!("Pointer pos: {}", pointer_pos));
+
+        let top_layer = self
+            .pointer_hover_pos()
+            .and_then(|pos| self.layer_id_at(pos))
+            .map_or_else(String::new, |layer| layer.short_debug_format());
+        ui.label(format!("Top layer under mouse: {}", top_layer));
+
+        ui.add_space(16.0);
+
+        ui.label(format!(
+            "There are {} text galleys in the layout cache",
+            self.fonts(|f| f.num_galleys_in_cache())
+        ))
+        .on_hover_text("This is approximately the number of text strings on screen");
+        ui.add_space(16.0);
+
+        CollapsingHeader::new("📥 Input")
+            .default_open(false)
+            .show(ui, |ui| {
+                let input = ui.input(|i| i.clone());
+                input.ui(ui);
+            });
+
+        CollapsingHeader::new("📊 Paint stats")
+            .default_open(false)
+            .show(ui, |ui| {
+                let paint_stats = self.read(|ctx| ctx.paint_stats);
+                paint_stats.ui(ui);
+            });
+
+        CollapsingHeader::new("🖼 Textures")
+            .default_open(false)
+            .show(ui, |ui| {
+                self.texture_ui(ui);
+            });
+
+        CollapsingHeader::new("🔠 Font texture")
+            .default_open(false)
+            .show(ui, |ui| {
+                let font_image_size = self.fonts(|f| f.font_image_size());
+                crate::introspection::font_texture_ui(ui, font_image_size);
+            });
+    }
+
+    /// Show stats about the allocated textures.
+    pub fn texture_ui(&self, ui: &mut crate::Ui) {
+        let tex_mngr = self.tex_manager();
+        let tex_mngr = tex_mngr.read();
+
+        let mut textures: Vec<_> = tex_mngr.allocated().collect();
+        textures.sort_by_key(|(id, _)| *id);
+
+        let mut bytes = 0;
+        for (_, tex) in &textures {
+            bytes += tex.bytes_used();
+        }
+
+        ui.label(format!(
+            "{} allocated texture(s), using {:.1} MB",
+            textures.len(),
+            bytes as f64 * 1e-6
+        ));
+        let max_preview_size = vec2(48.0, 32.0);
+
+        ui.group(|ui| {
+            ScrollArea::vertical()
+                .max_height(300.0)
+                .auto_shrink([false, true])
+                .show(ui, |ui| {
+                    ui.style_mut().override_text_style = Some(TextStyle::Monospace);
+                    Grid::new("textures")
+                        .striped(true)
+                        .num_columns(4)
+                        .spacing(vec2(16.0, 2.0))
+                        .min_row_height(max_preview_size.y)
+                        .show(ui, |ui| {
+                            for (&texture_id, meta) in textures {
+                                let [w, h] = meta.size;
+
+                                let mut size = vec2(w as f32, h as f32);
+                                size *= (max_preview_size.x / size.x).min(1.0);
+                                size *= (max_preview_size.y / size.y).min(1.0);
+                                ui.image(texture_id, size).on_hover_ui(|ui| {
+                                    // show larger on hover
+                                    let max_size = 0.5 * ui.ctx().screen_rect().size();
+                                    let mut size = vec2(w as f32, h as f32);
+                                    size *= max_size.x / size.x.max(max_size.x);
+                                    size *= max_size.y / size.y.max(max_size.y);
+                                    ui.image(texture_id, size);
+                                });
+
+                                ui.label(format!("{} x {}", w, h));
+                                ui.label(format!("{:.3} MB", meta.bytes_used() as f64 * 1e-6));
+                                ui.label(format!("{:?}", meta.name));
+                                ui.end_row();
+                            }
+                        });
+                });
+        });
+    }
+
+    pub fn memory_ui(&self, ui: &mut crate::Ui) {
+        if ui
+            .button("Reset all")
+            .on_hover_text("Reset all egui state")
+            .clicked()
+        {
+            self.memory_mut(|mem| *mem = Default::default());
+        }
+
+        let (num_state, num_serialized) = self.data(|d| (d.len(), d.count_serialized()));
+        ui.label(format!(
+            "{} widget states stored (of which {} are serialized).",
+            num_state, num_serialized
+        ));
+
+        ui.horizontal(|ui| {
+            ui.label(format!(
+                "{} areas (panels, windows, popups, …)",
+                self.memory(|mem| mem.areas.count())
+            ));
+            if ui.button("Reset").clicked() {
+                self.memory_mut(|mem| mem.areas = Default::default());
+            }
+        });
+        ui.indent("areas", |ui| {
+            ui.label("Visible areas, ordered back to front.");
+            ui.label("Hover to highlight");
+            let layers_ids: Vec<LayerId> = self.memory(|mem| mem.areas.order().to_vec());
+            for layer_id in layers_ids {
+                let area = self.memory(|mem| mem.areas.get(layer_id.id).copied());
+                if let Some(area) = area {
+                    let is_visible = self.memory(|mem| mem.areas.is_visible(&layer_id));
+                    if !is_visible {
+                        continue;
+                    }
+                    let text = format!("{} - {:?}", layer_id.short_debug_format(), area.rect(),);
+                    // TODO(emilk): `Sense::hover_highlight()`
+                    if ui
+                        .add(Label::new(RichText::new(text).monospace()).sense(Sense::click()))
+                        .hovered
+                        && is_visible
+                    {
+                        ui.ctx()
+                            .debug_painter()
+                            .debug_rect(area.rect(), Color32::RED, "");
+                    }
+                }
+            }
+        });
+
+        ui.horizontal(|ui| {
+            ui.label(format!(
+                "{} collapsing headers",
+                self.data(|d| d.count::<containers::collapsing_header::InnerState>())
+            ));
+            if ui.button("Reset").clicked() {
+                self.data_mut(|d| d.remove_by_type::<containers::collapsing_header::InnerState>());
+            }
+        });
+
+        ui.horizontal(|ui| {
+            ui.label(format!(
+                "{} menu bars",
+                self.data(|d| d.count::<menu::BarState>())
+            ));
+            if ui.button("Reset").clicked() {
+                self.data_mut(|d| d.remove_by_type::<menu::BarState>());
+            }
+        });
+
+        ui.horizontal(|ui| {
+            ui.label(format!(
+                "{} scroll areas",
+                self.data(|d| d.count::<scroll_area::State>())
+            ));
+            if ui.button("Reset").clicked() {
+                self.data_mut(|d| d.remove_by_type::<scroll_area::State>());
+            }
+        });
+
+        ui.horizontal(|ui| {
+            ui.label(format!(
+                "{} resize areas",
+                self.data(|d| d.count::<resize::State>())
+            ));
+            if ui.button("Reset").clicked() {
+                self.data_mut(|d| d.remove_by_type::<resize::State>());
+            }
+        });
+
+        ui.shrink_width_to_current(); // don't let the text below grow this window wider
+        ui.label("NOTE: the position of this window cannot be reset from within itself.");
+
+        ui.collapsing("Interaction", |ui| {
+            let interaction = self.memory(|mem| mem.interaction.clone());
+            interaction.ui(ui);
+        });
+    }
+}
+
+impl Context {
+    pub fn style_ui(&self, ui: &mut Ui) {
+        let mut style: Style = (*self.style()).clone();
+        style.ui(ui);
+        self.set_style(style);
+    }
+}
+
+/// ## Accessibility
+impl Context {
+    /// Call the provided function with the given ID pushed on the stack of
+    /// parent IDs for accessibility purposes. If the `accesskit` feature
+    /// is disabled or if AccessKit support is not active for this frame,
+    /// the function is still called, but with no other effect.
+    ///
+    /// No locks are held while the given closure is called.
+    pub fn with_accessibility_parent(&self, _id: Id, f: impl FnOnce()) {
+        // TODO(emilk): this isn't thread-safe - another thread can call this function between the push/pop calls
+        #[cfg(feature = "accesskit")]
+        self.frame_state_mut(|fs| {
+            if let Some(state) = fs.accesskit_state.as_mut() {
+                state.parent_stack.push(_id);
+            }
+        });
+
+        f();
+
+        #[cfg(feature = "accesskit")]
+        self.frame_state_mut(|fs| {
+            if let Some(state) = fs.accesskit_state.as_mut() {
+                assert_eq!(state.parent_stack.pop(), Some(_id));
+            }
+        });
+    }
+
+    /// If AccessKit support is active for the current frame, get or create
+    /// a node builder with the specified ID and return a mutable reference to it.
+    /// For newly created nodes, the parent is the node with the ID at the top
+    /// of the stack managed by [`Context::with_accessibility_parent`].
+    ///
+    /// The `Context` lock is held while the given closure is called!
+    ///
+    /// Returns `None` if acesskit is off.
+    // TODO: consider making both RO and RW versions
+    #[cfg(feature = "accesskit")]
+    pub fn accesskit_node_builder<R>(
+        &self,
+        id: Id,
+        writer: impl FnOnce(&mut accesskit::NodeBuilder) -> R,
+    ) -> Option<R> {
+        self.write(|ctx| {
+            ctx.frame_state
+                .accesskit_state
+                .is_some()
+                .then(|| ctx.accesskit_node_builder(id))
+                .map(writer)
+        })
+    }
+
+    /// Enable generation of AccessKit tree updates in all future frames.
+    ///
+    /// If it's practical for the egui integration to immediately run the egui
+    /// application when it is either initializing the AccessKit adapter or
+    /// being called by the AccessKit adapter to provide the initial tree update,
+    /// then it should do so, to provide a complete AccessKit tree to the adapter
+    /// immediately. Otherwise, it should enqueue a repaint and use the
+    /// placeholder tree update from [`Context::accesskit_placeholder_tree_update`]
+    /// in the meantime.
+    #[cfg(feature = "accesskit")]
+    pub fn enable_accesskit(&self) {
+        self.write(|ctx| ctx.is_accesskit_enabled = true);
+    }
+
+    /// Return a tree update that the egui integration should provide to the
+    /// AccessKit adapter if it cannot immediately run the egui application
+    /// to get a full tree update after running [`Context::enable_accesskit`].
+    #[cfg(feature = "accesskit")]
+    pub fn accesskit_placeholder_tree_update(&self) -> accesskit::TreeUpdate {
+        use accesskit::{NodeBuilder, Role, Tree, TreeUpdate};
+
+        let root_id = crate::accesskit_root_id().accesskit_id();
+        self.write(|ctx| TreeUpdate {
+            nodes: vec![(
+                root_id,
+                NodeBuilder::new(Role::Window).build(&mut ctx.accesskit_node_classes),
+            )],
+            tree: Some(Tree::new(root_id)),
+            focus: None,
+        })
+    }
+}
+
+#[test]
+fn context_impl_send_sync() {
+    fn assert_send_sync<T: Send + Sync>() {}
+    assert_send_sync::<Context>();
+}
diff --git a/egui/crates/egui/src/data/input.rs b/egui/crates/egui/src/data/input.rs
new file mode 100644
index 0000000..67c1853
--- /dev/null
+++ b/egui/crates/egui/src/data/input.rs
@@ -0,0 +1,940 @@
+//! The input needed by egui.
+
+use crate::emath::*;
+
+/// What the integrations provides to egui at the start of each frame.
+///
+/// Set the values that make sense, leave the rest at their `Default::default()`.
+///
+/// You can check if `egui` is using the inputs using
+/// [`crate::Context::wants_pointer_input`] and [`crate::Context::wants_keyboard_input`].
+///
+/// All coordinates are in points (logical pixels) with origin (0, 0) in the top left corner.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct RawInput {
+    /// Position and size of the area that egui should use, in points.
+    /// Usually you would set this to
+    ///
+    /// `Some(Rect::from_pos_size(Default::default(), screen_size_in_points))`.
+    ///
+    /// but you could also constrain egui to some smaller portion of your window if you like.
+    ///
+    /// `None` will be treated as "same as last frame", with the default being a very big area.
+    pub screen_rect: Option<Rect>,
+
+    /// Also known as device pixel ratio, > 1 for high resolution screens.
+    /// If text looks blurry you probably forgot to set this.
+    /// Set this the first frame, whenever it changes, or just on every frame.
+    pub pixels_per_point: Option<f32>,
+
+    /// Maximum size of one side of the font texture.
+    ///
+    /// Ask your graphics drivers about this. This corresponds to `GL_MAX_TEXTURE_SIZE`.
+    ///
+    /// The default is a very small (but very portable) 2048.
+    pub max_texture_side: Option<usize>,
+
+    /// Monotonically increasing time, in seconds. Relative to whatever. Used for animations.
+    /// If `None` is provided, egui will assume a time delta of `predicted_dt` (default 1/60 seconds).
+    pub time: Option<f64>,
+
+    /// Should be set to the expected time between frames when painting at vsync speeds.
+    /// The default for this is 1/60.
+    /// Can safely be left at its default value.
+    pub predicted_dt: f32,
+
+    /// Which modifier keys are down at the start of the frame?
+    pub modifiers: Modifiers,
+
+    /// In-order events received this frame.
+    ///
+    /// There is currently no way to know if egui handles a particular event,
+    /// but you can check if egui is using the keyboard with [`crate::Context::wants_keyboard_input`]
+    /// and/or the pointer (mouse/touch) with [`crate::Context::is_using_pointer`].
+    pub events: Vec<Event>,
+
+    /// Dragged files hovering over egui.
+    pub hovered_files: Vec<HoveredFile>,
+
+    /// Dragged files dropped into egui.
+    ///
+    /// Note: when using `eframe` on Windows you need to enable
+    /// drag-and-drop support using `eframe::NativeOptions`.
+    pub dropped_files: Vec<DroppedFile>,
+
+    /// The window has the keyboard focus (i.e. is receiving key presses).
+    pub has_focus: bool,
+}
+
+impl Default for RawInput {
+    fn default() -> Self {
+        Self {
+            screen_rect: None,
+            pixels_per_point: None,
+            max_texture_side: None,
+            time: None,
+            predicted_dt: 1.0 / 60.0,
+            modifiers: Modifiers::default(),
+            events: vec![],
+            hovered_files: Default::default(),
+            dropped_files: Default::default(),
+            has_focus: true, // integrations opt into global focus tracking
+        }
+    }
+}
+
+impl RawInput {
+    /// Helper: move volatile (deltas and events), clone the rest.
+    ///
+    /// * [`Self::hovered_files`] is cloned.
+    /// * [`Self::dropped_files`] is moved.
+    pub fn take(&mut self) -> RawInput {
+        RawInput {
+            screen_rect: self.screen_rect.take(),
+            pixels_per_point: self.pixels_per_point.take(),
+            max_texture_side: self.max_texture_side.take(),
+            time: self.time.take(),
+            predicted_dt: self.predicted_dt,
+            modifiers: self.modifiers,
+            events: std::mem::take(&mut self.events),
+            hovered_files: self.hovered_files.clone(),
+            dropped_files: std::mem::take(&mut self.dropped_files),
+            has_focus: self.has_focus,
+        }
+    }
+
+    /// Add on new input.
+    pub fn append(&mut self, newer: Self) {
+        let Self {
+            screen_rect,
+            pixels_per_point,
+            max_texture_side,
+            time,
+            predicted_dt,
+            modifiers,
+            mut events,
+            mut hovered_files,
+            mut dropped_files,
+            has_focus,
+        } = newer;
+
+        self.screen_rect = screen_rect.or(self.screen_rect);
+        self.pixels_per_point = pixels_per_point.or(self.pixels_per_point);
+        self.max_texture_side = max_texture_side.or(self.max_texture_side);
+        self.time = time; // use latest time
+        self.predicted_dt = predicted_dt; // use latest dt
+        self.modifiers = modifiers; // use latest
+        self.events.append(&mut events);
+        self.hovered_files.append(&mut hovered_files);
+        self.dropped_files.append(&mut dropped_files);
+        self.has_focus = has_focus;
+    }
+}
+
+/// A file about to be dropped into egui.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct HoveredFile {
+    /// Set by the `egui-winit` backend.
+    pub path: Option<std::path::PathBuf>,
+
+    /// With the `eframe` web backend, this is set to the mime-type of the file (if available).
+    pub mime: String,
+}
+
+/// A file dropped into egui.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct DroppedFile {
+    /// Set by the `egui-winit` backend.
+    pub path: Option<std::path::PathBuf>,
+
+    /// Name of the file. Set by the `eframe` web backend.
+    pub name: String,
+
+    /// Set by the `eframe` web backend.
+    pub last_modified: Option<std::time::SystemTime>,
+
+    /// Set by the `eframe` web backend.
+    pub bytes: Option<std::sync::Arc<[u8]>>,
+}
+
+/// An input event generated by the integration.
+///
+/// This only covers events that egui cares about.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum Event {
+    /// The integration detected a "copy" event (e.g. Cmd+C).
+    Copy,
+
+    /// The integration detected a "cut" event (e.g. Cmd+X).
+    Cut,
+
+    /// The integration detected a "paste" event (e.g. Cmd+V).
+    Paste(String),
+
+    /// Text input, e.g. via keyboard.
+    ///
+    /// When the user presses enter/return, do not send a [`Text`](Event::Text) (just [`Key::Enter`]).
+    Text(String),
+
+    /// A key was pressed or released.
+    Key {
+        key: Key,
+
+        /// Was it pressed or released?
+        pressed: bool,
+
+        /// If this is a `pressed` event, is it a key-repeat?
+        ///
+        /// On many platforms, holding down a key produces many repeated "pressed" events for it, so called key-repeats.
+        /// Sometimes you will want to ignore such events, and this lets you do that.
+        ///
+        /// egui will automatically detect such repeat events and mark them as such here.
+        /// Therefore, if you are writing an egui integration, you do not need to set this (just set it to `false`).
+        repeat: bool,
+
+        /// The state of the modifier keys at the time of the event.
+        modifiers: Modifiers,
+    },
+
+    /// The mouse or touch moved to a new place.
+    PointerMoved(Pos2),
+
+    /// A mouse button was pressed or released (or a touch started or stopped).
+    PointerButton {
+        /// Where is the pointer?
+        pos: Pos2,
+
+        /// What mouse button? For touches, use [`PointerButton::Primary`].
+        button: PointerButton,
+
+        /// Was it the button/touch pressed this frame, or released?
+        pressed: bool,
+
+        /// The state of the modifier keys at the time of the event.
+        modifiers: Modifiers,
+    },
+
+    /// The mouse left the screen, or the last/primary touch input disappeared.
+    ///
+    /// This means there is no longer a cursor on the screen for hovering etc.
+    ///
+    /// On touch-up first send `PointerButton{pressed: false, …}` followed by `PointerLeft`.
+    PointerGone,
+
+    /// How many points (logical pixels) the user scrolled.
+    ///
+    /// The direction of the vector indicates how to move the _content_ that is being viewed.
+    /// So if you get positive values, the content being viewed should move to the right and down,
+    /// revealing new things to the left and up.
+    ///
+    /// A positive X-value indicates the content is being moved right,
+    /// as when swiping right on a touch-screen or track-pad with natural scrolling.
+    ///
+    /// A positive Y-value indicates the content is being moved down,
+    /// as when swiping down on a touch-screen or track-pad with natural scrolling.
+    ///
+    /// Shift-scroll should result in horizontal scrolling (it is up to the integrations to do this).
+    Scroll(Vec2),
+
+    /// Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
+    /// * `zoom = 1`: no change.
+    /// * `zoom < 1`: pinch together
+    /// * `zoom > 1`: pinch spread
+    Zoom(f32),
+
+    /// IME composition start.
+    CompositionStart,
+
+    /// A new IME candidate is being suggested.
+    CompositionUpdate(String),
+
+    /// IME composition ended with this final result.
+    CompositionEnd(String),
+
+    /// On touch screens, report this *in addition to*
+    /// [`Self::PointerMoved`], [`Self::PointerButton`], [`Self::PointerGone`]
+    Touch {
+        /// Hashed device identifier (if available; may be zero).
+        /// Can be used to separate touches from different devices.
+        device_id: TouchDeviceId,
+
+        /// Unique identifier of a finger/pen. Value is stable from touch down
+        /// to lift-up
+        id: TouchId,
+
+        /// One of: start move end cancel.
+        phase: TouchPhase,
+
+        /// Position of the touch (or where the touch was last detected)
+        pos: Pos2,
+
+        /// Describes how hard the touch device was pressed. May always be `0` if the platform does
+        /// not support pressure sensitivity.
+        /// The value is in the range from 0.0 (no pressure) to 1.0 (maximum pressure).
+        force: f32,
+    },
+
+    /// A raw mouse wheel event as sent by the backend (minus the z coordinate),
+    /// for implementing alternative custom controls.
+    /// Note that the same event can also trigger [`Self::Zoom`] and [`Self::Scroll`],
+    /// so you probably want to handle only one of them.
+    MouseWheel {
+        /// The unit of scrolling: points, lines, or pages.
+        unit: MouseWheelUnit,
+
+        /// The amount scrolled horizontally and vertically. The amount and direction corresponding
+        /// to one step of the wheel depends on the platform.
+        delta: Vec2,
+
+        /// The state of the modifier keys at the time of the event.
+        modifiers: Modifiers,
+    },
+
+    /// An assistive technology (e.g. screen reader) requested an action.
+    #[cfg(feature = "accesskit")]
+    AccessKitActionRequest(accesskit::ActionRequest),
+}
+
+/// Mouse button (or similar for touch input)
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum PointerButton {
+    /// The primary mouse button is usually the left one.
+    Primary = 0,
+
+    /// The secondary mouse button is usually the right one,
+    /// and most often used for context menus or other optional things.
+    Secondary = 1,
+
+    /// The tertiary mouse button is usually the middle mouse button (e.g. clicking the scroll wheel).
+    Middle = 2,
+
+    /// The first extra mouse button on some mice. In web typically corresponds to the Browser back button.
+    Extra1 = 3,
+
+    /// The second extra mouse button on some mice. In web typically corresponds to the Browser forward button.
+    Extra2 = 4,
+}
+
+/// Number of pointer buttons supported by egui, i.e. the number of possible states of [`PointerButton`].
+pub const NUM_POINTER_BUTTONS: usize = 5;
+
+/// State of the modifier keys. These must be fed to egui.
+///
+/// The best way to compare [`Modifiers`] is by using [`Modifiers::matches`].
+///
+/// NOTE: For cross-platform uses, ALT+SHIFT is a bad combination of modifiers
+/// as on mac that is how you type special characters,
+/// so those key presses are usually not reported to egui.
+#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Modifiers {
+    /// Either of the alt keys are down (option ⌥ on Mac).
+    pub alt: bool,
+
+    /// Either of the control keys are down.
+    /// When checking for keyboard shortcuts, consider using [`Self::command`] instead.
+    pub ctrl: bool,
+
+    /// Either of the shift keys are down.
+    pub shift: bool,
+
+    /// The Mac ⌘ Command key. Should always be set to `false` on other platforms.
+    pub mac_cmd: bool,
+
+    /// On Windows and Linux, set this to the same value as `ctrl`.
+    /// On Mac, this should be set whenever one of the ⌘ Command keys are down (same as `mac_cmd`).
+    /// This is so that egui can, for instance, select all text by checking for `command + A`
+    /// and it will work on both Mac and Windows.
+    pub command: bool,
+}
+
+impl Modifiers {
+    pub const NONE: Self = Self {
+        alt: false,
+        ctrl: false,
+        shift: false,
+        mac_cmd: false,
+        command: false,
+    };
+
+    pub const ALT: Self = Self {
+        alt: true,
+        ctrl: false,
+        shift: false,
+        mac_cmd: false,
+        command: false,
+    };
+    pub const CTRL: Self = Self {
+        alt: false,
+        ctrl: true,
+        shift: false,
+        mac_cmd: false,
+        command: false,
+    };
+    pub const SHIFT: Self = Self {
+        alt: false,
+        ctrl: false,
+        shift: true,
+        mac_cmd: false,
+        command: false,
+    };
+
+    #[deprecated = "Use `Modifiers::ALT | Modifiers::SHIFT` instead"]
+    pub const ALT_SHIFT: Self = Self {
+        alt: true,
+        ctrl: false,
+        shift: true,
+        mac_cmd: false,
+        command: false,
+    };
+
+    /// The Mac ⌘ Command key
+    pub const MAC_CMD: Self = Self {
+        alt: false,
+        ctrl: false,
+        shift: false,
+        mac_cmd: true,
+        command: false,
+    };
+
+    /// On Mac: ⌘ Command key, elsewhere: Ctrl key
+    pub const COMMAND: Self = Self {
+        alt: false,
+        ctrl: false,
+        shift: false,
+        mac_cmd: false,
+        command: true,
+    };
+
+    /// ```
+    /// # use egui::Modifiers;
+    /// assert_eq!(
+    ///     Modifiers::CTRL | Modifiers::ALT,
+    ///     Modifiers { ctrl: true, alt: true, ..Default::default() }
+    /// );
+    /// assert_eq!(
+    ///     Modifiers::ALT.plus(Modifiers::CTRL),
+    ///     Modifiers::CTRL.plus(Modifiers::ALT),
+    /// );
+    /// assert_eq!(
+    ///     Modifiers::CTRL | Modifiers::ALT,
+    ///     Modifiers::CTRL.plus(Modifiers::ALT),
+    /// );
+    /// ```
+    #[inline]
+    pub const fn plus(self, rhs: Self) -> Self {
+        Self {
+            alt: self.alt | rhs.alt,
+            ctrl: self.ctrl | rhs.ctrl,
+            shift: self.shift | rhs.shift,
+            mac_cmd: self.mac_cmd | rhs.mac_cmd,
+            command: self.command | rhs.command,
+        }
+    }
+
+    #[inline]
+    pub fn is_none(&self) -> bool {
+        self == &Self::default()
+    }
+
+    #[inline]
+    pub fn any(&self) -> bool {
+        !self.is_none()
+    }
+
+    /// Is shift the only pressed button?
+    #[inline]
+    pub fn shift_only(&self) -> bool {
+        self.shift && !(self.alt || self.command)
+    }
+
+    /// true if only [`Self::ctrl`] or only [`Self::mac_cmd`] is pressed.
+    #[inline]
+    pub fn command_only(&self) -> bool {
+        !self.alt && !self.shift && self.command
+    }
+
+    /// Check for equality but with proper handling of [`Self::command`].
+    ///
+    /// ```
+    /// # use egui::Modifiers;
+    /// assert!(Modifiers::CTRL.matches(Modifiers::CTRL));
+    /// assert!(!Modifiers::CTRL.matches(Modifiers::CTRL | Modifiers::SHIFT));
+    /// assert!(!(Modifiers::CTRL | Modifiers::SHIFT).matches(Modifiers::CTRL));
+    /// assert!((Modifiers::CTRL | Modifiers::COMMAND).matches(Modifiers::CTRL));
+    /// assert!((Modifiers::CTRL | Modifiers::COMMAND).matches(Modifiers::COMMAND));
+    /// assert!((Modifiers::MAC_CMD | Modifiers::COMMAND).matches(Modifiers::COMMAND));
+    /// assert!(!Modifiers::COMMAND.matches(Modifiers::MAC_CMD));
+    /// ```
+    pub fn matches(&self, pattern: Modifiers) -> bool {
+        // alt and shift must always match the pattern:
+        if pattern.alt != self.alt || pattern.shift != self.shift {
+            return false;
+        }
+
+        if pattern.mac_cmd {
+            // Mac-specific match:
+            if !self.mac_cmd {
+                return false;
+            }
+            if pattern.ctrl != self.ctrl {
+                return false;
+            }
+            return true;
+        }
+
+        if !pattern.ctrl && !pattern.command {
+            // the pattern explicitly doesn't want any ctrl/command:
+            return !self.ctrl && !self.command;
+        }
+
+        // if the pattern is looking for command, then `ctrl` may or may not be set depending on platform.
+        // if the pattern is looking for `ctrl`, then `command` may or may not be set depending on platform.
+
+        if pattern.ctrl && !self.ctrl {
+            return false;
+        }
+        if pattern.command && !self.command {
+            return false;
+        }
+
+        true
+    }
+}
+
+impl std::ops::BitOr for Modifiers {
+    type Output = Self;
+
+    #[inline]
+    fn bitor(self, rhs: Self) -> Self {
+        self.plus(rhs)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Names of different modifier keys.
+///
+/// Used to name modifiers.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ModifierNames<'a> {
+    pub is_short: bool,
+
+    pub alt: &'a str,
+    pub ctrl: &'a str,
+    pub shift: &'a str,
+    pub mac_cmd: &'a str,
+
+    /// What goes between the names
+    pub concat: &'a str,
+}
+
+impl ModifierNames<'static> {
+    /// ⌥ ^ ⇧ ⌘ - NOTE: not supported by the default egui font.
+    pub const SYMBOLS: Self = Self {
+        is_short: true,
+        alt: "⌥",
+        ctrl: "^",
+        shift: "⇧",
+        mac_cmd: "⌘",
+        concat: "",
+    };
+
+    /// Alt, Ctrl, Shift, Cmd
+    pub const NAMES: Self = Self {
+        is_short: false,
+        alt: "Alt",
+        ctrl: "Ctrl",
+        shift: "Shift",
+        mac_cmd: "Cmd",
+        concat: "+",
+    };
+}
+
+impl<'a> ModifierNames<'a> {
+    pub fn format(&self, modifiers: &Modifiers, is_mac: bool) -> String {
+        let mut s = String::new();
+
+        let mut append_if = |modifier_is_active, modifier_name| {
+            if modifier_is_active {
+                if !s.is_empty() {
+                    s += self.concat;
+                }
+                s += modifier_name;
+            }
+        };
+
+        if is_mac {
+            append_if(modifiers.ctrl, self.ctrl);
+            append_if(modifiers.shift, self.shift);
+            append_if(modifiers.alt, self.alt);
+            append_if(modifiers.mac_cmd || modifiers.command, self.mac_cmd);
+        } else {
+            append_if(modifiers.ctrl || modifiers.command, self.ctrl);
+            append_if(modifiers.alt, self.alt);
+            append_if(modifiers.shift, self.shift);
+        }
+
+        s
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Keyboard keys.
+///
+/// Includes all keys egui is interested in (such as `Home` and `End`)
+/// plus a few that are useful for detecting keyboard shortcuts.
+///
+/// Many keys are omitted because they are not always physical keys (depending on keyboard language), e.g. `;` and `§`,
+/// and are therefore unsuitable as keyboard shortcuts if you want your app to be portable.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum Key {
+    ArrowDown,
+    ArrowLeft,
+    ArrowRight,
+    ArrowUp,
+
+    Escape,
+    Tab,
+    Backspace,
+    Enter,
+    Space,
+
+    Insert,
+    Delete,
+    Home,
+    End,
+    PageUp,
+    PageDown,
+
+    /// The virtual keycode for the Minus key.
+    Minus,
+    /// The virtual keycode for the Plus/Equals key.
+    PlusEquals,
+
+    /// Either from the main row or from the numpad.
+    Num0,
+    /// Either from the main row or from the numpad.
+    Num1,
+    /// Either from the main row or from the numpad.
+    Num2,
+    /// Either from the main row or from the numpad.
+    Num3,
+    /// Either from the main row or from the numpad.
+    Num4,
+    /// Either from the main row or from the numpad.
+    Num5,
+    /// Either from the main row or from the numpad.
+    Num6,
+    /// Either from the main row or from the numpad.
+    Num7,
+    /// Either from the main row or from the numpad.
+    Num8,
+    /// Either from the main row or from the numpad.
+    Num9,
+
+    A, // Used for cmd+A (select All)
+    B,
+    C, // |CMD COPY|
+    D, // |CMD BOOKMARK|
+    E, // |CMD SEARCH|
+    F, // |CMD FIND firefox & chrome|
+    G, // |CMD FIND chrome|
+    H, // |CMD History|
+    I, // italics
+    J, // |CMD SEARCH firefox/DOWNLOAD chrome|
+    K, // Used for ctrl+K (delete text after cursor)
+    L,
+    M,
+    N,
+    O, // |CMD OPEN|
+    P, // |CMD PRINT|
+    Q,
+    R, // |CMD REFRESH|
+    S, // |CMD SAVE|
+    T, // |CMD TAB|
+    U, // Used for ctrl+U (delete text before cursor)
+    V, // |CMD PASTE|
+    W, // Used for ctrl+W (delete previous word)
+    X, // |CMD CUT|
+    Y,
+    Z, // |CMD UNDO|
+
+    // The function keys:
+    F1,
+    F2,
+    F3,
+    F4,
+    F5, // |CMD REFRESH|
+    F6,
+    F7,
+    F8,
+    F9,
+    F10,
+    F11,
+    F12,
+    F13,
+    F14,
+    F15,
+    F16,
+    F17,
+    F18,
+    F19,
+    F20,
+}
+
+impl Key {
+    /// Emoji or name representing the key
+    pub fn symbol_or_name(self) -> &'static str {
+        // TODO(emilk): add support for more unicode symbols (see for instance https://wincent.com/wiki/Unicode_representations_of_modifier_keys).
+        // Before we do we must first make sure they are supported in `Fonts` though,
+        // so perhaps this functions needs to take a `supports_character: impl Fn(char) -> bool` or something.
+        match self {
+            Key::ArrowDown => "⏷",
+            Key::ArrowLeft => "⏴",
+            Key::ArrowRight => "⏵",
+            Key::ArrowUp => "⏶",
+            Key::Minus => "-",
+            Key::PlusEquals => "+",
+            _ => self.name(),
+        }
+    }
+
+    /// Human-readable English name.
+    pub fn name(self) -> &'static str {
+        match self {
+            Key::ArrowDown => "Down",
+            Key::ArrowLeft => "Left",
+            Key::ArrowRight => "Right",
+            Key::ArrowUp => "Up",
+            Key::Escape => "Escape",
+            Key::Tab => "Tab",
+            Key::Backspace => "Backspace",
+            Key::Enter => "Enter",
+            Key::Space => "Space",
+            Key::Insert => "Insert",
+            Key::Delete => "Delete",
+            Key::Home => "Home",
+            Key::End => "End",
+            Key::PageUp => "PageUp",
+            Key::PageDown => "PageDown",
+            Key::Minus => "Minus",
+            Key::PlusEquals => "Plus",
+            Key::Num0 => "0",
+            Key::Num1 => "1",
+            Key::Num2 => "2",
+            Key::Num3 => "3",
+            Key::Num4 => "4",
+            Key::Num5 => "5",
+            Key::Num6 => "6",
+            Key::Num7 => "7",
+            Key::Num8 => "8",
+            Key::Num9 => "9",
+            Key::A => "A",
+            Key::B => "B",
+            Key::C => "C",
+            Key::D => "D",
+            Key::E => "E",
+            Key::F => "F",
+            Key::G => "G",
+            Key::H => "H",
+            Key::I => "I",
+            Key::J => "J",
+            Key::K => "K",
+            Key::L => "L",
+            Key::M => "M",
+            Key::N => "N",
+            Key::O => "O",
+            Key::P => "P",
+            Key::Q => "Q",
+            Key::R => "R",
+            Key::S => "S",
+            Key::T => "T",
+            Key::U => "U",
+            Key::V => "V",
+            Key::W => "W",
+            Key::X => "X",
+            Key::Y => "Y",
+            Key::Z => "Z",
+            Key::F1 => "F1",
+            Key::F2 => "F2",
+            Key::F3 => "F3",
+            Key::F4 => "F4",
+            Key::F5 => "F5",
+            Key::F6 => "F6",
+            Key::F7 => "F7",
+            Key::F8 => "F8",
+            Key::F9 => "F9",
+            Key::F10 => "F10",
+            Key::F11 => "F11",
+            Key::F12 => "F12",
+            Key::F13 => "F13",
+            Key::F14 => "F14",
+            Key::F15 => "F15",
+            Key::F16 => "F16",
+            Key::F17 => "F17",
+            Key::F18 => "F18",
+            Key::F19 => "F19",
+            Key::F20 => "F20",
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A keyboard shortcut, e.g. `Ctrl+Alt+W`.
+///
+/// Can be used with [`crate::InputState::consume_shortcut`]
+/// and [`crate::Context::format_shortcut`].
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+pub struct KeyboardShortcut {
+    pub modifiers: Modifiers,
+    pub key: Key,
+}
+
+impl KeyboardShortcut {
+    pub const fn new(modifiers: Modifiers, key: Key) -> Self {
+        Self { modifiers, key }
+    }
+
+    pub fn format(&self, names: &ModifierNames<'_>, is_mac: bool) -> String {
+        let mut s = names.format(&self.modifiers, is_mac);
+        if !s.is_empty() {
+            s += names.concat;
+        }
+        if names.is_short {
+            s += self.key.symbol_or_name();
+        } else {
+            s += self.key.name();
+        }
+        s
+    }
+}
+
+#[test]
+fn format_kb_shortcut() {
+    let cmd_shift_f = KeyboardShortcut::new(Modifiers::COMMAND | Modifiers::SHIFT, Key::F);
+    assert_eq!(
+        cmd_shift_f.format(&ModifierNames::NAMES, false),
+        "Ctrl+Shift+F"
+    );
+    assert_eq!(
+        cmd_shift_f.format(&ModifierNames::NAMES, true),
+        "Shift+Cmd+F"
+    );
+    assert_eq!(cmd_shift_f.format(&ModifierNames::SYMBOLS, false), "^⇧F");
+    assert_eq!(cmd_shift_f.format(&ModifierNames::SYMBOLS, true), "⇧⌘F");
+}
+
+// ----------------------------------------------------------------------------
+
+impl RawInput {
+    pub fn ui(&self, ui: &mut crate::Ui) {
+        let Self {
+            screen_rect,
+            pixels_per_point,
+            max_texture_side,
+            time,
+            predicted_dt,
+            modifiers,
+            events,
+            hovered_files,
+            dropped_files,
+            has_focus,
+        } = self;
+
+        ui.label(format!("screen_rect: {:?} points", screen_rect));
+        ui.label(format!("pixels_per_point: {:?}", pixels_per_point))
+            .on_hover_text(
+                "Also called HDPI factor.\nNumber of physical pixels per each logical pixel.",
+            );
+        ui.label(format!("max_texture_side: {:?}", max_texture_side));
+        if let Some(time) = time {
+            ui.label(format!("time: {:.3} s", time));
+        } else {
+            ui.label("time: None");
+        }
+        ui.label(format!("predicted_dt: {:.1} ms", 1e3 * predicted_dt));
+        ui.label(format!("modifiers: {:#?}", modifiers));
+        ui.label(format!("hovered_files: {}", hovered_files.len()));
+        ui.label(format!("dropped_files: {}", dropped_files.len()));
+        ui.label(format!("has_focus: {}", has_focus));
+        ui.scope(|ui| {
+            ui.set_min_height(150.0);
+            ui.label(format!("events: {:#?}", events))
+                .on_hover_text("key presses etc");
+        });
+    }
+}
+
+/// this is a `u64` as values of this kind can always be obtained by hashing
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TouchDeviceId(pub u64);
+
+/// Unique identification of a touch occurrence (finger or pen or …).
+/// A Touch ID is valid until the finger is lifted.
+/// A new ID is used for the next touch.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TouchId(pub u64);
+
+/// In what phase a touch event is in.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum TouchPhase {
+    /// User just placed a touch point on the touch surface
+    Start,
+
+    /// User moves a touch point along the surface. This event is also sent when
+    /// any attributes (position, force, …) of the touch point change.
+    Move,
+
+    /// User lifted the finger or pen from the surface, or slid off the edge of
+    /// the surface
+    End,
+
+    /// Touch operation has been disrupted by something (various reasons are possible,
+    /// maybe a pop-up alert or any other kind of interruption which may not have
+    /// been intended by the user)
+    Cancel,
+}
+
+/// The unit associated with the numeric value of a mouse wheel event
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum MouseWheelUnit {
+    /// Number of ui points (logical pixels)
+    Point,
+
+    /// Number of lines
+    Line,
+
+    /// Number of pages
+    Page,
+}
+
+impl From<u64> for TouchId {
+    fn from(id: u64) -> Self {
+        Self(id)
+    }
+}
+
+impl From<i32> for TouchId {
+    fn from(id: i32) -> Self {
+        Self(id as u64)
+    }
+}
+
+impl From<u32> for TouchId {
+    fn from(id: u32) -> Self {
+        Self(id as u64)
+    }
+}
diff --git a/egui/crates/egui/src/data/mod.rs b/egui/crates/egui/src/data/mod.rs
new file mode 100644
index 0000000..5a4b3f1
--- /dev/null
+++ b/egui/crates/egui/src/data/mod.rs
@@ -0,0 +1,4 @@
+//! All the data sent between egui and the backend
+
+pub mod input;
+pub mod output;
diff --git a/egui/crates/egui/src/data/output.rs b/egui/crates/egui/src/data/output.rs
new file mode 100644
index 0000000..b0bfa9e
--- /dev/null
+++ b/egui/crates/egui/src/data/output.rs
@@ -0,0 +1,629 @@
+//! All the data egui returns to the backend at the end of each frame.
+
+use crate::WidgetType;
+
+/// What egui emits each frame from [`crate::Context::run`].
+///
+/// The backend should use this.
+#[derive(Clone, Default, PartialEq)]
+pub struct FullOutput {
+    /// Non-rendering related output.
+    pub platform_output: PlatformOutput,
+
+    /// If `Duration::is_zero()`, egui is requesting immediate repaint (i.e. on the next frame).
+    ///
+    /// This happens for instance when there is an animation, or if a user has called `Context::request_repaint()`.
+    ///
+    /// If `Duration` is greater than zero, egui wants to be repainted at or before the specified
+    /// duration elapses. when in reactive mode, egui spends forever waiting for input and only then,
+    /// will it repaint itself. this can be used to make sure that backend will only wait for a
+    /// specified amount of time, and repaint egui without any new input.
+    pub repaint_after: std::time::Duration,
+
+    /// Texture changes since last frame (including the font texture).
+    ///
+    /// The backend needs to apply [`crate::TexturesDelta::set`] _before_ painting,
+    /// and free any texture in [`crate::TexturesDelta::free`] _after_ painting.
+    pub textures_delta: epaint::textures::TexturesDelta,
+
+    /// What to paint.
+    ///
+    /// You can use [`crate::Context::tessellate`] to turn this into triangles.
+    pub shapes: Vec<epaint::ClippedShape>,
+}
+
+impl FullOutput {
+    /// Add on new output.
+    pub fn append(&mut self, newer: Self) {
+        let Self {
+            platform_output,
+            repaint_after,
+            textures_delta,
+            shapes,
+        } = newer;
+
+        self.platform_output.append(platform_output);
+        self.repaint_after = repaint_after; // if the last frame doesn't need a repaint, then we don't need to repaint
+        self.textures_delta.append(textures_delta);
+        self.shapes = shapes; // Only paint the latest
+    }
+}
+
+/// The non-rendering part of what egui emits each frame.
+///
+/// You can access (and modify) this with [`crate::Context::output`].
+///
+/// The backend should use this.
+#[derive(Default, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PlatformOutput {
+    /// Set the cursor to this icon.
+    pub cursor_icon: CursorIcon,
+
+    /// If set, open this url.
+    pub open_url: Option<OpenUrl>,
+
+    /// If set, put this text in the system clipboard. Ignore if empty.
+    ///
+    /// This is often a response to [`crate::Event::Copy`] or [`crate::Event::Cut`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// if ui.button("📋").clicked() {
+    ///     ui.output_mut(|o| o.copied_text = "some_text".to_string());
+    /// }
+    /// # });
+    /// ```
+    pub copied_text: String,
+
+    /// Events that may be useful to e.g. a screen reader.
+    pub events: Vec<OutputEvent>,
+
+    /// Is there a mutable [`TextEdit`](crate::TextEdit) under the cursor?
+    /// Use by `eframe` web to show/hide mobile keyboard and IME agent.
+    pub mutable_text_under_cursor: bool,
+
+    /// Screen-space position of text edit cursor (used for IME).
+    pub text_cursor_pos: Option<crate::Pos2>,
+
+    #[cfg(feature = "accesskit")]
+    pub accesskit_update: Option<accesskit::TreeUpdate>,
+}
+
+impl PlatformOutput {
+    /// Open the given url in a web browser.
+    /// If egui is running in a browser, the same tab will be reused.
+    pub fn open_url(&mut self, url: impl ToString) {
+        self.open_url = Some(OpenUrl::same_tab(url));
+    }
+
+    /// This can be used by a text-to-speech system to describe the events (if any).
+    pub fn events_description(&self) -> String {
+        // only describe last event:
+        if let Some(event) = self.events.iter().rev().next() {
+            match event {
+                OutputEvent::Clicked(widget_info)
+                | OutputEvent::DoubleClicked(widget_info)
+                | OutputEvent::TripleClicked(widget_info)
+                | OutputEvent::FocusGained(widget_info)
+                | OutputEvent::TextSelectionChanged(widget_info)
+                | OutputEvent::ValueChanged(widget_info) => {
+                    return widget_info.description();
+                }
+            }
+        }
+        Default::default()
+    }
+
+    /// Add on new output.
+    pub fn append(&mut self, newer: Self) {
+        let Self {
+            cursor_icon,
+            open_url,
+            copied_text,
+            mut events,
+            mutable_text_under_cursor,
+            text_cursor_pos,
+            #[cfg(feature = "accesskit")]
+            accesskit_update,
+        } = newer;
+
+        self.cursor_icon = cursor_icon;
+        if open_url.is_some() {
+            self.open_url = open_url;
+        }
+        if !copied_text.is_empty() {
+            self.copied_text = copied_text;
+        }
+        self.events.append(&mut events);
+        self.mutable_text_under_cursor = mutable_text_under_cursor;
+        self.text_cursor_pos = text_cursor_pos.or(self.text_cursor_pos);
+
+        #[cfg(feature = "accesskit")]
+        {
+            // egui produces a complete AccessKit tree for each frame,
+            // so overwrite rather than appending.
+            self.accesskit_update = accesskit_update;
+        }
+    }
+
+    /// Take everything ephemeral (everything except `cursor_icon` currently)
+    pub fn take(&mut self) -> Self {
+        let taken = std::mem::take(self);
+        self.cursor_icon = taken.cursor_icon; // everything else is ephemeral
+        taken
+    }
+}
+
+/// What URL to open, and how.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct OpenUrl {
+    pub url: String,
+
+    /// If `true`, open the url in a new tab.
+    /// If `false` open it in the same tab.
+    /// Only matters when in a web browser.
+    pub new_tab: bool,
+}
+
+impl OpenUrl {
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn same_tab(url: impl ToString) -> Self {
+        Self {
+            url: url.to_string(),
+            new_tab: false,
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn new_tab(url: impl ToString) -> Self {
+        Self {
+            url: url.to_string(),
+            new_tab: true,
+        }
+    }
+}
+
+/// A mouse cursor icon.
+///
+/// egui emits a [`CursorIcon`] in [`PlatformOutput`] each frame as a request to the integration.
+///
+/// Loosely based on <https://developer.mozilla.org/en-US/docs/Web/CSS/cursor>.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum CursorIcon {
+    /// Normal cursor icon, whatever that is.
+    Default,
+
+    /// Show no cursor
+    None,
+
+    // ------------------------------------
+    // Links and status:
+    /// A context menu is available
+    ContextMenu,
+
+    /// Question mark
+    Help,
+
+    /// Pointing hand, used for e.g. web links
+    PointingHand,
+
+    /// Shows that processing is being done, but that the program is still interactive.
+    Progress,
+
+    /// Not yet ready, try later.
+    Wait,
+
+    // ------------------------------------
+    // Selection:
+    /// Hover a cell in a table
+    Cell,
+
+    /// For precision work
+    Crosshair,
+
+    /// Text caret, e.g. "Click here to edit text"
+    Text,
+
+    /// Vertical text caret, e.g. "Click here to edit vertical text"
+    VerticalText,
+
+    // ------------------------------------
+    // Drag-and-drop:
+    /// Indicated an alias, e.g. a shortcut
+    Alias,
+
+    /// Indicate that a copy will be made
+    Copy,
+
+    /// Omnidirectional move icon (e.g. arrows in all cardinal directions)
+    Move,
+
+    /// Can't drop here
+    NoDrop,
+
+    /// Forbidden
+    NotAllowed,
+
+    /// The thing you are hovering can be grabbed
+    Grab,
+
+    /// You are grabbing the thing you are hovering
+    Grabbing,
+
+    // ------------------------------------
+    /// Something can be scrolled in any direction (panned).
+    AllScroll,
+
+    // ------------------------------------
+    // Resizing in two directions:
+    /// Horizontal resize `-` to make something wider or more narrow (left to/from right)
+    ResizeHorizontal,
+
+    /// Diagonal resize `/` (right-up to/from left-down)
+    ResizeNeSw,
+
+    /// Diagonal resize `\` (left-up to/from right-down)
+    ResizeNwSe,
+
+    /// Vertical resize `|` (up-down or down-up)
+    ResizeVertical,
+
+    // ------------------------------------
+    // Resizing in one direction:
+    /// Resize something rightwards (e.g. when dragging the right-most edge of something)
+    ResizeEast,
+
+    /// Resize something down and right (e.g. when dragging the bottom-right corner of something)
+    ResizeSouthEast,
+
+    /// Resize something downwards (e.g. when dragging the bottom edge of something)
+    ResizeSouth,
+
+    /// Resize something down and left (e.g. when dragging the bottom-left corner of something)
+    ResizeSouthWest,
+
+    /// Resize something leftwards (e.g. when dragging the left edge of something)
+    ResizeWest,
+
+    /// Resize something up and left (e.g. when dragging the top-left corner of something)
+    ResizeNorthWest,
+
+    /// Resize something up (e.g. when dragging the top edge of something)
+    ResizeNorth,
+
+    /// Resize something up and right (e.g. when dragging the top-right corner of something)
+    ResizeNorthEast,
+
+    // ------------------------------------
+    /// Resize a column
+    ResizeColumn,
+
+    /// Resize a row
+    ResizeRow,
+
+    // ------------------------------------
+    // Zooming:
+    /// Enhance!
+    ZoomIn,
+
+    /// Let's get a better overview
+    ZoomOut,
+}
+
+impl CursorIcon {
+    pub const ALL: [CursorIcon; 35] = [
+        CursorIcon::Default,
+        CursorIcon::None,
+        CursorIcon::ContextMenu,
+        CursorIcon::Help,
+        CursorIcon::PointingHand,
+        CursorIcon::Progress,
+        CursorIcon::Wait,
+        CursorIcon::Cell,
+        CursorIcon::Crosshair,
+        CursorIcon::Text,
+        CursorIcon::VerticalText,
+        CursorIcon::Alias,
+        CursorIcon::Copy,
+        CursorIcon::Move,
+        CursorIcon::NoDrop,
+        CursorIcon::NotAllowed,
+        CursorIcon::Grab,
+        CursorIcon::Grabbing,
+        CursorIcon::AllScroll,
+        CursorIcon::ResizeHorizontal,
+        CursorIcon::ResizeNeSw,
+        CursorIcon::ResizeNwSe,
+        CursorIcon::ResizeVertical,
+        CursorIcon::ResizeEast,
+        CursorIcon::ResizeSouthEast,
+        CursorIcon::ResizeSouth,
+        CursorIcon::ResizeSouthWest,
+        CursorIcon::ResizeWest,
+        CursorIcon::ResizeNorthWest,
+        CursorIcon::ResizeNorth,
+        CursorIcon::ResizeNorthEast,
+        CursorIcon::ResizeColumn,
+        CursorIcon::ResizeRow,
+        CursorIcon::ZoomIn,
+        CursorIcon::ZoomOut,
+    ];
+}
+
+impl Default for CursorIcon {
+    fn default() -> Self {
+        Self::Default
+    }
+}
+
+/// Things that happened during this frame that the integration may be interested in.
+///
+/// In particular, these events may be useful for accessability, i.e. for screen readers.
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum OutputEvent {
+    /// A widget was clicked.
+    Clicked(WidgetInfo),
+
+    /// A widget was double-clicked.
+    DoubleClicked(WidgetInfo),
+
+    /// A widget was triple-clicked.
+    TripleClicked(WidgetInfo),
+
+    /// A widget gained keyboard focus (by tab key).
+    FocusGained(WidgetInfo),
+
+    /// Text selection was updated.
+    TextSelectionChanged(WidgetInfo),
+
+    /// A widget's value changed.
+    ValueChanged(WidgetInfo),
+}
+
+impl OutputEvent {
+    pub fn widget_info(&self) -> &WidgetInfo {
+        match self {
+            OutputEvent::Clicked(info)
+            | OutputEvent::DoubleClicked(info)
+            | OutputEvent::TripleClicked(info)
+            | OutputEvent::FocusGained(info)
+            | OutputEvent::TextSelectionChanged(info)
+            | OutputEvent::ValueChanged(info) => info,
+        }
+    }
+}
+
+impl std::fmt::Debug for OutputEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Clicked(wi) => write!(f, "Clicked({:?})", wi),
+            Self::DoubleClicked(wi) => write!(f, "DoubleClicked({:?})", wi),
+            Self::TripleClicked(wi) => write!(f, "TripleClicked({:?})", wi),
+            Self::FocusGained(wi) => write!(f, "FocusGained({:?})", wi),
+            Self::TextSelectionChanged(wi) => write!(f, "TextSelectionChanged({:?})", wi),
+            Self::ValueChanged(wi) => write!(f, "ValueChanged({:?})", wi),
+        }
+    }
+}
+
+/// Describes a widget such as a [`crate::Button`] or a [`crate::TextEdit`].
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WidgetInfo {
+    /// The type of widget this is.
+    pub typ: WidgetType,
+
+    /// Whether the widget is enabled.
+    pub enabled: bool,
+
+    /// The text on labels, buttons, checkboxes etc.
+    pub label: Option<String>,
+
+    /// The contents of some editable text (for [`TextEdit`](crate::TextEdit) fields).
+    pub current_text_value: Option<String>,
+
+    /// The previous text value.
+    pub prev_text_value: Option<String>,
+
+    /// The current value of checkboxes and radio buttons.
+    pub selected: Option<bool>,
+
+    /// The current value of sliders etc.
+    pub value: Option<f64>,
+
+    /// Selected range of characters in [`Self::current_text_value`].
+    pub text_selection: Option<std::ops::RangeInclusive<usize>>,
+}
+
+impl std::fmt::Debug for WidgetInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self {
+            typ,
+            enabled,
+            label,
+            current_text_value: text_value,
+            prev_text_value,
+            selected,
+            value,
+            text_selection,
+        } = self;
+
+        let mut s = f.debug_struct("WidgetInfo");
+
+        s.field("typ", typ);
+        s.field("enabled", enabled);
+
+        if let Some(label) = label {
+            s.field("label", label);
+        }
+        if let Some(text_value) = text_value {
+            s.field("text_value", text_value);
+        }
+        if let Some(prev_text_value) = prev_text_value {
+            s.field("prev_text_value", prev_text_value);
+        }
+        if let Some(selected) = selected {
+            s.field("selected", selected);
+        }
+        if let Some(value) = value {
+            s.field("value", value);
+        }
+        if let Some(text_selection) = text_selection {
+            s.field("text_selection", text_selection);
+        }
+
+        s.finish()
+    }
+}
+
+impl WidgetInfo {
+    pub fn new(typ: WidgetType) -> Self {
+        Self {
+            typ,
+            enabled: true,
+            label: None,
+            current_text_value: None,
+            prev_text_value: None,
+            selected: None,
+            value: None,
+            text_selection: None,
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn labeled(typ: WidgetType, label: impl ToString) -> Self {
+        Self {
+            label: Some(label.to_string()),
+            ..Self::new(typ)
+        }
+    }
+
+    /// checkboxes, radio-buttons etc
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn selected(typ: WidgetType, selected: bool, label: impl ToString) -> Self {
+        Self {
+            label: Some(label.to_string()),
+            selected: Some(selected),
+            ..Self::new(typ)
+        }
+    }
+
+    pub fn drag_value(value: f64) -> Self {
+        Self {
+            value: Some(value),
+            ..Self::new(WidgetType::DragValue)
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn slider(value: f64, label: impl ToString) -> Self {
+        let label = label.to_string();
+        Self {
+            label: if label.is_empty() { None } else { Some(label) },
+            value: Some(value),
+            ..Self::new(WidgetType::Slider)
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn text_edit(prev_text_value: impl ToString, text_value: impl ToString) -> Self {
+        let text_value = text_value.to_string();
+        let prev_text_value = prev_text_value.to_string();
+        let prev_text_value = if text_value == prev_text_value {
+            None
+        } else {
+            Some(prev_text_value)
+        };
+        Self {
+            current_text_value: Some(text_value),
+            prev_text_value,
+            ..Self::new(WidgetType::TextEdit)
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn text_selection_changed(
+        text_selection: std::ops::RangeInclusive<usize>,
+        current_text_value: impl ToString,
+    ) -> Self {
+        Self {
+            text_selection: Some(text_selection),
+            current_text_value: Some(current_text_value.to_string()),
+            ..Self::new(WidgetType::TextEdit)
+        }
+    }
+
+    /// This can be used by a text-to-speech system to describe the widget.
+    pub fn description(&self) -> String {
+        let Self {
+            typ,
+            enabled,
+            label,
+            current_text_value: text_value,
+            prev_text_value: _,
+            selected,
+            value,
+            text_selection: _,
+        } = self;
+
+        // TODO(emilk): localization
+        let widget_type = match typ {
+            WidgetType::Link => "link",
+            WidgetType::TextEdit => "text edit",
+            WidgetType::Button => "button",
+            WidgetType::Checkbox => "checkbox",
+            WidgetType::RadioButton => "radio",
+            WidgetType::SelectableLabel => "selectable",
+            WidgetType::ComboBox => "combo",
+            WidgetType::Slider => "slider",
+            WidgetType::DragValue => "drag value",
+            WidgetType::ColorButton => "color button",
+            WidgetType::ImageButton => "image button",
+            WidgetType::CollapsingHeader => "collapsing header",
+            WidgetType::Label | WidgetType::Other => "",
+        };
+
+        let mut description = widget_type.to_owned();
+
+        if let Some(selected) = selected {
+            if *typ == WidgetType::Checkbox {
+                let state = if *selected { "checked" } else { "unchecked" };
+                description = format!("{} {}", state, description);
+            } else {
+                description += if *selected { "selected" } else { "" };
+            };
+        }
+
+        if let Some(label) = label {
+            description = format!("{}: {}", label, description);
+        }
+
+        if typ == &WidgetType::TextEdit {
+            let text;
+            if let Some(text_value) = text_value {
+                if text_value.is_empty() {
+                    text = "blank".into();
+                } else {
+                    text = text_value.to_string();
+                }
+            } else {
+                text = "blank".into();
+            }
+            description = format!("{}: {}", text, description);
+        }
+
+        if let Some(value) = value {
+            description += " ";
+            description += &value.to_string();
+        }
+
+        if !enabled {
+            description += ": disabled";
+        }
+        description.trim().to_owned()
+    }
+}
diff --git a/egui/crates/egui/src/frame_state.rs b/egui/crates/egui/src/frame_state.rs
new file mode 100644
index 0000000..be61dbe
--- /dev/null
+++ b/egui/crates/egui/src/frame_state.rs
@@ -0,0 +1,173 @@
+use std::ops::RangeInclusive;
+
+use crate::{id::IdSet, *};
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct TooltipFrameState {
+    pub common_id: Id,
+    pub rect: Rect,
+    pub count: usize,
+}
+
+#[cfg(feature = "accesskit")]
+#[derive(Clone)]
+pub(crate) struct AccessKitFrameState {
+    pub(crate) node_builders: IdMap<accesskit::NodeBuilder>,
+    pub(crate) parent_stack: Vec<Id>,
+}
+
+/// State that is collected during a frame and then cleared.
+/// Short-term (single frame) memory.
+#[derive(Clone)]
+pub(crate) struct FrameState {
+    /// All [`Id`]s that were used this frame.
+    /// Used to debug [`Id`] clashes of widgets.
+    pub(crate) used_ids: IdMap<Rect>,
+
+    /// Starts off as the screen_rect, shrinks as panels are added.
+    /// The [`CentralPanel`] does not change this.
+    /// This is the area available to Window's.
+    pub(crate) available_rect: Rect,
+
+    /// Starts off as the screen_rect, shrinks as panels are added.
+    /// The [`CentralPanel`] retracts from this.
+    pub(crate) unused_rect: Rect,
+
+    /// How much space is used by panels.
+    pub(crate) used_by_panels: Rect,
+
+    /// If a tooltip has been shown this frame, where was it?
+    /// This is used to prevent multiple tooltips to cover each other.
+    /// Initialized to `None` at the start of each frame.
+    pub(crate) tooltip_state: Option<TooltipFrameState>,
+
+    /// Set to [`InputState::scroll_delta`] on the start of each frame.
+    ///
+    /// Cleared by the first [`ScrollArea`] that makes use of it.
+    pub(crate) scroll_delta: Vec2, // TODO(emilk): move to `InputState` ?
+
+    /// horizontal, vertical
+    pub(crate) scroll_target: [Option<(RangeInclusive<f32>, Option<Align>)>; 2],
+
+    #[cfg(feature = "accesskit")]
+    pub(crate) accesskit_state: Option<AccessKitFrameState>,
+
+    /// Highlight these widgets this next frame. Read from this.
+    pub(crate) highlight_this_frame: IdSet,
+
+    /// Highlight these widgets the next frame. Write to this.
+    pub(crate) highlight_next_frame: IdSet,
+}
+
+impl Default for FrameState {
+    fn default() -> Self {
+        Self {
+            used_ids: Default::default(),
+            available_rect: Rect::NAN,
+            unused_rect: Rect::NAN,
+            used_by_panels: Rect::NAN,
+            tooltip_state: None,
+            scroll_delta: Vec2::ZERO,
+            scroll_target: [None, None],
+            #[cfg(feature = "accesskit")]
+            accesskit_state: None,
+            highlight_this_frame: Default::default(),
+            highlight_next_frame: Default::default(),
+        }
+    }
+}
+
+impl FrameState {
+    pub(crate) fn begin_frame(&mut self, input: &InputState) {
+        let Self {
+            used_ids,
+            available_rect,
+            unused_rect,
+            used_by_panels,
+            tooltip_state,
+            scroll_delta,
+            scroll_target,
+            #[cfg(feature = "accesskit")]
+            accesskit_state,
+            highlight_this_frame,
+            highlight_next_frame,
+        } = self;
+
+        used_ids.clear();
+        *available_rect = input.screen_rect();
+        *unused_rect = input.screen_rect();
+        *used_by_panels = Rect::NOTHING;
+        *tooltip_state = None;
+        *scroll_delta = input.scroll_delta;
+        *scroll_target = [None, None];
+
+        #[cfg(feature = "accesskit")]
+        {
+            *accesskit_state = None;
+        }
+
+        *highlight_this_frame = std::mem::take(highlight_next_frame);
+    }
+
+    /// How much space is still available after panels has been added.
+    /// This is the "background" area, what egui doesn't cover with panels (but may cover with windows).
+    /// This is also the area to which windows are constrained.
+    pub(crate) fn available_rect(&self) -> Rect {
+        crate::egui_assert!(
+            self.available_rect.is_finite(),
+            "Called `available_rect()` before `Context::run()`"
+        );
+        self.available_rect
+    }
+
+    /// Shrink `available_rect`.
+    pub(crate) fn allocate_left_panel(&mut self, panel_rect: Rect) {
+        crate::egui_assert!(
+            panel_rect.min.distance(self.available_rect.min) < 0.1,
+            "Mismatching left panel. You must not create a panel from within another panel."
+        );
+        self.available_rect.min.x = panel_rect.max.x;
+        self.unused_rect.min.x = panel_rect.max.x;
+        self.used_by_panels = self.used_by_panels.union(panel_rect);
+    }
+
+    /// Shrink `available_rect`.
+    pub(crate) fn allocate_right_panel(&mut self, panel_rect: Rect) {
+        crate::egui_assert!(
+            panel_rect.max.distance(self.available_rect.max) < 0.1,
+            "Mismatching right panel. You must not create a panel from within another panel."
+        );
+        self.available_rect.max.x = panel_rect.min.x;
+        self.unused_rect.max.x = panel_rect.min.x;
+        self.used_by_panels = self.used_by_panels.union(panel_rect);
+    }
+
+    /// Shrink `available_rect`.
+    pub(crate) fn allocate_top_panel(&mut self, panel_rect: Rect) {
+        crate::egui_assert!(
+            panel_rect.min.distance(self.available_rect.min) < 0.1,
+            "Mismatching top panel. You must not create a panel from within another panel."
+        );
+        self.available_rect.min.y = panel_rect.max.y;
+        self.unused_rect.min.y = panel_rect.max.y;
+        self.used_by_panels = self.used_by_panels.union(panel_rect);
+    }
+
+    /// Shrink `available_rect`.
+    pub(crate) fn allocate_bottom_panel(&mut self, panel_rect: Rect) {
+        crate::egui_assert!(
+            panel_rect.max.distance(self.available_rect.max) < 0.1,
+            "Mismatching bottom panel. You must not create a panel from within another panel."
+        );
+        self.available_rect.max.y = panel_rect.min.y;
+        self.unused_rect.max.y = panel_rect.min.y;
+        self.used_by_panels = self.used_by_panels.union(panel_rect);
+    }
+
+    pub(crate) fn allocate_central_panel(&mut self, panel_rect: Rect) {
+        // Note: we do not shrink `available_rect`, because
+        // we allow windows to cover the CentralPanel.
+        self.unused_rect = Rect::NOTHING; // Nothing left unused after this
+        self.used_by_panels = self.used_by_panels.union(panel_rect);
+    }
+}
diff --git a/egui/crates/egui/src/grid.rs b/egui/crates/egui/src/grid.rs
new file mode 100644
index 0000000..314266a
--- /dev/null
+++ b/egui/crates/egui/src/grid.rs
@@ -0,0 +1,439 @@
+use crate::*;
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub(crate) struct State {
+    col_widths: Vec<f32>,
+    row_heights: Vec<f32>,
+}
+
+impl State {
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        ctx.data_mut(|d| d.get_temp(id))
+    }
+
+    pub fn store(self, ctx: &Context, id: Id) {
+        // We don't persist Grids, because
+        // A) there are potentially a lot of them, using up a lot of space (and therefore serialization time)
+        // B) if the code changes, the grid _should_ change, and not remember old sizes
+        ctx.data_mut(|d| d.insert_temp(id, self));
+    }
+
+    fn set_min_col_width(&mut self, col: usize, width: f32) {
+        self.col_widths
+            .resize(self.col_widths.len().max(col + 1), 0.0);
+        self.col_widths[col] = self.col_widths[col].max(width);
+    }
+
+    fn set_min_row_height(&mut self, row: usize, height: f32) {
+        self.row_heights
+            .resize(self.row_heights.len().max(row + 1), 0.0);
+        self.row_heights[row] = self.row_heights[row].max(height);
+    }
+
+    fn col_width(&self, col: usize) -> Option<f32> {
+        self.col_widths.get(col).copied()
+    }
+
+    fn row_height(&self, row: usize) -> Option<f32> {
+        self.row_heights.get(row).copied()
+    }
+
+    fn full_width(&self, x_spacing: f32) -> f32 {
+        self.col_widths.iter().sum::<f32>()
+            + (self.col_widths.len().at_least(1) - 1) as f32 * x_spacing
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+// type alias for boxed function to determine row color during grid generation
+type ColorPickerFn = Box<dyn Fn(usize, &Style) -> Option<Color32>>;
+
+pub(crate) struct GridLayout {
+    ctx: Context,
+    style: std::sync::Arc<Style>,
+    id: Id,
+
+    /// First frame (no previous know state).
+    is_first_frame: bool,
+
+    /// State previous frame (if any).
+    /// This can be used to predict future sizes of cells.
+    prev_state: State,
+    /// State accumulated during the current frame.
+    curr_state: State,
+    initial_available: Rect,
+
+    // Options:
+    num_columns: Option<usize>,
+    spacing: Vec2,
+    min_cell_size: Vec2,
+    max_cell_size: Vec2,
+    color_picker: Option<ColorPickerFn>,
+
+    // Cursor:
+    col: usize,
+    row: usize,
+}
+
+impl GridLayout {
+    pub(crate) fn new(ui: &Ui, id: Id, prev_state: Option<State>) -> Self {
+        let is_first_frame = prev_state.is_none();
+        let prev_state = prev_state.unwrap_or_default();
+
+        // TODO(emilk): respect current layout
+
+        let initial_available = ui.placer().max_rect().intersect(ui.cursor());
+        crate::egui_assert!(
+            initial_available.min.x.is_finite(),
+            "Grid not yet available for right-to-left layouts"
+        );
+
+        ui.ctx().check_for_id_clash(id, initial_available, "Grid");
+
+        Self {
+            ctx: ui.ctx().clone(),
+            style: ui.style().clone(),
+            id,
+            is_first_frame,
+            prev_state,
+            curr_state: State::default(),
+            initial_available,
+
+            num_columns: None,
+            spacing: ui.spacing().item_spacing,
+            min_cell_size: ui.spacing().interact_size,
+            max_cell_size: Vec2::INFINITY,
+            color_picker: None,
+
+            col: 0,
+            row: 0,
+        }
+    }
+}
+
+impl GridLayout {
+    fn prev_col_width(&self, col: usize) -> f32 {
+        self.prev_state
+            .col_width(col)
+            .unwrap_or(self.min_cell_size.x)
+    }
+
+    fn prev_row_height(&self, row: usize) -> f32 {
+        self.prev_state
+            .row_height(row)
+            .unwrap_or(self.min_cell_size.y)
+    }
+
+    pub(crate) fn wrap_text(&self) -> bool {
+        self.max_cell_size.x.is_finite()
+    }
+
+    pub(crate) fn available_rect(&self, region: &Region) -> Rect {
+        let is_last_column = Some(self.col + 1) == self.num_columns;
+
+        let width = if is_last_column {
+            // The first frame we don't really know the widths of the previous columns,
+            // so returning a big available width here can cause trouble.
+            if self.is_first_frame {
+                self.curr_state
+                    .col_width(self.col)
+                    .unwrap_or(self.min_cell_size.x)
+            } else {
+                (self.initial_available.right() - region.cursor.left())
+                    .at_most(self.max_cell_size.x)
+            }
+        } else if self.max_cell_size.x.is_finite() {
+            // TODO(emilk): should probably heed `prev_state` here too
+            self.max_cell_size.x
+        } else {
+            // If we want to allow width-filling widgets like [`Separator`] in one of the first cells
+            // then we need to make sure they don't spill out of the first cell:
+            self.prev_state
+                .col_width(self.col)
+                .or_else(|| self.curr_state.col_width(self.col))
+                .unwrap_or(self.min_cell_size.x)
+        };
+
+        // If something above was wider, we can be wider:
+        let width = width.max(self.curr_state.col_width(self.col).unwrap_or(0.0));
+
+        let available = region.max_rect.intersect(region.cursor);
+
+        let height = region.max_rect.max.y - available.top();
+        let height = height
+            .at_least(self.min_cell_size.y)
+            .at_most(self.max_cell_size.y);
+
+        Rect::from_min_size(available.min, vec2(width, height))
+    }
+
+    pub(crate) fn next_cell(&self, cursor: Rect, child_size: Vec2) -> Rect {
+        let width = self.prev_state.col_width(self.col).unwrap_or(0.0);
+        let height = self.prev_row_height(self.row);
+        let size = child_size.max(vec2(width, height));
+        Rect::from_min_size(cursor.min, size)
+    }
+
+    #[allow(clippy::unused_self)]
+    pub(crate) fn align_size_within_rect(&self, size: Vec2, frame: Rect) -> Rect {
+        // TODO(emilk): allow this alignment to be customized
+        Align2::LEFT_CENTER.align_size_within_rect(size, frame)
+    }
+
+    pub(crate) fn justify_and_align(&self, frame: Rect, size: Vec2) -> Rect {
+        self.align_size_within_rect(size, frame)
+    }
+
+    pub(crate) fn advance(&mut self, cursor: &mut Rect, _frame_rect: Rect, widget_rect: Rect) {
+        let debug_expand_width = self.style.debug.show_expand_width;
+        let debug_expand_height = self.style.debug.show_expand_height;
+        if debug_expand_width || debug_expand_height {
+            let rect = widget_rect;
+            let too_wide = rect.width() > self.prev_col_width(self.col);
+            let too_high = rect.height() > self.prev_row_height(self.row);
+
+            if (debug_expand_width && too_wide) || (debug_expand_height && too_high) {
+                let painter = self.ctx.debug_painter();
+                painter.rect_stroke(rect, 0.0, (1.0, Color32::LIGHT_BLUE));
+
+                let stroke = Stroke::new(2.5, Color32::from_rgb(200, 0, 0));
+                let paint_line_seg = |a, b| painter.line_segment([a, b], stroke);
+
+                if debug_expand_width && too_wide {
+                    paint_line_seg(rect.left_top(), rect.left_bottom());
+                    paint_line_seg(rect.left_center(), rect.right_center());
+                    paint_line_seg(rect.right_top(), rect.right_bottom());
+                }
+            }
+        }
+
+        self.curr_state
+            .set_min_col_width(self.col, widget_rect.width().max(self.min_cell_size.x));
+        self.curr_state
+            .set_min_row_height(self.row, widget_rect.height().max(self.min_cell_size.y));
+
+        cursor.min.x += self.prev_col_width(self.col) + self.spacing.x;
+        self.col += 1;
+    }
+
+    fn paint_row(&mut self, cursor: &mut Rect, painter: &Painter) {
+        // handle row color painting based on color-picker function
+        let Some(color_picker) = self.color_picker.as_ref() else { return };
+        let Some(row_color)    = color_picker(self.row, &self.style) else { return };
+        let Some(height)       = self.prev_state.row_height(self.row) else {return };
+        // Paint background for coming row:
+        let size = Vec2::new(self.prev_state.full_width(self.spacing.x), height);
+        let rect = Rect::from_min_size(cursor.min, size);
+        let rect = rect.expand2(0.5 * self.spacing.y * Vec2::Y);
+        let rect = rect.expand2(2.0 * Vec2::X); // HACK: just looks better with some spacing on the sides
+
+        painter.rect_filled(rect, 2.0, row_color);
+    }
+
+    pub(crate) fn end_row(&mut self, cursor: &mut Rect, painter: &Painter) {
+        cursor.min.x = self.initial_available.min.x;
+        cursor.min.y += self.spacing.y;
+        cursor.min.y += self
+            .curr_state
+            .row_height(self.row)
+            .unwrap_or(self.min_cell_size.y);
+
+        self.col = 0;
+        self.row += 1;
+
+        self.paint_row(cursor, painter);
+    }
+
+    pub(crate) fn save(&self) {
+        if self.curr_state != self.prev_state {
+            self.curr_state.clone().store(&self.ctx, self.id);
+            self.ctx.request_repaint();
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A simple grid layout.
+///
+/// The cells are always laid out left to right, top-down.
+/// The contents of each cell will be aligned to the left and center.
+///
+/// If you want to add multiple widgets to a cell you need to group them with
+/// [`Ui::horizontal`], [`Ui::vertical`] etc.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// egui::Grid::new("some_unique_id").show(ui, |ui| {
+///     ui.label("First row, first column");
+///     ui.label("First row, second column");
+///     ui.end_row();
+///
+///     ui.label("Second row, first column");
+///     ui.label("Second row, second column");
+///     ui.label("Second row, third column");
+///     ui.end_row();
+///
+///     ui.horizontal(|ui| { ui.label("Same"); ui.label("cell"); });
+///     ui.label("Third row, second column");
+///     ui.end_row();
+/// });
+/// # });
+/// ```
+#[must_use = "You should call .show()"]
+pub struct Grid {
+    id_source: Id,
+    num_columns: Option<usize>,
+    min_col_width: Option<f32>,
+    min_row_height: Option<f32>,
+    max_cell_size: Vec2,
+    spacing: Option<Vec2>,
+    start_row: usize,
+    color_picker: Option<ColorPickerFn>,
+}
+
+impl Grid {
+    /// Create a new [`Grid`] with a locally unique identifier.
+    pub fn new(id_source: impl std::hash::Hash) -> Self {
+        Self {
+            id_source: Id::new(id_source),
+            num_columns: None,
+            min_col_width: None,
+            min_row_height: None,
+            max_cell_size: Vec2::INFINITY,
+            spacing: None,
+            start_row: 0,
+            color_picker: None,
+        }
+    }
+
+    /// Setting this will allow for dynamic coloring of rows of the grid object
+    pub fn with_row_color<F>(mut self, color_picker: F) -> Self
+    where
+        F: Fn(usize, &Style) -> Option<Color32> + 'static,
+    {
+        self.color_picker = Some(Box::new(color_picker));
+        self
+    }
+
+    /// Setting this will allow the last column to expand to take up the rest of the space of the parent [`Ui`].
+    pub fn num_columns(mut self, num_columns: usize) -> Self {
+        self.num_columns = Some(num_columns);
+        self
+    }
+
+    /// If `true`, add a subtle background color to every other row.
+    ///
+    /// This can make a table easier to read.
+    /// Default is whatever is in [`crate::Visuals::striped`].
+    pub fn striped(self, striped: bool) -> Self {
+        if striped {
+            self.with_row_color(move |row, style| {
+                if row % 2 == 1 {
+                    return Some(style.visuals.faint_bg_color);
+                }
+                None
+            })
+        } else {
+            self
+        }
+    }
+
+    /// Set minimum width of each column.
+    /// Default: [`crate::style::Spacing::interact_size`]`.x`.
+    pub fn min_col_width(mut self, min_col_width: f32) -> Self {
+        self.min_col_width = Some(min_col_width);
+        self
+    }
+
+    /// Set minimum height of each row.
+    /// Default: [`crate::style::Spacing::interact_size`]`.y`.
+    pub fn min_row_height(mut self, min_row_height: f32) -> Self {
+        self.min_row_height = Some(min_row_height);
+        self
+    }
+
+    /// Set soft maximum width (wrapping width) of each column.
+    pub fn max_col_width(mut self, max_col_width: f32) -> Self {
+        self.max_cell_size.x = max_col_width;
+        self
+    }
+
+    /// Set spacing between columns/rows.
+    /// Default: [`crate::style::Spacing::item_spacing`].
+    pub fn spacing(mut self, spacing: impl Into<Vec2>) -> Self {
+        self.spacing = Some(spacing.into());
+        self
+    }
+
+    /// Change which row number the grid starts on.
+    /// This can be useful when you have a large [`Grid`] inside of [`ScrollArea::show_rows`].
+    pub fn start_row(mut self, start_row: usize) -> Self {
+        self.start_row = start_row;
+        self
+    }
+}
+
+impl Grid {
+    pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        self.show_dyn(ui, Box::new(add_contents))
+    }
+
+    fn show_dyn<'c, R>(
+        self,
+        ui: &mut Ui,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let Self {
+            id_source,
+            num_columns,
+            min_col_width,
+            min_row_height,
+            max_cell_size,
+            spacing,
+            start_row,
+            color_picker,
+        } = self;
+        let min_col_width = min_col_width.unwrap_or_else(|| ui.spacing().interact_size.x);
+        let min_row_height = min_row_height.unwrap_or_else(|| ui.spacing().interact_size.y);
+        let spacing = spacing.unwrap_or_else(|| ui.spacing().item_spacing);
+
+        let id = ui.make_persistent_id(id_source);
+        let prev_state = State::load(ui.ctx(), id);
+
+        // Each grid cell is aligned LEFT_CENTER.
+        // If somebody wants to wrap more things inside a cell,
+        // then we should pick a default layout that matches that alignment,
+        // which we do here:
+        let max_rect = ui.cursor().intersect(ui.max_rect());
+        ui.allocate_ui_at_rect(max_rect, |ui| {
+            ui.set_visible(prev_state.is_some()); // Avoid visible first-frame jitter
+            ui.horizontal(|ui| {
+                let is_color = color_picker.is_some();
+                let mut grid = GridLayout {
+                    num_columns,
+                    color_picker,
+                    min_cell_size: vec2(min_col_width, min_row_height),
+                    max_cell_size,
+                    spacing,
+                    row: start_row,
+                    ..GridLayout::new(ui, id, prev_state)
+                };
+
+                // paint first incoming row
+                if is_color {
+                    let mut cursor = ui.cursor();
+                    let painter = ui.painter();
+                    grid.paint_row(&mut cursor, painter);
+                }
+
+                ui.set_grid(grid);
+                let r = add_contents(ui);
+                ui.save_grid();
+                r
+            })
+            .inner
+        })
+    }
+}
diff --git a/egui/crates/egui/src/gui_zoom.rs b/egui/crates/egui/src/gui_zoom.rs
new file mode 100644
index 0000000..1bee638
--- /dev/null
+++ b/egui/crates/egui/src/gui_zoom.rs
@@ -0,0 +1,117 @@
+//! Helpers for zooming the whole GUI of an app (changing [`Context::pixels_per_point`].
+//!
+use crate::*;
+
+/// The suggested keyboard shortcuts for global gui zooming.
+pub mod kb_shortcuts {
+    use super::*;
+
+    pub const ZOOM_IN: KeyboardShortcut =
+        KeyboardShortcut::new(Modifiers::COMMAND, Key::PlusEquals);
+    pub const ZOOM_OUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::Minus);
+    pub const ZOOM_RESET: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::Num0);
+}
+
+/// Let the user scale the GUI (change `Context::pixels_per_point`) by pressing
+/// Cmd+Plus, Cmd+Minus or Cmd+0, just like in a browser.
+///
+/// When using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe), you want to call this as:
+/// ```ignore
+/// // On web, the browser controls the gui zoom.
+/// if !frame.is_web() {
+///     egui::gui_zoom::zoom_with_keyboard_shortcuts(
+///         ctx,
+///         frame.info().native_pixels_per_point,
+///     );
+/// }
+/// ```
+pub fn zoom_with_keyboard_shortcuts(ctx: &Context, native_pixels_per_point: Option<f32>) {
+    if ctx.input_mut(|i| i.consume_shortcut(&kb_shortcuts::ZOOM_RESET)) {
+        if let Some(native_pixels_per_point) = native_pixels_per_point {
+            ctx.set_pixels_per_point(native_pixels_per_point);
+        }
+    } else {
+        if ctx.input_mut(|i| i.consume_shortcut(&kb_shortcuts::ZOOM_IN)) {
+            zoom_in(ctx);
+        }
+        if ctx.input_mut(|i| i.consume_shortcut(&kb_shortcuts::ZOOM_OUT)) {
+            zoom_out(ctx);
+        }
+    }
+}
+
+const MIN_PIXELS_PER_POINT: f32 = 0.2;
+const MAX_PIXELS_PER_POINT: f32 = 4.0;
+
+/// Make everything larger.
+pub fn zoom_in(ctx: &Context) {
+    let mut pixels_per_point = ctx.pixels_per_point();
+    pixels_per_point += 0.1;
+    pixels_per_point = pixels_per_point.clamp(MIN_PIXELS_PER_POINT, MAX_PIXELS_PER_POINT);
+    pixels_per_point = (pixels_per_point * 10.).round() / 10.;
+    ctx.set_pixels_per_point(pixels_per_point);
+}
+
+/// Make everything smaller.
+pub fn zoom_out(ctx: &Context) {
+    let mut pixels_per_point = ctx.pixels_per_point();
+    pixels_per_point -= 0.1;
+    pixels_per_point = pixels_per_point.clamp(MIN_PIXELS_PER_POINT, MAX_PIXELS_PER_POINT);
+    pixels_per_point = (pixels_per_point * 10.).round() / 10.;
+    ctx.set_pixels_per_point(pixels_per_point);
+}
+
+/// Show buttons for zooming the ui.
+///
+/// This is meant to be called from within a menu (See [`Ui::menu_button`]).
+///
+/// When using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe), you want to call this as:
+/// ```ignore
+/// // On web, the browser controls the gui zoom.
+/// if !frame.is_web() {
+///     ui.menu_button("View", |ui| {
+///         egui::gui_zoom::zoom_menu_buttons(
+///             ui,
+///             frame.info().native_pixels_per_point,
+///         );
+///     });
+/// }
+/// ```
+pub fn zoom_menu_buttons(ui: &mut Ui, native_pixels_per_point: Option<f32>) {
+    if ui
+        .add_enabled(
+            ui.ctx().pixels_per_point() < MAX_PIXELS_PER_POINT,
+            Button::new("Zoom In").shortcut_text(ui.ctx().format_shortcut(&kb_shortcuts::ZOOM_IN)),
+        )
+        .clicked()
+    {
+        zoom_in(ui.ctx());
+        ui.close_menu();
+    }
+
+    if ui
+        .add_enabled(
+            ui.ctx().pixels_per_point() > MIN_PIXELS_PER_POINT,
+            Button::new("Zoom Out")
+                .shortcut_text(ui.ctx().format_shortcut(&kb_shortcuts::ZOOM_OUT)),
+        )
+        .clicked()
+    {
+        zoom_out(ui.ctx());
+        ui.close_menu();
+    }
+
+    if let Some(native_pixels_per_point) = native_pixels_per_point {
+        if ui
+            .add_enabled(
+                ui.ctx().pixels_per_point() != native_pixels_per_point,
+                Button::new("Reset Zoom")
+                    .shortcut_text(ui.ctx().format_shortcut(&kb_shortcuts::ZOOM_RESET)),
+            )
+            .clicked()
+        {
+            ui.ctx().set_pixels_per_point(native_pixels_per_point);
+            ui.close_menu();
+        }
+    }
+}
diff --git a/egui/crates/egui/src/id.rs b/egui/crates/egui/src/id.rs
new file mode 100644
index 0000000..6123143
--- /dev/null
+++ b/egui/crates/egui/src/id.rs
@@ -0,0 +1,175 @@
+// TODO(emilk): have separate types `PositionId` and `UniqueId`. ?
+
+/// egui tracks widgets frame-to-frame using [`Id`]s.
+///
+/// For instance, if you start dragging a slider one frame, egui stores
+/// the sliders [`Id`] as the current active id so that next frame when
+/// you move the mouse the same slider changes, even if the mouse has
+/// moved outside the slider.
+///
+/// For some widgets [`Id`]s are also used to persist some state about the
+/// widgets, such as Window position or whether not a collapsing header region is open.
+///
+/// This implies that the [`Id`]s must be unique.
+///
+/// For simple things like sliders and buttons that don't have any memory and
+/// doesn't move we can use the location of the widget as a source of identity.
+/// For instance, a slider only needs a unique and persistent ID while you are
+/// dragging the slider. As long as it is still while moving, that is fine.
+///
+/// For things that need to persist state even after moving (windows, collapsing headers)
+/// the location of the widgets is obviously not good enough. For instance,
+/// a collapsing region needs to remember whether or not it is open even
+/// if the layout next frame is different and the collapsing is not lower down
+/// on the screen.
+///
+/// Then there are widgets that need no identifiers at all, like labels,
+/// because they have no state nor are interacted with.
+#[derive(Clone, Copy, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Id(u64);
+
+impl Id {
+    /// A special [`Id`], in particular as a key to [`crate::Memory::data`]
+    /// for when there is no particular widget to attach the data.
+    ///
+    /// The null [`Id`] is still a valid id to use in all circumstances,
+    /// though obviously it will lead to a lot of collisions if you do use it!
+    pub fn null() -> Self {
+        Self(0)
+    }
+
+    pub(crate) fn background() -> Self {
+        Self(1)
+    }
+
+    /// Generate a new [`Id`] by hashing some source (e.g. a string or integer).
+    pub fn new(source: impl std::hash::Hash) -> Id {
+        use std::hash::{BuildHasher, Hasher};
+        let mut hasher = epaint::ahash::RandomState::with_seeds(1, 2, 3, 4).build_hasher();
+        source.hash(&mut hasher);
+        Id(hasher.finish())
+    }
+
+    /// Generate a new [`Id`] by hashing the parent [`Id`] and the given argument.
+    pub fn with(self, child: impl std::hash::Hash) -> Id {
+        use std::hash::{BuildHasher, Hasher};
+        let mut hasher = epaint::ahash::RandomState::with_seeds(1, 2, 3, 4).build_hasher();
+        hasher.write_u64(self.0);
+        child.hash(&mut hasher);
+        Id(hasher.finish())
+    }
+
+    /// Short and readable summary
+    pub fn short_debug_format(&self) -> String {
+        format!("{:04X}", self.0 as u16)
+    }
+
+    #[inline(always)]
+    pub(crate) fn value(&self) -> u64 {
+        self.0
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub(crate) fn accesskit_id(&self) -> accesskit::NodeId {
+        std::num::NonZeroU64::new(self.0).unwrap().into()
+    }
+}
+
+impl std::fmt::Debug for Id {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:016X}", self.0)
+    }
+}
+
+/// Convenience
+impl From<&'static str> for Id {
+    #[inline]
+    fn from(string: &'static str) -> Self {
+        Self::new(string)
+    }
+}
+
+impl From<String> for Id {
+    #[inline]
+    fn from(string: String) -> Self {
+        Self::new(string)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+// Idea taken from the `nohash_hasher` crate.
+#[derive(Default)]
+pub struct IdHasher(u64);
+
+impl std::hash::Hasher for IdHasher {
+    fn write(&mut self, _: &[u8]) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_u8(&mut self, _n: u8) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_u16(&mut self, _n: u16) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_u32(&mut self, _n: u32) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    #[inline(always)]
+    fn write_u64(&mut self, n: u64) {
+        self.0 = n;
+    }
+
+    fn write_usize(&mut self, _n: usize) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_i8(&mut self, _n: i8) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_i16(&mut self, _n: i16) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_i32(&mut self, _n: i32) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_i64(&mut self, _n: i64) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    fn write_isize(&mut self, _n: isize) {
+        unreachable!("Invalid use of IdHasher");
+    }
+
+    #[inline(always)]
+    fn finish(&self) -> u64 {
+        self.0
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct BuildIdHasher {}
+
+impl std::hash::BuildHasher for BuildIdHasher {
+    type Hasher = IdHasher;
+
+    #[inline(always)]
+    fn build_hasher(&self) -> IdHasher {
+        IdHasher::default()
+    }
+}
+
+/// `IdSet` is a `HashSet<Id>` optimized by knowing that [`Id`] has good entropy, and doesn't need more hashing.
+pub type IdSet = std::collections::HashSet<Id, BuildIdHasher>;
+
+/// `IdMap<V>` is a `HashMap<Id, V>` optimized by knowing that [`Id`] has good entropy, and doesn't need more hashing.
+pub type IdMap<V> = std::collections::HashMap<Id, V, BuildIdHasher>;
diff --git a/egui/crates/egui/src/input_state.rs b/egui/crates/egui/src/input_state.rs
new file mode 100644
index 0000000..12b1325
--- /dev/null
+++ b/egui/crates/egui/src/input_state.rs
@@ -0,0 +1,1018 @@
+mod touch_state;
+
+use crate::data::input::*;
+use crate::{emath::*, util::History};
+use std::collections::{BTreeMap, HashSet};
+
+pub use crate::data::input::Key;
+pub use touch_state::MultiTouchInfo;
+use touch_state::TouchState;
+
+/// If the pointer moves more than this, it won't become a click (but it is still a drag)
+const MAX_CLICK_DIST: f32 = 6.0; // TODO(emilk): move to settings
+
+/// If the pointer is down for longer than this, it won't become a click (but it is still a drag)
+const MAX_CLICK_DURATION: f64 = 0.6; // TODO(emilk): move to settings
+
+/// The new pointer press must come within this many seconds from previous pointer release
+const MAX_DOUBLE_CLICK_DELAY: f64 = 0.3; // TODO(emilk): move to settings
+
+/// Input state that egui updates each frame.
+///
+/// You can check if `egui` is using the inputs using
+/// [`crate::Context::wants_pointer_input`] and [`crate::Context::wants_keyboard_input`].
+#[derive(Clone, Debug)]
+pub struct InputState {
+    /// The raw input we got this frame from the backend.
+    pub raw: RawInput,
+
+    /// State of the mouse or simple touch gestures which can be mapped to mouse operations.
+    pub pointer: PointerState,
+
+    /// State of touches, except those covered by PointerState (like clicks and drags).
+    /// (We keep a separate [`TouchState`] for each encountered touch device.)
+    touch_states: BTreeMap<TouchDeviceId, TouchState>,
+
+    /// How many points the user scrolled.
+    ///
+    /// The delta dictates how the _content_ should move.
+    ///
+    /// A positive X-value indicates the content is being moved right,
+    /// as when swiping right on a touch-screen or track-pad with natural scrolling.
+    ///
+    /// A positive Y-value indicates the content is being moved down,
+    /// as when swiping down on a touch-screen or track-pad with natural scrolling.
+    pub scroll_delta: Vec2,
+
+    /// Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
+    ///
+    /// * `zoom = 1`: no change.
+    /// * `zoom < 1`: pinch together
+    /// * `zoom > 1`: pinch spread
+    zoom_factor_delta: f32,
+
+    /// Position and size of the egui area.
+    pub screen_rect: Rect,
+
+    /// Also known as device pixel ratio, > 1 for high resolution screens.
+    pub pixels_per_point: f32,
+
+    /// Maximum size of one side of a texture.
+    ///
+    /// This depends on the backend.
+    pub max_texture_side: usize,
+
+    /// Time in seconds. Relative to whatever. Used for animation.
+    pub time: f64,
+
+    /// Time since last frame, in seconds.
+    ///
+    /// This can be very unstable in reactive mode (when we don't paint each frame).
+    /// For animations it is therefore better to use [`Self::stable_dt`].
+    pub unstable_dt: f32,
+
+    /// Estimated time until next frame (provided we repaint right away).
+    ///
+    /// Used for animations to get instant feedback (avoid frame delay).
+    /// Should be set to the expected time between frames when painting at vsync speeds.
+    ///
+    /// On most integrations this has a fixed value of `1.0 / 60.0`, so it is not a very accurate estimate.
+    pub predicted_dt: f32,
+
+    /// Time since last frame (in seconds), but gracefully handles the first frame after sleeping in reactive mode.
+    ///
+    /// In reactive mode (available in e.g. `eframe`), `egui` only updates when there is new input
+    /// or something is animating.
+    /// This can lead to large gaps of time (sleep), leading to large [`Self::unstable_dt`].
+    ///
+    /// If `egui` requested a repaint the previous frame, then `egui` will use
+    /// `stable_dt = unstable_dt;`, but if `egui` did not not request a repaint last frame,
+    /// then `egui` will assume `unstable_dt` is too large, and will use
+    /// `stable_dt = predicted_dt;`.
+    ///
+    /// This means that for the first frame after a sleep,
+    /// `stable_dt` will be a prediction of the delta-time until the next frame,
+    /// and in all other situations this will be an accurate measurement of time passed
+    /// since the previous frame.
+    ///
+    /// Note that a frame can still stall for various reasons, so `stable_dt` can
+    /// still be unusually large in some situations.
+    ///
+    /// When animating something, it is recommended that you use something like
+    /// `stable_dt.min(0.1)` - this will give you smooth animations when the framerate is good
+    /// (even in reactive mode), but will avoid large jumps when framerate is bad,
+    /// and will effectively slow down the animation when FPS drops below 10.
+    pub stable_dt: f32,
+
+    /// Which modifier keys are down at the start of the frame?
+    pub modifiers: Modifiers,
+
+    // The keys that are currently being held down.
+    pub keys_down: HashSet<Key>,
+
+    /// In-order events received this frame
+    pub events: Vec<Event>,
+}
+
+impl Default for InputState {
+    fn default() -> Self {
+        Self {
+            raw: Default::default(),
+            pointer: Default::default(),
+            touch_states: Default::default(),
+            scroll_delta: Vec2::ZERO,
+            zoom_factor_delta: 1.0,
+            screen_rect: Rect::from_min_size(Default::default(), vec2(10_000.0, 10_000.0)),
+            pixels_per_point: 1.0,
+            max_texture_side: 2048,
+            time: 0.0,
+            unstable_dt: 1.0 / 60.0,
+            predicted_dt: 1.0 / 60.0,
+            stable_dt: 1.0 / 60.0,
+            modifiers: Default::default(),
+            keys_down: Default::default(),
+            events: Default::default(),
+        }
+    }
+}
+
+impl InputState {
+    #[must_use]
+    pub fn begin_frame(
+        mut self,
+        mut new: RawInput,
+        requested_repaint_last_frame: bool,
+    ) -> InputState {
+        let time = new.time.unwrap_or(self.time + new.predicted_dt as f64);
+        let unstable_dt = (time - self.time) as f32;
+
+        let stable_dt = if requested_repaint_last_frame {
+            // we should have had a repaint straight away,
+            // so this should be trustable.
+            unstable_dt
+        } else {
+            new.predicted_dt
+        };
+
+        let screen_rect = new.screen_rect.unwrap_or(self.screen_rect);
+        self.create_touch_states_for_new_devices(&new.events);
+        for touch_state in self.touch_states.values_mut() {
+            touch_state.begin_frame(time, &new, self.pointer.interact_pos);
+        }
+        let pointer = self.pointer.begin_frame(time, &new);
+
+        let mut keys_down = self.keys_down;
+        let mut scroll_delta = Vec2::ZERO;
+        let mut zoom_factor_delta = 1.0;
+        for event in &mut new.events {
+            match event {
+                Event::Key {
+                    key,
+                    pressed,
+                    repeat,
+                    ..
+                } => {
+                    if *pressed {
+                        let first_press = keys_down.insert(*key);
+                        *repeat = !first_press;
+                    } else {
+                        keys_down.remove(key);
+                    }
+                }
+                Event::Scroll(delta) => {
+                    scroll_delta += *delta;
+                }
+                Event::Zoom(factor) => {
+                    zoom_factor_delta *= *factor;
+                }
+                _ => {}
+            }
+        }
+
+        InputState {
+            pointer,
+            touch_states: self.touch_states,
+            scroll_delta,
+            zoom_factor_delta,
+            screen_rect,
+            pixels_per_point: new.pixels_per_point.unwrap_or(self.pixels_per_point),
+            max_texture_side: new.max_texture_side.unwrap_or(self.max_texture_side),
+            time,
+            unstable_dt,
+            predicted_dt: new.predicted_dt,
+            stable_dt,
+            modifiers: new.modifiers,
+            keys_down,
+            events: new.events.clone(), // TODO(emilk): remove clone() and use raw.events
+            raw: new,
+        }
+    }
+
+    #[inline(always)]
+    pub fn screen_rect(&self) -> Rect {
+        self.screen_rect
+    }
+
+    /// Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
+    /// * `zoom = 1`: no change
+    /// * `zoom < 1`: pinch together
+    /// * `zoom > 1`: pinch spread
+    #[inline(always)]
+    pub fn zoom_delta(&self) -> f32 {
+        // If a multi touch gesture is detected, it measures the exact and linear proportions of
+        // the distances of the finger tips. It is therefore potentially more accurate than
+        // `zoom_factor_delta` which is based on the `ctrl-scroll` event which, in turn, may be
+        // synthesized from an original touch gesture.
+        self.multi_touch()
+            .map_or(self.zoom_factor_delta, |touch| touch.zoom_delta)
+    }
+
+    /// 2D non-proportional zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
+    ///
+    /// For multitouch devices the user can do a horizontal or vertical pinch gesture.
+    /// In these cases a non-proportional zoom factor is a available.
+    /// In other cases, this reverts to `Vec2::splat(self.zoom_delta())`.
+    ///
+    /// For horizontal pinches, this will return `[z, 1]`,
+    /// for vertical pinches this will return `[1, z]`,
+    /// and otherwise this will return `[z, z]`,
+    /// where `z` is the zoom factor:
+    /// * `zoom = 1`: no change
+    /// * `zoom < 1`: pinch together
+    /// * `zoom > 1`: pinch spread
+    #[inline(always)]
+    pub fn zoom_delta_2d(&self) -> Vec2 {
+        // If a multi touch gesture is detected, it measures the exact and linear proportions of
+        // the distances of the finger tips.  It is therefore potentially more accurate than
+        // `zoom_factor_delta` which is based on the `ctrl-scroll` event which, in turn, may be
+        // synthesized from an original touch gesture.
+        self.multi_touch().map_or_else(
+            || Vec2::splat(self.zoom_factor_delta),
+            |touch| touch.zoom_delta_2d,
+        )
+    }
+
+    pub fn wants_repaint(&self) -> bool {
+        self.pointer.wants_repaint() || self.scroll_delta != Vec2::ZERO || !self.events.is_empty()
+    }
+
+    /// Count presses of a key. If non-zero, the presses are consumed, so that this will only return non-zero once.
+    ///
+    /// Includes key-repeat events.
+    pub fn count_and_consume_key(&mut self, modifiers: Modifiers, key: Key) -> usize {
+        let mut count = 0usize;
+
+        self.events.retain(|event| {
+            let is_match = matches!(
+                event,
+                Event::Key {
+                    key: ev_key,
+                    modifiers: ev_mods,
+                    pressed: true,
+                    ..
+                } if *ev_key == key && ev_mods.matches(modifiers)
+            );
+
+            count += is_match as usize;
+
+            !is_match
+        });
+
+        count
+    }
+
+    /// Check for a key press. If found, `true` is returned and the key pressed is consumed, so that this will only return `true` once.
+    ///
+    /// Includes key-repeat events.
+    pub fn consume_key(&mut self, modifiers: Modifiers, key: Key) -> bool {
+        self.count_and_consume_key(modifiers, key) > 0
+    }
+
+    /// Check if the given shortcut has been pressed.
+    ///
+    /// If so, `true` is returned and the key pressed is consumed, so that this will only return `true` once.
+    ///
+    /// Includes key-repeat events.
+    pub fn consume_shortcut(&mut self, shortcut: &KeyboardShortcut) -> bool {
+        let KeyboardShortcut { modifiers, key } = *shortcut;
+        self.consume_key(modifiers, key)
+    }
+
+    /// Was the given key pressed this frame?
+    ///
+    /// Includes key-repeat events.
+    pub fn key_pressed(&self, desired_key: Key) -> bool {
+        self.num_presses(desired_key) > 0
+    }
+
+    /// How many times was the given key pressed this frame?
+    ///
+    /// Includes key-repeat events.
+    pub fn num_presses(&self, desired_key: Key) -> usize {
+        self.events
+            .iter()
+            .filter(|event| {
+                matches!(
+                    event,
+                    Event::Key { key, pressed: true, .. }
+                    if *key == desired_key
+                )
+            })
+            .count()
+    }
+
+    /// Is the given key currently held down?
+    pub fn key_down(&self, desired_key: Key) -> bool {
+        self.keys_down.contains(&desired_key)
+    }
+
+    /// Was the given key released this frame?
+    pub fn key_released(&self, desired_key: Key) -> bool {
+        self.events.iter().any(|event| {
+            matches!(
+                event,
+                Event::Key {
+                    key,
+                    pressed: false,
+                    ..
+                } if *key == desired_key
+            )
+        })
+    }
+
+    /// Also known as device pixel ratio, > 1 for high resolution screens.
+    #[inline(always)]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.pixels_per_point
+    }
+
+    /// Size of a physical pixel in logical gui coordinates (points).
+    #[inline(always)]
+    pub fn physical_pixel_size(&self) -> f32 {
+        1.0 / self.pixels_per_point()
+    }
+
+    /// How imprecise do we expect the mouse/touch input to be?
+    /// Returns imprecision in points.
+    #[inline(always)]
+    pub fn aim_radius(&self) -> f32 {
+        // TODO(emilk): multiply by ~3 for touch inputs because fingers are fat
+        self.physical_pixel_size()
+    }
+
+    /// Returns details about the currently ongoing multi-touch gesture, if any. Note that this
+    /// method returns `None` for single-touch gestures (click, drag, …).
+    ///
+    /// ```
+    /// # use egui::emath::Rot2;
+    /// # egui::__run_test_ui(|ui| {
+    /// let mut zoom = 1.0; // no zoom
+    /// let mut rotation = 0.0; // no rotation
+    /// let multi_touch = ui.input(|i| i.multi_touch());
+    /// if let Some(multi_touch) = multi_touch {
+    ///     zoom *= multi_touch.zoom_delta;
+    ///     rotation += multi_touch.rotation_delta;
+    /// }
+    /// let transform = zoom * Rot2::from_angle(rotation);
+    /// # });
+    /// ```
+    ///
+    /// By far not all touch devices are supported, and the details depend on the `egui`
+    /// integration backend you are using. `eframe` web supports multi touch for most mobile
+    /// devices, but not for a `Trackpad` on `MacOS`, for example. The backend has to be able to
+    /// capture native touch events, but many browsers seem to pass such events only for touch
+    /// _screens_, but not touch _pads._
+    ///
+    /// Refer to [`MultiTouchInfo`] for details about the touch information available.
+    ///
+    /// Consider using `zoom_delta()` instead of `MultiTouchInfo::zoom_delta` as the former
+    /// delivers a synthetic zoom factor based on ctrl-scroll events, as a fallback.
+    pub fn multi_touch(&self) -> Option<MultiTouchInfo> {
+        // In case of multiple touch devices simply pick the touch_state of the first active device
+        if let Some(touch_state) = self.touch_states.values().find(|t| t.is_active()) {
+            touch_state.info()
+        } else {
+            None
+        }
+    }
+
+    /// True if there currently are any fingers touching egui.
+    pub fn any_touches(&self) -> bool {
+        !self.touch_states.is_empty()
+    }
+
+    /// Scans `events` for device IDs of touch devices we have not seen before,
+    /// and creates a new [`TouchState`] for each such device.
+    fn create_touch_states_for_new_devices(&mut self, events: &[Event]) {
+        for event in events {
+            if let Event::Touch { device_id, .. } = event {
+                self.touch_states
+                    .entry(*device_id)
+                    .or_insert_with(|| TouchState::new(*device_id));
+            }
+        }
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub fn accesskit_action_requests(
+        &self,
+        id: crate::Id,
+        action: accesskit::Action,
+    ) -> impl Iterator<Item = &accesskit::ActionRequest> {
+        let accesskit_id = id.accesskit_id();
+        self.events.iter().filter_map(move |event| {
+            if let Event::AccessKitActionRequest(request) = event {
+                if request.target == accesskit_id && request.action == action {
+                    return Some(request);
+                }
+            }
+            None
+        })
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub fn has_accesskit_action_request(&self, id: crate::Id, action: accesskit::Action) -> bool {
+        self.accesskit_action_requests(id, action).next().is_some()
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub fn num_accesskit_action_requests(&self, id: crate::Id, action: accesskit::Action) -> usize {
+        self.accesskit_action_requests(id, action).count()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A pointer (mouse or touch) click.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct Click {
+    pub pos: Pos2,
+
+    /// 1 or 2 (double-click) or 3 (triple-click)
+    pub count: u32,
+
+    /// Allows you to check for e.g. shift-click
+    pub modifiers: Modifiers,
+}
+
+impl Click {
+    pub fn is_double(&self) -> bool {
+        self.count == 2
+    }
+
+    pub fn is_triple(&self) -> bool {
+        self.count == 3
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum PointerEvent {
+    Moved(Pos2),
+    Pressed {
+        position: Pos2,
+        button: PointerButton,
+    },
+    Released {
+        click: Option<Click>,
+        button: PointerButton,
+    },
+}
+
+impl PointerEvent {
+    pub fn is_press(&self) -> bool {
+        matches!(self, PointerEvent::Pressed { .. })
+    }
+
+    pub fn is_release(&self) -> bool {
+        matches!(self, PointerEvent::Released { .. })
+    }
+
+    pub fn is_click(&self) -> bool {
+        matches!(self, PointerEvent::Released { click: Some(_), .. })
+    }
+}
+
+/// Mouse or touch state.
+#[derive(Clone, Debug)]
+pub struct PointerState {
+    /// Latest known time
+    time: f64,
+
+    // Consider a finger tapping a touch screen.
+    // What position should we report?
+    // The location of the touch, or `None`, because the finger is gone?
+    //
+    // For some cases we want the first: e.g. to check for interaction.
+    // For showing tooltips, we want the latter (no tooltips, since there are no fingers).
+    /// Latest reported pointer position.
+    /// When tapping a touch screen, this will be `None`.
+    latest_pos: Option<Pos2>,
+
+    /// Latest position of the mouse, but ignoring any [`Event::PointerGone`]
+    /// if there were interactions this frame.
+    /// When tapping a touch screen, this will be the location of the touch.
+    interact_pos: Option<Pos2>,
+
+    /// How much the pointer moved compared to last frame, in points.
+    delta: Vec2,
+
+    /// Current velocity of pointer.
+    velocity: Vec2,
+
+    /// Recent movement of the pointer.
+    /// Used for calculating velocity of pointer.
+    pos_history: History<Pos2>,
+
+    down: [bool; NUM_POINTER_BUTTONS],
+
+    /// Where did the current click/drag originate?
+    /// `None` if no mouse button is down.
+    press_origin: Option<Pos2>,
+
+    /// When did the current click/drag originate?
+    /// `None` if no mouse button is down.
+    press_start_time: Option<f64>,
+
+    /// Set to `true` if the pointer has moved too much (since being pressed)
+    /// for it to be registered as a click.
+    pub(crate) has_moved_too_much_for_a_click: bool,
+
+    /// When did the pointer get click last?
+    /// Used to check for double-clicks.
+    last_click_time: f64,
+
+    /// When did the pointer get click two clicks ago?
+    /// Used to check for triple-clicks.
+    last_last_click_time: f64,
+
+    /// All button events that occurred this frame
+    pub(crate) pointer_events: Vec<PointerEvent>,
+}
+
+impl Default for PointerState {
+    fn default() -> Self {
+        Self {
+            time: -f64::INFINITY,
+            latest_pos: None,
+            interact_pos: None,
+            delta: Vec2::ZERO,
+            velocity: Vec2::ZERO,
+            pos_history: History::new(0..1000, 0.1),
+            down: Default::default(),
+            press_origin: None,
+            press_start_time: None,
+            has_moved_too_much_for_a_click: false,
+            last_click_time: std::f64::NEG_INFINITY,
+            last_last_click_time: std::f64::NEG_INFINITY,
+            pointer_events: vec![],
+        }
+    }
+}
+
+impl PointerState {
+    #[must_use]
+    pub(crate) fn begin_frame(mut self, time: f64, new: &RawInput) -> PointerState {
+        self.time = time;
+
+        self.pointer_events.clear();
+
+        let old_pos = self.latest_pos;
+        self.interact_pos = self.latest_pos;
+
+        for event in &new.events {
+            match event {
+                Event::PointerMoved(pos) => {
+                    let pos = *pos;
+
+                    self.latest_pos = Some(pos);
+                    self.interact_pos = Some(pos);
+
+                    if let Some(press_origin) = self.press_origin {
+                        self.has_moved_too_much_for_a_click |=
+                            press_origin.distance(pos) > MAX_CLICK_DIST;
+                    }
+
+                    self.pointer_events.push(PointerEvent::Moved(pos));
+                }
+                Event::PointerButton {
+                    pos,
+                    button,
+                    pressed,
+                    modifiers,
+                } => {
+                    let pos = *pos;
+                    let button = *button;
+                    let pressed = *pressed;
+                    let modifiers = *modifiers;
+
+                    self.latest_pos = Some(pos);
+                    self.interact_pos = Some(pos);
+
+                    if pressed {
+                        // Start of a drag: we want to track the velocity for during the drag
+                        // and ignore any incoming movement
+                        self.pos_history.clear();
+                    }
+
+                    if pressed {
+                        self.press_origin = Some(pos);
+                        self.press_start_time = Some(time);
+                        self.has_moved_too_much_for_a_click = false;
+                        self.pointer_events.push(PointerEvent::Pressed {
+                            position: pos,
+                            button,
+                        });
+                    } else {
+                        let clicked = self.could_any_button_be_click();
+
+                        let click = if clicked {
+                            let double_click =
+                                (time - self.last_click_time) < MAX_DOUBLE_CLICK_DELAY;
+                            let triple_click =
+                                (time - self.last_last_click_time) < (MAX_DOUBLE_CLICK_DELAY * 2.0);
+                            let count = if triple_click {
+                                3
+                            } else if double_click {
+                                2
+                            } else {
+                                1
+                            };
+
+                            self.last_last_click_time = self.last_click_time;
+                            self.last_click_time = time;
+
+                            Some(Click {
+                                pos,
+                                count,
+                                modifiers,
+                            })
+                        } else {
+                            None
+                        };
+
+                        self.pointer_events
+                            .push(PointerEvent::Released { click, button });
+
+                        self.press_origin = None;
+                        self.press_start_time = None;
+                    }
+
+                    self.down[button as usize] = pressed; // must be done after the above call to `could_any_button_be_click`
+                }
+                Event::PointerGone => {
+                    self.latest_pos = None;
+                    // NOTE: we do NOT clear `self.interact_pos` here. It will be cleared next frame.
+                }
+                _ => {}
+            }
+        }
+
+        self.delta = if let (Some(old_pos), Some(new_pos)) = (old_pos, self.latest_pos) {
+            new_pos - old_pos
+        } else {
+            Vec2::ZERO
+        };
+
+        if let Some(pos) = self.latest_pos {
+            self.pos_history.add(time, pos);
+        } else {
+            // we do not clear the `pos_history` here, because it is exactly when a finger has
+            // released from the touch screen that we may want to assign a velocity to whatever
+            // the user tried to throw.
+        }
+
+        self.pos_history.flush(time);
+
+        self.velocity = if self.pos_history.len() >= 3 && self.pos_history.duration() > 0.01 {
+            self.pos_history.velocity().unwrap_or_default()
+        } else {
+            Vec2::default()
+        };
+
+        self
+    }
+
+    fn wants_repaint(&self) -> bool {
+        !self.pointer_events.is_empty() || self.delta != Vec2::ZERO
+    }
+
+    /// How much the pointer moved compared to last frame, in points.
+    #[inline(always)]
+    pub fn delta(&self) -> Vec2 {
+        self.delta
+    }
+
+    /// Current velocity of pointer.
+    #[inline(always)]
+    pub fn velocity(&self) -> Vec2 {
+        self.velocity
+    }
+
+    /// Where did the current click/drag originate?
+    /// `None` if no mouse button is down.
+    #[inline(always)]
+    pub fn press_origin(&self) -> Option<Pos2> {
+        self.press_origin
+    }
+
+    /// When did the current click/drag originate?
+    /// `None` if no mouse button is down.
+    #[inline(always)]
+    pub fn press_start_time(&self) -> Option<f64> {
+        self.press_start_time
+    }
+
+    /// Latest reported pointer position.
+    /// When tapping a touch screen, this will be `None`.
+    #[inline(always)]
+    pub(crate) fn latest_pos(&self) -> Option<Pos2> {
+        self.latest_pos
+    }
+
+    /// If it is a good idea to show a tooltip, where is pointer?
+    #[inline(always)]
+    pub fn hover_pos(&self) -> Option<Pos2> {
+        self.latest_pos
+    }
+
+    /// If you detect a click or drag and wants to know where it happened, use this.
+    ///
+    /// Latest position of the mouse, but ignoring any [`Event::PointerGone`]
+    /// if there were interactions this frame.
+    /// When tapping a touch screen, this will be the location of the touch.
+    #[inline(always)]
+    pub fn interact_pos(&self) -> Option<Pos2> {
+        self.interact_pos
+    }
+
+    /// Do we have a pointer?
+    ///
+    /// `false` if the mouse is not over the egui area, or if no touches are down on touch screens.
+    #[inline(always)]
+    pub fn has_pointer(&self) -> bool {
+        self.latest_pos.is_some()
+    }
+
+    /// Is the pointer currently still?
+    /// This is smoothed so a few frames of stillness is required before this returns `true`.
+    #[inline(always)]
+    pub fn is_still(&self) -> bool {
+        self.velocity == Vec2::ZERO
+    }
+
+    /// Is the pointer currently moving?
+    /// This is smoothed so a few frames of stillness is required before this returns `false`.
+    #[inline]
+    pub fn is_moving(&self) -> bool {
+        self.velocity != Vec2::ZERO
+    }
+
+    /// Was any pointer button pressed (`!down -> down`) this frame?
+    /// This can sometimes return `true` even if `any_down() == false`
+    /// because a press can be shorted than one frame.
+    pub fn any_pressed(&self) -> bool {
+        self.pointer_events.iter().any(|event| event.is_press())
+    }
+
+    /// Was any pointer button released (`down -> !down`) this frame?
+    pub fn any_released(&self) -> bool {
+        self.pointer_events.iter().any(|event| event.is_release())
+    }
+
+    /// Was the button given pressed this frame?
+    pub fn button_pressed(&self, button: PointerButton) -> bool {
+        self.pointer_events
+            .iter()
+            .any(|event| matches!(event, &PointerEvent::Pressed{button: b, ..} if button == b))
+    }
+
+    /// Was the button given released this frame?
+    pub fn button_released(&self, button: PointerButton) -> bool {
+        self.pointer_events
+            .iter()
+            .any(|event| matches!(event, &PointerEvent::Released{button: b, ..} if button == b))
+    }
+
+    /// Was the primary button pressed this frame?
+    pub fn primary_pressed(&self) -> bool {
+        self.button_pressed(PointerButton::Primary)
+    }
+
+    /// Was the secondary button pressed this frame?
+    pub fn secondary_pressed(&self) -> bool {
+        self.button_pressed(PointerButton::Secondary)
+    }
+
+    /// Was the primary button released this frame?
+    pub fn primary_released(&self) -> bool {
+        self.button_released(PointerButton::Primary)
+    }
+
+    /// Was the secondary button released this frame?
+    pub fn secondary_released(&self) -> bool {
+        self.button_released(PointerButton::Secondary)
+    }
+
+    /// Is any pointer button currently down?
+    pub fn any_down(&self) -> bool {
+        self.down.iter().any(|&down| down)
+    }
+
+    /// Were there any type of click this frame?
+    pub fn any_click(&self) -> bool {
+        self.pointer_events.iter().any(|event| event.is_click())
+    }
+
+    /// Was the button given clicked this frame?
+    pub fn button_clicked(&self, button: PointerButton) -> bool {
+        self.pointer_events
+            .iter()
+            .any(|event| matches!(event, &PointerEvent::Pressed { button: b, .. } if button == b))
+    }
+
+    /// Was the button given double clicked this frame?
+    pub fn button_double_clicked(&self, button: PointerButton) -> bool {
+        self.pointer_events.iter().any(|event| {
+            matches!(
+                &event,
+                PointerEvent::Released {
+                    click: Some(click),
+                    button: b,
+                } if *b == button && click.is_double()
+            )
+        })
+    }
+
+    /// Was the button given triple clicked this frame?
+    pub fn button_triple_clicked(&self, button: PointerButton) -> bool {
+        self.pointer_events.iter().any(|event| {
+            matches!(
+                &event,
+                PointerEvent::Released {
+                    click: Some(click),
+                    button: b,
+                } if *b == button && click.is_triple()
+            )
+        })
+    }
+
+    /// Was the primary button clicked this frame?
+    pub fn primary_clicked(&self) -> bool {
+        self.button_clicked(PointerButton::Primary)
+    }
+
+    /// Was the secondary button clicked this frame?
+    pub fn secondary_clicked(&self) -> bool {
+        self.button_clicked(PointerButton::Secondary)
+    }
+
+    /// Is this button currently down?
+    #[inline(always)]
+    pub fn button_down(&self, button: PointerButton) -> bool {
+        self.down[button as usize]
+    }
+
+    /// If the pointer button is down, will it register as a click when released?
+    #[inline(always)]
+    pub(crate) fn could_any_button_be_click(&self) -> bool {
+        if !self.any_down() {
+            return false;
+        }
+
+        if self.has_moved_too_much_for_a_click {
+            return false;
+        }
+
+        if let Some(press_start_time) = self.press_start_time {
+            if self.time - press_start_time > MAX_CLICK_DURATION {
+                return false;
+            }
+        }
+
+        true
+    }
+
+    /// Is the primary button currently down?
+    #[inline(always)]
+    pub fn primary_down(&self) -> bool {
+        self.button_down(PointerButton::Primary)
+    }
+
+    /// Is the secondary button currently down?
+    #[inline(always)]
+    pub fn secondary_down(&self) -> bool {
+        self.button_down(PointerButton::Secondary)
+    }
+
+    /// Is the middle button currently down?
+    #[inline(always)]
+    pub fn middle_down(&self) -> bool {
+        self.button_down(PointerButton::Middle)
+    }
+}
+
+impl InputState {
+    pub fn ui(&self, ui: &mut crate::Ui) {
+        let Self {
+            raw,
+            pointer,
+            touch_states,
+            scroll_delta,
+            zoom_factor_delta,
+            screen_rect,
+            pixels_per_point,
+            max_texture_side,
+            time,
+            unstable_dt,
+            predicted_dt,
+            stable_dt,
+            modifiers,
+            keys_down,
+            events,
+        } = self;
+
+        ui.style_mut()
+            .text_styles
+            .get_mut(&crate::TextStyle::Body)
+            .unwrap()
+            .family = crate::FontFamily::Monospace;
+
+        ui.collapsing("Raw Input", |ui| raw.ui(ui));
+
+        crate::containers::CollapsingHeader::new("🖱 Pointer")
+            .default_open(true)
+            .show(ui, |ui| {
+                pointer.ui(ui);
+            });
+
+        for (device_id, touch_state) in touch_states {
+            ui.collapsing(format!("Touch State [device {}]", device_id.0), |ui| {
+                touch_state.ui(ui);
+            });
+        }
+
+        ui.label(format!("scroll_delta: {:?} points", scroll_delta));
+        ui.label(format!("zoom_factor_delta: {:4.2}x", zoom_factor_delta));
+        ui.label(format!("screen_rect: {:?} points", screen_rect));
+        ui.label(format!(
+            "{} physical pixels for each logical point",
+            pixels_per_point
+        ));
+        ui.label(format!(
+            "max texture size (on each side): {}",
+            max_texture_side
+        ));
+        ui.label(format!("time: {:.3} s", time));
+        ui.label(format!(
+            "time since previous frame: {:.1} ms",
+            1e3 * unstable_dt
+        ));
+        ui.label(format!("predicted_dt: {:.1} ms", 1e3 * predicted_dt));
+        ui.label(format!("stable_dt:    {:.1} ms", 1e3 * stable_dt));
+        ui.label(format!("modifiers: {:#?}", modifiers));
+        ui.label(format!("keys_down: {:?}", keys_down));
+        ui.scope(|ui| {
+            ui.set_min_height(150.0);
+            ui.label(format!("events: {:#?}", events))
+                .on_hover_text("key presses etc");
+        });
+    }
+}
+
+impl PointerState {
+    pub fn ui(&self, ui: &mut crate::Ui) {
+        let Self {
+            time: _,
+            latest_pos,
+            interact_pos,
+            delta,
+            velocity,
+            pos_history: _,
+            down,
+            press_origin,
+            press_start_time,
+            has_moved_too_much_for_a_click,
+            last_click_time,
+            last_last_click_time,
+            pointer_events,
+        } = self;
+
+        ui.label(format!("latest_pos: {:?}", latest_pos));
+        ui.label(format!("interact_pos: {:?}", interact_pos));
+        ui.label(format!("delta: {:?}", delta));
+        ui.label(format!(
+            "velocity: [{:3.0} {:3.0}] points/sec",
+            velocity.x, velocity.y
+        ));
+        ui.label(format!("down: {:#?}", down));
+        ui.label(format!("press_origin: {:?}", press_origin));
+        ui.label(format!("press_start_time: {:?} s", press_start_time));
+        ui.label(format!(
+            "has_moved_too_much_for_a_click: {}",
+            has_moved_too_much_for_a_click
+        ));
+        ui.label(format!("last_click_time: {:#?}", last_click_time));
+        ui.label(format!("last_last_click_time: {:#?}", last_last_click_time));
+        ui.label(format!("pointer_events: {:?}", pointer_events));
+    }
+}
diff --git a/egui/crates/egui/src/input_state/touch_state.rs b/egui/crates/egui/src/input_state/touch_state.rs
new file mode 100644
index 0000000..becd0d5
--- /dev/null
+++ b/egui/crates/egui/src/input_state/touch_state.rs
@@ -0,0 +1,339 @@
+use std::{collections::BTreeMap, fmt::Debug};
+
+use crate::{
+    data::input::TouchDeviceId,
+    emath::{normalized_angle, Pos2, Vec2},
+    Event, RawInput, TouchId, TouchPhase,
+};
+
+/// All you probably need to know about a multi-touch gesture.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct MultiTouchInfo {
+    /// Point in time when the gesture started.
+    pub start_time: f64,
+
+    /// Position of the pointer at the time the gesture started.
+    pub start_pos: Pos2,
+
+    /// Number of touches (fingers) on the surface. Value is ≥ 2 since for a single touch no
+    /// [`MultiTouchInfo`] is created.
+    pub num_touches: usize,
+
+    /// Proportional zoom factor (pinch gesture).
+    /// * `zoom = 1`: no change
+    /// * `zoom < 1`: pinch together
+    /// * `zoom > 1`: pinch spread
+    pub zoom_delta: f32,
+
+    /// 2D non-proportional zoom factor (pinch gesture).
+    ///
+    /// For horizontal pinches, this will return `[z, 1]`,
+    /// for vertical pinches this will return `[1, z]`,
+    /// and otherwise this will return `[z, z]`,
+    /// where `z` is the zoom factor:
+    /// * `zoom = 1`: no change
+    /// * `zoom < 1`: pinch together
+    /// * `zoom > 1`: pinch spread
+    pub zoom_delta_2d: Vec2,
+
+    /// Rotation in radians. Moving fingers around each other will change this value. This is a
+    /// relative value, comparing the orientation of fingers in the current frame with the previous
+    /// frame. If all fingers are resting, this value is `0.0`.
+    pub rotation_delta: f32,
+
+    /// Relative movement (comparing previous frame and current frame) of the average position of
+    /// all touch points. Without movement this value is `Vec2::ZERO`.
+    ///
+    /// Note that this may not necessarily be measured in screen points (although it _will_ be for
+    /// most mobile devices). In general (depending on the touch device), touch coordinates cannot
+    /// be directly mapped to the screen. A touch always is considered to start at the position of
+    /// the pointer, but touch movement is always measured in the units delivered by the device,
+    /// and may depend on hardware and system settings.
+    pub translation_delta: Vec2,
+
+    /// Current force of the touch (average of the forces of the individual fingers). This is a
+    /// value in the interval `[0.0 .. =1.0]`.
+    ///
+    /// Note 1: A value of `0.0` either indicates a very light touch, or it means that the device
+    /// is not capable of measuring the touch force at all.
+    ///
+    /// Note 2: Just increasing the physical pressure without actually moving the finger may not
+    /// necessarily lead to a change of this value.
+    pub force: f32,
+}
+
+/// The current state (for a specific touch device) of touch events and gestures.
+#[derive(Clone)]
+pub(crate) struct TouchState {
+    /// Technical identifier of the touch device. This is used to identify relevant touch events
+    /// for this [`TouchState`] instance.
+    device_id: TouchDeviceId,
+
+    /// Active touches, if any.
+    ///
+    /// TouchId is the unique identifier of the touch. It is valid as long as the finger/pen touches the surface. The
+    /// next touch will receive a new unique ID.
+    ///
+    /// Refer to [`ActiveTouch`].
+    active_touches: BTreeMap<TouchId, ActiveTouch>,
+
+    /// If a gesture has been recognized (i.e. when exactly two fingers touch the surface), this
+    /// holds state information
+    gesture_state: Option<GestureState>,
+}
+
+#[derive(Clone, Debug)]
+struct GestureState {
+    start_time: f64,
+    start_pointer_pos: Pos2,
+    pinch_type: PinchType,
+    previous: Option<DynGestureState>,
+    current: DynGestureState,
+}
+
+/// Gesture data that can change over time
+#[derive(Clone, Copy, Debug)]
+struct DynGestureState {
+    /// used for proportional zooming
+    avg_distance: f32,
+
+    /// used for non-proportional zooming
+    avg_abs_distance2: Vec2,
+
+    avg_pos: Pos2,
+
+    avg_force: f32,
+
+    heading: f32,
+}
+
+/// Describes an individual touch (finger or digitizer) on the touch surface. Instances exist as
+/// long as the finger/pen touches the surface.
+#[derive(Clone, Copy, Debug)]
+struct ActiveTouch {
+    /// Current position of this touch, in device coordinates (not necessarily screen position)
+    pos: Pos2,
+
+    /// Current force of the touch. A value in the interval [0.0 .. 1.0]
+    ///
+    /// Note that a value of 0.0 either indicates a very light touch, or it means that the device
+    /// is not capable of measuring the touch force.
+    force: f32,
+}
+
+impl TouchState {
+    pub fn new(device_id: TouchDeviceId) -> Self {
+        Self {
+            device_id,
+            active_touches: Default::default(),
+            gesture_state: None,
+        }
+    }
+
+    pub fn begin_frame(&mut self, time: f64, new: &RawInput, pointer_pos: Option<Pos2>) {
+        let mut added_or_removed_touches = false;
+        for event in &new.events {
+            match *event {
+                Event::Touch {
+                    device_id,
+                    id,
+                    phase,
+                    pos,
+                    force,
+                } if device_id == self.device_id => match phase {
+                    TouchPhase::Start => {
+                        self.active_touches.insert(id, ActiveTouch { pos, force });
+                        added_or_removed_touches = true;
+                    }
+                    TouchPhase::Move => {
+                        if let Some(touch) = self.active_touches.get_mut(&id) {
+                            touch.pos = pos;
+                            touch.force = force;
+                        }
+                    }
+                    TouchPhase::End | TouchPhase::Cancel => {
+                        self.active_touches.remove(&id);
+                        added_or_removed_touches = true;
+                    }
+                },
+                _ => (),
+            }
+        }
+        // This needs to be called each frame, even if there are no new touch events.
+        // Otherwise, we would send the same old delta information multiple times:
+        self.update_gesture(time, pointer_pos);
+
+        if added_or_removed_touches {
+            // Adding or removing fingers makes the average values "jump". We better forget
+            // about the previous values, and don't create delta information for this frame:
+            if let Some(ref mut state) = &mut self.gesture_state {
+                state.previous = None;
+            }
+        }
+    }
+
+    pub fn is_active(&self) -> bool {
+        self.gesture_state.is_some()
+    }
+
+    pub fn info(&self) -> Option<MultiTouchInfo> {
+        self.gesture_state.as_ref().map(|state| {
+            // state.previous can be `None` when the number of simultaneous touches has just
+            // changed. In this case, we take `current` as `previous`, pretending that there
+            // was no change for the current frame.
+            let state_previous = state.previous.unwrap_or(state.current);
+
+            let zoom_delta = state.current.avg_distance / state_previous.avg_distance;
+
+            let zoom_delta2 = match state.pinch_type {
+                PinchType::Horizontal => Vec2::new(
+                    state.current.avg_abs_distance2.x / state_previous.avg_abs_distance2.x,
+                    1.0,
+                ),
+                PinchType::Vertical => Vec2::new(
+                    1.0,
+                    state.current.avg_abs_distance2.y / state_previous.avg_abs_distance2.y,
+                ),
+                PinchType::Proportional => Vec2::splat(zoom_delta),
+            };
+
+            MultiTouchInfo {
+                start_time: state.start_time,
+                start_pos: state.start_pointer_pos,
+                num_touches: self.active_touches.len(),
+                zoom_delta,
+                zoom_delta_2d: zoom_delta2,
+                rotation_delta: normalized_angle(state.current.heading - state_previous.heading),
+                translation_delta: state.current.avg_pos - state_previous.avg_pos,
+                force: state.current.avg_force,
+            }
+        })
+    }
+
+    fn update_gesture(&mut self, time: f64, pointer_pos: Option<Pos2>) {
+        if let Some(dyn_state) = self.calc_dynamic_state() {
+            if let Some(ref mut state) = &mut self.gesture_state {
+                // updating an ongoing gesture
+                state.previous = Some(state.current);
+                state.current = dyn_state;
+            } else if let Some(pointer_pos) = pointer_pos {
+                // starting a new gesture
+                self.gesture_state = Some(GestureState {
+                    start_time: time,
+                    start_pointer_pos: pointer_pos,
+                    pinch_type: PinchType::classify(&self.active_touches),
+                    previous: None,
+                    current: dyn_state,
+                });
+            }
+        } else {
+            // the end of a gesture (if there is any)
+            self.gesture_state = None;
+        }
+    }
+
+    /// `None` if less than two fingers
+    fn calc_dynamic_state(&self) -> Option<DynGestureState> {
+        let num_touches = self.active_touches.len();
+        if num_touches < 2 {
+            None
+        } else {
+            let mut state = DynGestureState {
+                avg_distance: 0.0,
+                avg_abs_distance2: Vec2::ZERO,
+                avg_pos: Pos2::ZERO,
+                avg_force: 0.0,
+                heading: 0.0,
+            };
+            let num_touches_recip = 1. / num_touches as f32;
+
+            // first pass: calculate force and center of touch positions:
+            for touch in self.active_touches.values() {
+                state.avg_force += touch.force;
+                state.avg_pos.x += touch.pos.x;
+                state.avg_pos.y += touch.pos.y;
+            }
+            state.avg_force *= num_touches_recip;
+            state.avg_pos.x *= num_touches_recip;
+            state.avg_pos.y *= num_touches_recip;
+
+            // second pass: calculate distances from center:
+            for touch in self.active_touches.values() {
+                state.avg_distance += state.avg_pos.distance(touch.pos);
+                state.avg_abs_distance2.x += (state.avg_pos.x - touch.pos.x).abs();
+                state.avg_abs_distance2.y += (state.avg_pos.y - touch.pos.y).abs();
+            }
+            state.avg_distance *= num_touches_recip;
+            state.avg_abs_distance2 *= num_touches_recip;
+
+            // Calculate the direction from the first touch to the center position.
+            // This is not the perfect way of calculating the direction if more than two fingers
+            // are involved, but as long as all fingers rotate more or less at the same angular
+            // velocity, the shortcomings of this method will not be noticed. One can see the
+            // issues though, when touching with three or more fingers, and moving only one of them
+            // (it takes two hands to do this in a controlled manner). A better technique would be
+            // to store the current and previous directions (with reference to the center) for each
+            // touch individually, and then calculate the average of all individual changes in
+            // direction. But this approach cannot be implemented locally in this method, making
+            // everything a bit more complicated.
+            let first_touch = self.active_touches.values().next().unwrap();
+            state.heading = (state.avg_pos - first_touch.pos).angle();
+
+            Some(state)
+        }
+    }
+}
+
+impl TouchState {
+    pub fn ui(&self, ui: &mut crate::Ui) {
+        ui.label(format!("{:?}", self));
+    }
+}
+
+impl Debug for TouchState {
+    // This outputs less clutter than `#[derive(Debug)]`:
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (id, touch) in &self.active_touches {
+            f.write_fmt(format_args!("#{:?}: {:#?}\n", id, touch))?;
+        }
+        f.write_fmt(format_args!("gesture: {:#?}\n", self.gesture_state))?;
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+enum PinchType {
+    Horizontal,
+    Vertical,
+    Proportional,
+}
+
+impl PinchType {
+    fn classify(touches: &BTreeMap<TouchId, ActiveTouch>) -> Self {
+        // For non-proportional 2d zooming:
+        // If the user is pinching with two fingers that have roughly the same Y coord,
+        // then the Y zoom is unstable and should be 1.
+        // Similarly, if the fingers are directly above/below each other,
+        // we should only zoom on the Y axis.
+        // If the fingers are roughly on a diagonal, we revert to the proportional zooming.
+
+        if touches.len() == 2 {
+            let mut touches = touches.values();
+            let t0 = touches.next().unwrap().pos;
+            let t1 = touches.next().unwrap().pos;
+
+            let dx = (t0.x - t1.x).abs();
+            let dy = (t0.y - t1.y).abs();
+
+            if dx > 3.0 * dy {
+                Self::Horizontal
+            } else if dy > 3.0 * dx {
+                Self::Vertical
+            } else {
+                Self::Proportional
+            }
+        } else {
+            Self::Proportional
+        }
+    }
+}
diff --git a/egui/crates/egui/src/introspection.rs b/egui/crates/egui/src/introspection.rs
new file mode 100644
index 0000000..ae66cdd
--- /dev/null
+++ b/egui/crates/egui/src/introspection.rs
@@ -0,0 +1,198 @@
+//! Showing UI:s for egui/epaint types.
+use crate::*;
+
+pub fn font_family_ui(ui: &mut Ui, font_family: &mut FontFamily) {
+    let families = ui.fonts(|f| f.families());
+    ui.horizontal(|ui| {
+        for alternative in families {
+            let text = alternative.to_string();
+            ui.radio_value(font_family, alternative, text);
+        }
+    });
+}
+
+pub fn font_id_ui(ui: &mut Ui, font_id: &mut FontId) {
+    let families = ui.fonts(|f| f.families());
+    ui.horizontal(|ui| {
+        ui.add(Slider::new(&mut font_id.size, 4.0..=40.0).max_decimals(1));
+        for alternative in families {
+            let text = alternative.to_string();
+            ui.radio_value(&mut font_id.family, alternative, text);
+        }
+    });
+}
+
+// Show font texture in demo Ui
+pub(crate) fn font_texture_ui(ui: &mut Ui, [width, height]: [usize; 2]) -> Response {
+    ui.vertical(|ui| {
+        let color = if ui.visuals().dark_mode {
+            Color32::WHITE
+        } else {
+            Color32::BLACK
+        };
+
+        ui.label(format!(
+            "Texture size: {} x {} (hover to zoom)",
+            width, height
+        ));
+        if width <= 1 || height <= 1 {
+            return;
+        }
+        let mut size = vec2(width as f32, height as f32);
+        if size.x > ui.available_width() {
+            size *= ui.available_width() / size.x;
+        }
+        let (rect, response) = ui.allocate_at_least(size, Sense::hover());
+        let mut mesh = Mesh::default();
+        mesh.add_rect_with_uv(rect, [pos2(0.0, 0.0), pos2(1.0, 1.0)].into(), color);
+        ui.painter().add(Shape::mesh(mesh));
+
+        let (tex_w, tex_h) = (width as f32, height as f32);
+
+        response
+            .on_hover_cursor(CursorIcon::ZoomIn)
+            .on_hover_ui_at_pointer(|ui| {
+                if let Some(pos) = ui.ctx().pointer_latest_pos() {
+                    let (_id, zoom_rect) = ui.allocate_space(vec2(128.0, 128.0));
+                    let u = remap_clamp(pos.x, rect.x_range(), 0.0..=tex_w);
+                    let v = remap_clamp(pos.y, rect.y_range(), 0.0..=tex_h);
+
+                    let texel_radius = 32.0;
+                    let u = u.at_least(texel_radius).at_most(tex_w - texel_radius);
+                    let v = v.at_least(texel_radius).at_most(tex_h - texel_radius);
+
+                    let uv_rect = Rect::from_min_max(
+                        pos2((u - texel_radius) / tex_w, (v - texel_radius) / tex_h),
+                        pos2((u + texel_radius) / tex_w, (v + texel_radius) / tex_h),
+                    );
+                    let mut mesh = Mesh::default();
+                    mesh.add_rect_with_uv(zoom_rect, uv_rect, color);
+                    ui.painter().add(Shape::mesh(mesh));
+                }
+            });
+    })
+    .response
+}
+
+impl Widget for &epaint::stats::PaintStats {
+    fn ui(self, ui: &mut Ui) -> Response {
+        ui.vertical(|ui| {
+            ui.label(
+                "egui generates intermediate level shapes like circles and text. \
+                These are later tessellated into triangles.",
+            );
+            ui.add_space(10.0);
+
+            ui.style_mut().override_text_style = Some(TextStyle::Monospace);
+
+            let epaint::stats::PaintStats {
+                shapes,
+                shape_text,
+                shape_path,
+                shape_mesh,
+                shape_vec,
+                num_callbacks,
+                text_shape_vertices,
+                text_shape_indices,
+                clipped_primitives,
+                vertices,
+                indices,
+            } = self;
+
+            ui.label("Intermediate:");
+            label(ui, shapes, "shapes").on_hover_text("Boxes, circles, etc");
+            ui.horizontal(|ui| {
+                label(ui, shape_text, "text");
+                ui.small("(mostly cached)");
+            });
+            label(ui, shape_path, "paths");
+            label(ui, shape_mesh, "nested meshes");
+            label(ui, shape_vec, "nested shapes");
+            ui.label(format!("{:6} callbacks", num_callbacks));
+            ui.add_space(10.0);
+
+            ui.label("Text shapes:");
+            label(ui, text_shape_vertices, "vertices");
+            label(ui, text_shape_indices, "indices")
+                .on_hover_text("Three 32-bit indices per triangles");
+            ui.add_space(10.0);
+
+            ui.label("Tessellated (and culled):");
+            label(ui, clipped_primitives, "primitives lists")
+                .on_hover_text("Number of separate clip rectangles");
+            label(ui, vertices, "vertices");
+            label(ui, indices, "indices").on_hover_text("Three 32-bit indices per triangles");
+            ui.add_space(10.0);
+
+            // ui.label("Total:");
+            // ui.label(self.total().format(""));
+        })
+        .response
+    }
+}
+
+fn label(ui: &mut Ui, alloc_info: &epaint::stats::AllocInfo, what: &str) -> Response {
+    ui.add(Label::new(alloc_info.format(what)).wrap(false))
+}
+
+impl Widget for &mut epaint::TessellationOptions {
+    fn ui(self, ui: &mut Ui) -> Response {
+        ui.vertical(|ui| {
+            let epaint::TessellationOptions {
+                feathering,
+                feathering_size_in_pixels,
+                coarse_tessellation_culling,
+                prerasterized_discs,
+                round_text_to_pixels,
+                debug_paint_clip_rects,
+                debug_paint_text_rects,
+                debug_ignore_clip_rects,
+                bezier_tolerance,
+                epsilon: _,
+            } = self;
+
+            ui.checkbox(feathering, "Feathering (antialias)")
+                .on_hover_text("Apply feathering to smooth out the edges of shapes. Turn off for small performance gain.");
+            let feathering_slider = crate::Slider::new(feathering_size_in_pixels, 0.0..=10.0)
+                .smallest_positive(0.1)
+                .logarithmic(true)
+                .text("Feathering size in pixels");
+            ui.add_enabled(*feathering, feathering_slider);
+
+            ui.checkbox(prerasterized_discs, "Speed up filled circles with pre-rasterization");
+
+            ui.add(
+                crate::widgets::Slider::new(bezier_tolerance, 0.0001..=10.0)
+                    .logarithmic(true)
+                    .show_value(true)
+                    .text("Spline Tolerance"),
+            );
+            ui.collapsing("debug", |ui| {
+                ui.checkbox(
+                    coarse_tessellation_culling,
+                    "Do coarse culling in the tessellator",
+                );
+                ui.checkbox(round_text_to_pixels, "Align text positions to pixel grid")
+                    .on_hover_text("Most text already is, so don't expect to see a large change.");
+
+                ui.checkbox(debug_ignore_clip_rects, "Ignore clip rectangles");
+                ui.checkbox(debug_paint_clip_rects, "Paint clip rectangles");
+                ui.checkbox(debug_paint_text_rects, "Paint text bounds");
+            });
+        })
+        .response
+    }
+}
+
+impl Widget for &memory::Interaction {
+    fn ui(self, ui: &mut Ui) -> Response {
+        ui.vertical(|ui| {
+            ui.label(format!("click_id: {:?}", self.click_id));
+            ui.label(format!("drag_id: {:?}", self.drag_id));
+            ui.label(format!("drag_is_window: {:?}", self.drag_is_window));
+            ui.label(format!("click_interest: {:?}", self.click_interest));
+            ui.label(format!("drag_interest: {:?}", self.drag_interest));
+        })
+        .response
+    }
+}
diff --git a/egui/crates/egui/src/layers.rs b/egui/crates/egui/src/layers.rs
new file mode 100644
index 0000000..9e951f0
--- /dev/null
+++ b/egui/crates/egui/src/layers.rs
@@ -0,0 +1,201 @@
+//! Handles paint layers, i.e. how things
+//! are sometimes painted behind or in front of other things.
+
+use crate::{Id, *};
+use epaint::{ClippedShape, Shape};
+
+/// Different layer categories
+#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum Order {
+    /// Painted behind all floating windows
+    Background,
+
+    /// Special layer between panels and windows
+    PanelResizeLine,
+
+    /// Normal moveable windows that you reorder by click
+    Middle,
+
+    /// Popups, menus etc that should always be painted on top of windows
+    /// Foreground objects can also have tooltips
+    Foreground,
+
+    /// Things floating on top of everything else, like tooltips.
+    /// You cannot interact with these.
+    Tooltip,
+
+    /// Debug layer, always painted last / on top
+    Debug,
+}
+
+impl Order {
+    const COUNT: usize = 6;
+    const ALL: [Order; Self::COUNT] = [
+        Self::Background,
+        Self::PanelResizeLine,
+        Self::Middle,
+        Self::Foreground,
+        Self::Tooltip,
+        Self::Debug,
+    ];
+    pub const TOP: Self = Self::Debug;
+
+    #[inline(always)]
+    pub fn allow_interaction(&self) -> bool {
+        match self {
+            Self::Background
+            | Self::PanelResizeLine
+            | Self::Middle
+            | Self::Foreground
+            | Self::Debug => true,
+            Self::Tooltip => false,
+        }
+    }
+
+    /// Short and readable summary
+    pub fn short_debug_format(&self) -> &'static str {
+        match self {
+            Self::Background => "backg",
+            Self::PanelResizeLine => "panel",
+            Self::Middle => "middl",
+            Self::Foreground => "foreg",
+            Self::Tooltip => "toolt",
+            Self::Debug => "debug",
+        }
+    }
+}
+
+/// An identifier for a paint layer.
+/// Also acts as an identifier for [`Area`]:s.
+#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct LayerId {
+    pub order: Order,
+    pub id: Id,
+}
+
+impl LayerId {
+    pub fn new(order: Order, id: Id) -> Self {
+        Self { order, id }
+    }
+
+    pub fn debug() -> Self {
+        Self {
+            order: Order::Debug,
+            id: Id::new("debug"),
+        }
+    }
+
+    pub fn background() -> Self {
+        Self {
+            order: Order::Background,
+            id: Id::background(),
+        }
+    }
+
+    #[inline(always)]
+    pub fn allow_interaction(&self) -> bool {
+        self.order.allow_interaction()
+    }
+
+    /// Short and readable summary
+    pub fn short_debug_format(&self) -> String {
+        format!(
+            "{} {}",
+            self.order.short_debug_format(),
+            self.id.short_debug_format()
+        )
+    }
+}
+
+/// A unique identifier of a specific [`Shape`] in a [`PaintList`].
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct ShapeIdx(usize);
+
+/// A list of [`Shape`]s paired with a clip rectangle.
+#[derive(Clone, Default)]
+pub struct PaintList(Vec<ClippedShape>);
+
+impl PaintList {
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Returns the index of the new [`Shape`] that can be used with `PaintList::set`.
+    #[inline(always)]
+    pub fn add(&mut self, clip_rect: Rect, shape: Shape) -> ShapeIdx {
+        let idx = ShapeIdx(self.0.len());
+        self.0.push(ClippedShape(clip_rect, shape));
+        idx
+    }
+
+    pub fn extend<I: IntoIterator<Item = Shape>>(&mut self, clip_rect: Rect, shapes: I) {
+        self.0.extend(
+            shapes
+                .into_iter()
+                .map(|shape| ClippedShape(clip_rect, shape)),
+        );
+    }
+
+    /// Modify an existing [`Shape`].
+    ///
+    /// Sometimes you want to paint a frame behind some contents, but don't know how large the frame needs to be
+    /// until the contents have been added, and therefor also painted to the [`PaintList`].
+    ///
+    /// The solution is to allocate a [`Shape`] using `let idx = paint_list.add(cr, Shape::Noop);`
+    /// and then later setting it using `paint_list.set(idx, cr, frame);`.
+    #[inline(always)]
+    pub fn set(&mut self, idx: ShapeIdx, clip_rect: Rect, shape: Shape) {
+        self.0[idx.0] = ClippedShape(clip_rect, shape);
+    }
+
+    /// Translate each [`Shape`] and clip rectangle by this much, in-place
+    pub fn translate(&mut self, delta: Vec2) {
+        for ClippedShape(clip_rect, shape) in &mut self.0 {
+            *clip_rect = clip_rect.translate(delta);
+            shape.translate(delta);
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub(crate) struct GraphicLayers([IdMap<PaintList>; Order::COUNT]);
+
+impl GraphicLayers {
+    pub fn list(&mut self, layer_id: LayerId) -> &mut PaintList {
+        self.0[layer_id.order as usize]
+            .entry(layer_id.id)
+            .or_default()
+    }
+
+    pub fn drain(&mut self, area_order: &[LayerId]) -> impl ExactSizeIterator<Item = ClippedShape> {
+        let mut all_shapes: Vec<_> = Default::default();
+
+        for &order in &Order::ALL {
+            let order_map = &mut self.0[order as usize];
+
+            // If a layer is empty at the start of the frame
+            // then nobody has added to it, and it is old and defunct.
+            // Free it to save memory:
+            order_map.retain(|_, list| !list.is_empty());
+
+            // First do the layers part of area_order:
+            for layer_id in area_order {
+                if layer_id.order == order {
+                    if let Some(list) = order_map.get_mut(&layer_id.id) {
+                        all_shapes.append(&mut list.0);
+                    }
+                }
+            }
+
+            // Also draw areas that are missing in `area_order`:
+            for shapes in order_map.values_mut() {
+                all_shapes.append(&mut shapes.0);
+            }
+        }
+
+        all_shapes.into_iter()
+    }
+}
diff --git a/egui/crates/egui/src/layout.rs b/egui/crates/egui/src/layout.rs
new file mode 100644
index 0000000..8da2370
--- /dev/null
+++ b/egui/crates/egui/src/layout.rs
@@ -0,0 +1,841 @@
+use crate::{egui_assert, emath::*, Align};
+use std::f32::INFINITY;
+
+// ----------------------------------------------------------------------------
+
+/// This describes the bounds and existing contents of an [`Ui`][`crate::Ui`].
+/// It is what is used and updated by [`Layout`] when adding new widgets.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Region {
+    /// This is the minimal size of the [`Ui`](crate::Ui).
+    /// When adding new widgets, this will generally expand.
+    ///
+    /// Always finite.
+    ///
+    /// The bounding box of all child widgets, but not necessarily a tight bounding box
+    /// since [`Ui`](crate::Ui) can start with a non-zero min_rect size.
+    pub min_rect: Rect,
+
+    /// The maximum size of this [`Ui`](crate::Ui). This is a *soft max*
+    /// meaning new widgets will *try* not to expand beyond it,
+    /// but if they have to, they will.
+    ///
+    /// Text will wrap at `max_rect.right()`.
+    /// Some widgets (like separator lines) will try to fill the full `max_rect` width of the ui.
+    ///
+    /// `max_rect` will always be at least the size of `min_rect`.
+    ///
+    /// If the `max_rect` size is zero, it is a signal that child widgets should be as small as possible.
+    /// If the `max_rect` size is infinite, it is a signal that child widgets should take up as much room as they want.
+    pub max_rect: Rect,
+
+    /// Where the next widget will be put.
+    ///
+    /// One side of this will always be infinite: the direction in which new widgets will be added.
+    /// The opposing side is what is incremented.
+    /// The crossing sides are initialized to `max_rect`.
+    ///
+    /// So one can think of `cursor` as a constraint on the available region.
+    ///
+    /// If something has already been added, this will point to `style.spacing.item_spacing` beyond the latest child.
+    /// The cursor can thus be `style.spacing.item_spacing` pixels outside of the min_rect.
+    pub(crate) cursor: Rect,
+}
+
+impl Region {
+    /// Expand the `min_rect` and `max_rect` of this ui to include a child at the given rect.
+    pub fn expand_to_include_rect(&mut self, rect: Rect) {
+        self.min_rect = self.min_rect.union(rect);
+        self.max_rect = self.max_rect.union(rect);
+    }
+
+    /// Ensure we are big enough to contain the given X-coordinate.
+    /// This is sometimes useful to expand an ui to stretch to a certain place.
+    pub fn expand_to_include_x(&mut self, x: f32) {
+        self.min_rect.extend_with_x(x);
+        self.max_rect.extend_with_x(x);
+        self.cursor.extend_with_x(x);
+    }
+
+    /// Ensure we are big enough to contain the given Y-coordinate.
+    /// This is sometimes useful to expand an ui to stretch to a certain place.
+    pub fn expand_to_include_y(&mut self, y: f32) {
+        self.min_rect.extend_with_y(y);
+        self.max_rect.extend_with_y(y);
+        self.cursor.extend_with_y(y);
+    }
+
+    pub fn sanity_check(&self) {
+        egui_assert!(!self.min_rect.any_nan());
+        egui_assert!(!self.max_rect.any_nan());
+        egui_assert!(!self.cursor.any_nan());
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Layout direction, one of [`LeftToRight`](Direction::LeftToRight), [`RightToLeft`](Direction::RightToLeft), [`TopDown`](Direction::TopDown), [`BottomUp`](Direction::BottomUp).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum Direction {
+    LeftToRight,
+    RightToLeft,
+    TopDown,
+    BottomUp,
+}
+
+impl Direction {
+    #[inline(always)]
+    pub fn is_horizontal(self) -> bool {
+        match self {
+            Direction::LeftToRight | Direction::RightToLeft => true,
+            Direction::TopDown | Direction::BottomUp => false,
+        }
+    }
+
+    #[inline(always)]
+    pub fn is_vertical(self) -> bool {
+        match self {
+            Direction::LeftToRight | Direction::RightToLeft => false,
+            Direction::TopDown | Direction::BottomUp => true,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// The layout of a [`Ui`][`crate::Ui`], e.g. "vertical & centered".
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+///     ui.label("world!");
+///     ui.label("Hello");
+/// });
+/// # });
+/// ```
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+// #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Layout {
+    /// Main axis direction
+    pub main_dir: Direction,
+
+    /// If true, wrap around when reading the end of the main direction.
+    /// For instance, for `main_dir == Direction::LeftToRight` this will
+    /// wrap to a new row when we reach the right side of the `max_rect`.
+    pub main_wrap: bool,
+
+    /// How to align things on the main axis.
+    pub main_align: Align,
+
+    /// Justify the main axis?
+    pub main_justify: bool,
+
+    /// How to align things on the cross axis.
+    /// For vertical layouts: put things to left, center or right?
+    /// For horizontal layouts: put things to top, center or bottom?
+    pub cross_align: Align,
+
+    /// Justify the cross axis?
+    /// For vertical layouts justify mean all widgets get maximum width.
+    /// For horizontal layouts justify mean all widgets get maximum height.
+    pub cross_justify: bool,
+}
+
+impl Default for Layout {
+    fn default() -> Self {
+        // TODO(emilk): Get from `Style` instead.
+        Self::top_down(Align::LEFT) // This is a very euro-centric default.
+    }
+}
+
+/// ## Constructors
+impl Layout {
+    /// Place elements horizontally, left to right.
+    ///
+    /// The `valign` parameter controls how to align elements vertically.
+    #[inline(always)]
+    pub fn left_to_right(valign: Align) -> Self {
+        Self {
+            main_dir: Direction::LeftToRight,
+            main_wrap: false,
+            main_align: Align::Center, // looks best to e.g. center text within a button
+            main_justify: false,
+            cross_align: valign,
+            cross_justify: false,
+        }
+    }
+
+    /// Place elements horizontally, right to left.
+    ///
+    /// The `valign` parameter controls how to align elements vertically.
+    #[inline(always)]
+    pub fn right_to_left(valign: Align) -> Self {
+        Self {
+            main_dir: Direction::RightToLeft,
+            main_wrap: false,
+            main_align: Align::Center, // looks best to e.g. center text within a button
+            main_justify: false,
+            cross_align: valign,
+            cross_justify: false,
+        }
+    }
+
+    /// Place elements vertically, top to bottom.
+    ///
+    /// Use the provided horizontal alignment.
+    #[inline(always)]
+    pub fn top_down(halign: Align) -> Self {
+        Self {
+            main_dir: Direction::TopDown,
+            main_wrap: false,
+            main_align: Align::Center, // looks best to e.g. center text within a button
+            main_justify: false,
+            cross_align: halign,
+            cross_justify: false,
+        }
+    }
+
+    /// Top-down layout justified so that buttons etc fill the full available width.
+    #[inline(always)]
+    pub fn top_down_justified(halign: Align) -> Self {
+        Self::top_down(halign).with_cross_justify(true)
+    }
+
+    /// Place elements vertically, bottom up.
+    ///
+    /// Use the provided horizontal alignment.
+    #[inline(always)]
+    pub fn bottom_up(halign: Align) -> Self {
+        Self {
+            main_dir: Direction::BottomUp,
+            main_wrap: false,
+            main_align: Align::Center, // looks best to e.g. center text within a button
+            main_justify: false,
+            cross_align: halign,
+            cross_justify: false,
+        }
+    }
+
+    #[inline(always)]
+    pub fn from_main_dir_and_cross_align(main_dir: Direction, cross_align: Align) -> Self {
+        Self {
+            main_dir,
+            main_wrap: false,
+            main_align: Align::Center, // looks best to e.g. center text within a button
+            main_justify: false,
+            cross_align,
+            cross_justify: false,
+        }
+    }
+
+    /// For when you want to add a single widget to a layout, and that widget
+    /// should use up all available space.
+    ///
+    /// Only one widget may be added to the inner `Ui`!
+    #[inline(always)]
+    pub fn centered_and_justified(main_dir: Direction) -> Self {
+        Self {
+            main_dir,
+            main_wrap: false,
+            main_align: Align::Center,
+            main_justify: true,
+            cross_align: Align::Center,
+            cross_justify: true,
+        }
+    }
+
+    /// Wrap widgets when we overflow the main axis?
+    ///
+    /// For instance, for left-to-right layouts, setting this to `true` will
+    /// put widgets on a new row if we would overflow the right side of [`crate::Ui::max_rect`].
+    #[inline(always)]
+    pub fn with_main_wrap(self, main_wrap: bool) -> Self {
+        Self { main_wrap, ..self }
+    }
+
+    /// The alignment to use on the main axis.
+    #[inline(always)]
+    pub fn with_main_align(self, main_align: Align) -> Self {
+        Self { main_align, ..self }
+    }
+
+    /// The alignment to use on the cross axis.
+    ///
+    /// The "cross" axis is the one orthogonal to the main axis.
+    /// For instance: in left-to-right layout, the main axis is horizontal and the cross axis is vertical.
+    #[inline(always)]
+    pub fn with_cross_align(self, cross_align: Align) -> Self {
+        Self {
+            cross_align,
+            ..self
+        }
+    }
+
+    /// Justify widgets on the main axis?
+    ///
+    /// Justify here means "take up all available space".
+    #[inline(always)]
+    pub fn with_main_justify(self, main_justify: bool) -> Self {
+        Self {
+            main_justify,
+            ..self
+        }
+    }
+
+    /// Justify widgets along the cross axis?
+    ///
+    /// Justify here means "take up all available space".
+    ///
+    /// The "cross" axis is the one orthogonal to the main axis.
+    /// For instance: in left-to-right layout, the main axis is horizontal and the cross axis is vertical.
+    #[inline(always)]
+    pub fn with_cross_justify(self, cross_justify: bool) -> Self {
+        Self {
+            cross_justify,
+            ..self
+        }
+    }
+}
+
+/// ## Inspectors
+impl Layout {
+    #[inline(always)]
+    pub fn main_dir(&self) -> Direction {
+        self.main_dir
+    }
+
+    #[inline(always)]
+    pub fn main_wrap(&self) -> bool {
+        self.main_wrap
+    }
+
+    #[inline(always)]
+    pub fn cross_align(&self) -> Align {
+        self.cross_align
+    }
+
+    #[inline(always)]
+    pub fn cross_justify(&self) -> bool {
+        self.cross_justify
+    }
+
+    #[inline(always)]
+    pub fn is_horizontal(&self) -> bool {
+        self.main_dir().is_horizontal()
+    }
+
+    #[inline(always)]
+    pub fn is_vertical(&self) -> bool {
+        self.main_dir().is_vertical()
+    }
+
+    pub fn prefer_right_to_left(&self) -> bool {
+        self.main_dir == Direction::RightToLeft
+            || self.main_dir.is_vertical() && self.cross_align == Align::Max
+    }
+
+    /// e.g. for adjusting the placement of something.
+    /// * in horizontal layout: left or right?
+    /// * in vertical layout: same as [`Self::horizontal_align`].
+    pub fn horizontal_placement(&self) -> Align {
+        match self.main_dir {
+            Direction::LeftToRight => Align::LEFT,
+            Direction::RightToLeft => Align::RIGHT,
+            Direction::TopDown | Direction::BottomUp => self.cross_align,
+        }
+    }
+
+    /// e.g. for when aligning text within a button.
+    pub fn horizontal_align(&self) -> Align {
+        if self.is_horizontal() {
+            self.main_align
+        } else {
+            self.cross_align
+        }
+    }
+
+    /// e.g. for when aligning text within a button.
+    pub fn vertical_align(&self) -> Align {
+        if self.is_vertical() {
+            self.main_align
+        } else {
+            self.cross_align
+        }
+    }
+
+    /// e.g. for when aligning text within a button.
+    fn align2(&self) -> Align2 {
+        Align2([self.horizontal_align(), self.vertical_align()])
+    }
+
+    pub fn horizontal_justify(&self) -> bool {
+        if self.is_horizontal() {
+            self.main_justify
+        } else {
+            self.cross_justify
+        }
+    }
+
+    pub fn vertical_justify(&self) -> bool {
+        if self.is_vertical() {
+            self.main_justify
+        } else {
+            self.cross_justify
+        }
+    }
+}
+
+/// ## Doing layout
+impl Layout {
+    pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect {
+        egui_assert!(size.x >= 0.0 && size.y >= 0.0);
+        egui_assert!(!outer.is_negative());
+        self.align2().align_size_within_rect(size, outer)
+    }
+
+    fn initial_cursor(&self, max_rect: Rect) -> Rect {
+        let mut cursor = max_rect;
+
+        match self.main_dir {
+            Direction::LeftToRight => {
+                cursor.max.x = INFINITY;
+            }
+            Direction::RightToLeft => {
+                cursor.min.x = -INFINITY;
+            }
+            Direction::TopDown => {
+                cursor.max.y = INFINITY;
+            }
+            Direction::BottomUp => {
+                cursor.min.y = -INFINITY;
+            }
+        }
+
+        cursor
+    }
+
+    pub(crate) fn region_from_max_rect(&self, max_rect: Rect) -> Region {
+        egui_assert!(!max_rect.any_nan());
+        egui_assert!(max_rect.is_finite());
+        let mut region = Region {
+            min_rect: Rect::NOTHING, // temporary
+            max_rect,
+            cursor: self.initial_cursor(max_rect),
+        };
+        let seed = self.next_widget_position(&region);
+        region.min_rect = Rect::from_center_size(seed, Vec2::ZERO);
+        region
+    }
+
+    pub(crate) fn available_rect_before_wrap(&self, region: &Region) -> Rect {
+        self.available_from_cursor_max_rect(region.cursor, region.max_rect)
+    }
+
+    /// Amount of space available for a widget.
+    /// For wrapping layouts, this is the maximum (after wrap).
+    pub(crate) fn available_size(&self, r: &Region) -> Vec2 {
+        if self.main_wrap {
+            if self.main_dir.is_horizontal() {
+                vec2(r.max_rect.width(), r.cursor.height())
+            } else {
+                vec2(r.cursor.width(), r.max_rect.height())
+            }
+        } else {
+            self.available_from_cursor_max_rect(r.cursor, r.max_rect)
+                .size()
+        }
+    }
+
+    /// Given the cursor in the region, how much space is available
+    /// for the next widget?
+    fn available_from_cursor_max_rect(&self, cursor: Rect, max_rect: Rect) -> Rect {
+        egui_assert!(!cursor.any_nan());
+        egui_assert!(!max_rect.any_nan());
+        egui_assert!(max_rect.is_finite());
+
+        // NOTE: in normal top-down layout the cursor has moved below the current max_rect,
+        // but the available shouldn't be negative.
+
+        // ALSO: with wrapping layouts, cursor jumps to new row before expanding max_rect.
+
+        let mut avail = max_rect;
+
+        match self.main_dir {
+            Direction::LeftToRight => {
+                avail.min.x = cursor.min.x;
+                avail.max.x = avail.max.x.max(cursor.min.x);
+                avail.max.x = avail.max.x.max(avail.min.x);
+                avail.max.y = avail.max.y.max(avail.min.y);
+            }
+            Direction::RightToLeft => {
+                avail.max.x = cursor.max.x;
+                avail.min.x = avail.min.x.min(cursor.max.x);
+                avail.min.x = avail.min.x.min(avail.max.x);
+                avail.max.y = avail.max.y.max(avail.min.y);
+            }
+            Direction::TopDown => {
+                avail.min.y = cursor.min.y;
+                avail.max.y = avail.max.y.max(cursor.min.y);
+                avail.max.x = avail.max.x.max(avail.min.x);
+                avail.max.y = avail.max.y.max(avail.min.y);
+            }
+            Direction::BottomUp => {
+                avail.max.y = cursor.max.y;
+                avail.min.y = avail.min.y.min(cursor.max.y);
+                avail.max.x = avail.max.x.max(avail.min.x);
+                avail.min.y = avail.min.y.min(avail.max.y);
+            }
+        }
+
+        // We can use the cursor to restrict the available region.
+        // For instance, we use this to restrict the available space of a parent Ui
+        // after adding a panel to it.
+        // We also use it for wrapping layouts.
+        avail = avail.intersect(cursor);
+
+        // Make sure it isn't negative:
+        if avail.max.x < avail.min.x {
+            let x = 0.5 * (avail.min.x + avail.max.x);
+            avail.min.x = x;
+            avail.max.x = x;
+        }
+        if avail.max.y < avail.min.y {
+            let y = 0.5 * (avail.min.y + avail.max.y);
+            avail.min.y = y;
+            avail.max.y = y;
+        }
+
+        egui_assert!(!avail.any_nan());
+
+        avail
+    }
+
+    /// Returns where to put the next widget that is of the given size.
+    /// The returned `frame_rect` [`Rect`] will always be justified along the cross axis.
+    /// This is what you then pass to `advance_after_rects`.
+    /// Use `justify_and_align` to get the inner `widget_rect`.
+    pub(crate) fn next_frame(&self, region: &Region, child_size: Vec2, spacing: Vec2) -> Rect {
+        region.sanity_check();
+        egui_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+
+        if self.main_wrap {
+            let available_size = self.available_rect_before_wrap(region).size();
+
+            let Region {
+                mut cursor,
+                mut max_rect,
+                min_rect,
+            } = *region;
+
+            match self.main_dir {
+                Direction::LeftToRight => {
+                    if available_size.x < child_size.x && max_rect.left() < cursor.left() {
+                        // New row
+                        let new_row_height = cursor.height().max(child_size.y);
+                        // let new_top = cursor.bottom() + spacing.y;
+                        let new_top = min_rect.bottom() + spacing.y; // tighter packing
+                        cursor = Rect::from_min_max(
+                            pos2(max_rect.left(), new_top),
+                            pos2(INFINITY, new_top + new_row_height),
+                        );
+                        max_rect.max.y = max_rect.max.y.max(cursor.max.y);
+                    }
+                }
+                Direction::RightToLeft => {
+                    if available_size.x < child_size.x && cursor.right() < max_rect.right() {
+                        // New row
+                        let new_row_height = cursor.height().max(child_size.y);
+                        // let new_top = cursor.bottom() + spacing.y;
+                        let new_top = min_rect.bottom() + spacing.y; // tighter packing
+                        cursor = Rect::from_min_max(
+                            pos2(-INFINITY, new_top),
+                            pos2(max_rect.right(), new_top + new_row_height),
+                        );
+                        max_rect.max.y = max_rect.max.y.max(cursor.max.y);
+                    }
+                }
+                Direction::TopDown => {
+                    if available_size.y < child_size.y && max_rect.top() < cursor.top() {
+                        // New column
+                        let new_col_width = cursor.width().max(child_size.x);
+                        cursor = Rect::from_min_max(
+                            pos2(cursor.right() + spacing.x, max_rect.top()),
+                            pos2(cursor.right() + spacing.x + new_col_width, INFINITY),
+                        );
+                        max_rect.max.x = max_rect.max.x.max(cursor.max.x);
+                    }
+                }
+                Direction::BottomUp => {
+                    if available_size.y < child_size.y && cursor.bottom() < max_rect.bottom() {
+                        // New column
+                        let new_col_width = cursor.width().max(child_size.x);
+                        cursor = Rect::from_min_max(
+                            pos2(cursor.right() + spacing.x, -INFINITY),
+                            pos2(
+                                cursor.right() + spacing.x + new_col_width,
+                                max_rect.bottom(),
+                            ),
+                        );
+                        max_rect.max.x = max_rect.max.x.max(cursor.max.x);
+                    }
+                }
+            }
+
+            // Use the new cursor:
+            let region = Region {
+                min_rect,
+                max_rect,
+                cursor,
+            };
+
+            self.next_frame_ignore_wrap(&region, child_size)
+        } else {
+            self.next_frame_ignore_wrap(region, child_size)
+        }
+    }
+
+    fn next_frame_ignore_wrap(&self, region: &Region, child_size: Vec2) -> Rect {
+        region.sanity_check();
+        egui_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+
+        let available_rect = self.available_rect_before_wrap(region);
+
+        let mut frame_size = child_size;
+
+        if (self.is_vertical() && self.horizontal_align() == Align::Center)
+            || self.horizontal_justify()
+        {
+            frame_size.x = frame_size.x.max(available_rect.width()); // fill full width
+        }
+        if (self.is_horizontal() && self.vertical_align() == Align::Center)
+            || self.vertical_justify()
+        {
+            frame_size.y = frame_size.y.max(available_rect.height()); // fill full height
+        }
+
+        let align2 = match self.main_dir {
+            Direction::LeftToRight => Align2([Align::LEFT, self.vertical_align()]),
+            Direction::RightToLeft => Align2([Align::RIGHT, self.vertical_align()]),
+            Direction::TopDown => Align2([self.horizontal_align(), Align::TOP]),
+            Direction::BottomUp => Align2([self.horizontal_align(), Align::BOTTOM]),
+        };
+
+        let mut frame_rect = align2.align_size_within_rect(frame_size, available_rect);
+
+        if self.is_horizontal() && frame_rect.top() < region.cursor.top() {
+            // for horizontal layouts we always want to expand down,
+            // or we will overlap the row above.
+            // This is a bit hacky. Maybe we should do it for vertical layouts too.
+            frame_rect = frame_rect.translate(Vec2::Y * (region.cursor.top() - frame_rect.top()));
+        }
+
+        egui_assert!(!frame_rect.any_nan());
+        egui_assert!(!frame_rect.is_negative());
+
+        frame_rect
+    }
+
+    /// Apply justify (fill width/height) and/or alignment after calling `next_space`.
+    pub(crate) fn justify_and_align(&self, frame: Rect, mut child_size: Vec2) -> Rect {
+        egui_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+        egui_assert!(!frame.is_negative());
+
+        if self.horizontal_justify() {
+            child_size.x = child_size.x.at_least(frame.width()); // fill full width
+        }
+        if self.vertical_justify() {
+            child_size.y = child_size.y.at_least(frame.height()); // fill full height
+        }
+        self.align_size_within_rect(child_size, frame)
+    }
+
+    pub(crate) fn next_widget_space_ignore_wrap_justify(
+        &self,
+        region: &Region,
+        size: Vec2,
+    ) -> Rect {
+        let frame = self.next_frame_ignore_wrap(region, size);
+        let rect = self.align_size_within_rect(size, frame);
+        egui_assert!(!rect.any_nan());
+        egui_assert!(!rect.is_negative());
+        egui_assert!((rect.width() - size.x).abs() < 1.0 || size.x == f32::INFINITY);
+        egui_assert!((rect.height() - size.y).abs() < 1.0 || size.y == f32::INFINITY);
+        rect
+    }
+
+    /// Where would the next tiny widget be centered?
+    pub(crate) fn next_widget_position(&self, region: &Region) -> Pos2 {
+        self.next_widget_space_ignore_wrap_justify(region, Vec2::ZERO)
+            .center()
+    }
+
+    /// Advance the cursor by this many points, and allocate in region.
+    pub(crate) fn advance_cursor(&self, region: &mut Region, amount: f32) {
+        match self.main_dir {
+            Direction::LeftToRight => {
+                region.cursor.min.x += amount;
+                region.expand_to_include_x(region.cursor.min.x);
+            }
+            Direction::RightToLeft => {
+                region.cursor.max.x -= amount;
+                region.expand_to_include_x(region.cursor.max.x);
+            }
+            Direction::TopDown => {
+                region.cursor.min.y += amount;
+                region.expand_to_include_y(region.cursor.min.y);
+            }
+            Direction::BottomUp => {
+                region.cursor.max.y -= amount;
+                region.expand_to_include_y(region.cursor.max.y);
+            }
+        }
+    }
+
+    /// Advance cursor after a widget was added to a specific rectangle.
+    ///
+    /// * `frame_rect`: the frame inside which a widget was e.g. centered
+    /// * `widget_rect`: the actual rect used by the widget
+    pub(crate) fn advance_after_rects(
+        &self,
+        cursor: &mut Rect,
+        frame_rect: Rect,
+        widget_rect: Rect,
+        item_spacing: Vec2,
+    ) {
+        egui_assert!(!cursor.any_nan());
+        if self.main_wrap {
+            if cursor.intersects(frame_rect.shrink(1.0)) {
+                // make row/column larger if necessary
+                *cursor = cursor.union(frame_rect);
+            } else {
+                // this is a new row or column. We temporarily use NAN for what will be filled in later.
+                match self.main_dir {
+                    Direction::LeftToRight => {
+                        *cursor = Rect::from_min_max(
+                            pos2(f32::NAN, frame_rect.min.y),
+                            pos2(INFINITY, frame_rect.max.y),
+                        );
+                    }
+                    Direction::RightToLeft => {
+                        *cursor = Rect::from_min_max(
+                            pos2(-INFINITY, frame_rect.min.y),
+                            pos2(f32::NAN, frame_rect.max.y),
+                        );
+                    }
+                    Direction::TopDown => {
+                        *cursor = Rect::from_min_max(
+                            pos2(frame_rect.min.x, f32::NAN),
+                            pos2(frame_rect.max.x, INFINITY),
+                        );
+                    }
+                    Direction::BottomUp => {
+                        *cursor = Rect::from_min_max(
+                            pos2(frame_rect.min.x, -INFINITY),
+                            pos2(frame_rect.max.x, f32::NAN),
+                        );
+                    }
+                };
+            }
+        } else {
+            // Make sure we also expand where we consider adding things (the cursor):
+            if self.is_horizontal() {
+                cursor.min.y = cursor.min.y.min(frame_rect.min.y);
+                cursor.max.y = cursor.max.y.max(frame_rect.max.y);
+            } else {
+                cursor.min.x = cursor.min.x.min(frame_rect.min.x);
+                cursor.max.x = cursor.max.x.max(frame_rect.max.x);
+            }
+        }
+
+        match self.main_dir {
+            Direction::LeftToRight => {
+                cursor.min.x = widget_rect.max.x + item_spacing.x;
+            }
+            Direction::RightToLeft => {
+                cursor.max.x = widget_rect.min.x - item_spacing.x;
+            }
+            Direction::TopDown => {
+                cursor.min.y = widget_rect.max.y + item_spacing.y;
+            }
+            Direction::BottomUp => {
+                cursor.max.y = widget_rect.min.y - item_spacing.y;
+            }
+        };
+    }
+
+    /// Move to the next row in a wrapping layout.
+    /// Otherwise does nothing.
+    pub(crate) fn end_row(&mut self, region: &mut Region, spacing: Vec2) {
+        if self.main_wrap {
+            match self.main_dir {
+                Direction::LeftToRight => {
+                    let new_top = region.cursor.bottom() + spacing.y;
+                    region.cursor = Rect::from_min_max(
+                        pos2(region.max_rect.left(), new_top),
+                        pos2(INFINITY, new_top + region.cursor.height()),
+                    );
+                }
+                Direction::RightToLeft => {
+                    let new_top = region.cursor.bottom() + spacing.y;
+                    region.cursor = Rect::from_min_max(
+                        pos2(-INFINITY, new_top),
+                        pos2(region.max_rect.right(), new_top + region.cursor.height()),
+                    );
+                }
+                Direction::TopDown | Direction::BottomUp => {}
+            }
+        }
+    }
+
+    /// Set row height in horizontal wrapping layout.
+    pub(crate) fn set_row_height(&mut self, region: &mut Region, height: f32) {
+        if self.main_wrap && self.is_horizontal() {
+            region.cursor.max.y = region.cursor.min.y + height;
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// ## Debug stuff
+impl Layout {
+    /// Shows where the next widget is going to be placed
+    pub(crate) fn paint_text_at_cursor(
+        &self,
+        painter: &crate::Painter,
+        region: &Region,
+        stroke: epaint::Stroke,
+        text: impl ToString,
+    ) {
+        let cursor = region.cursor;
+        let next_pos = self.next_widget_position(region);
+
+        let l = 64.0;
+
+        let align = match self.main_dir {
+            Direction::LeftToRight => {
+                painter.line_segment([cursor.left_top(), cursor.left_bottom()], stroke);
+                painter.arrow(next_pos, vec2(l, 0.0), stroke);
+                Align2([Align::LEFT, self.vertical_align()])
+            }
+            Direction::RightToLeft => {
+                painter.line_segment([cursor.right_top(), cursor.right_bottom()], stroke);
+                painter.arrow(next_pos, vec2(-l, 0.0), stroke);
+                Align2([Align::RIGHT, self.vertical_align()])
+            }
+            Direction::TopDown => {
+                painter.line_segment([cursor.left_top(), cursor.right_top()], stroke);
+                painter.arrow(next_pos, vec2(0.0, l), stroke);
+                Align2([self.horizontal_align(), Align::TOP])
+            }
+            Direction::BottomUp => {
+                painter.line_segment([cursor.left_bottom(), cursor.right_bottom()], stroke);
+                painter.arrow(next_pos, vec2(0.0, -l), stroke);
+                Align2([self.horizontal_align(), Align::BOTTOM])
+            }
+        };
+
+        painter.debug_text(next_pos, align, stroke.color, text);
+    }
+}
diff --git a/egui/crates/egui/src/lib.rs b/egui/crates/egui/src/lib.rs
new file mode 100644
index 0000000..6280bba
--- /dev/null
+++ b/egui/crates/egui/src/lib.rs
@@ -0,0 +1,574 @@
+//! `egui`:  an easy-to-use GUI in pure Rust!
+//!
+//! Try the live web demo: <https://www.egui.rs/#demo>. Read more about egui at <https://github.com/emilk/egui>.
+//!
+//! `egui` is in heavy development, with each new version having breaking changes.
+//! You need to have rust 1.62.0 or later to use `egui`.
+//!
+//! To quickly get started with egui, you can take a look at [`eframe_template`](https://github.com/emilk/eframe_template)
+//! which uses [`eframe`](https://docs.rs/eframe).
+//!
+//! To create a GUI using egui you first need a [`Context`] (by convention referred to by `ctx`).
+//! Then you add a [`Window`] or a [`SidePanel`] to get a [`Ui`], which is what you'll be using to add all the buttons and labels that you need.
+//!
+//!
+//! # Using egui
+//!
+//! To see what is possible to build with egui you can check out the online demo at <https://www.egui.rs/#demo>.
+//!
+//! If you like the "learning by doing" approach, clone <https://github.com/emilk/eframe_template> and get started using egui right away.
+//!
+//! ### A simple example
+//!
+//! Here is a simple counter that can be incremented and decremented using two buttons:
+//! ```
+//! fn ui_counter(ui: &mut egui::Ui, counter: &mut i32) {
+//!     // Put the buttons and label on the same row:
+//!     ui.horizontal(|ui| {
+//!         if ui.button("-").clicked() {
+//!             *counter -= 1;
+//!         }
+//!         ui.label(counter.to_string());
+//!         if ui.button("+").clicked() {
+//!             *counter += 1;
+//!         }
+//!     });
+//! }
+//! ```
+//!
+//! In some GUI frameworks this would require defining multiple types and functions with callbacks or message handlers,
+//! but thanks to `egui` being immediate mode everything is one self-contained function!
+//!
+//! ### Getting a [`Ui`]
+//!
+//! Use one of [`SidePanel`], [`TopBottomPanel`], [`CentralPanel`], [`Window`] or [`Area`] to
+//! get access to an [`Ui`] where you can put widgets. For example:
+//!
+//! ```
+//! # egui::__run_test_ctx(|ctx| {
+//! egui::CentralPanel::default().show(&ctx, |ui| {
+//!     ui.add(egui::Label::new("Hello World!"));
+//!     ui.label("A shorter and more convenient way to add a label.");
+//!     if ui.button("Click me").clicked() {
+//!         // take some action here
+//!     }
+//! });
+//! # });
+//! ```
+//!
+//! ### Quick start
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! # let mut my_string = String::new();
+//! # let mut my_boolean = true;
+//! # let mut my_f32 = 42.0;
+//! ui.label("This is a label");
+//! ui.hyperlink("https://github.com/emilk/egui");
+//! ui.text_edit_singleline(&mut my_string);
+//! if ui.button("Click me").clicked() { }
+//! ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0));
+//! ui.add(egui::DragValue::new(&mut my_f32));
+//!
+//! ui.checkbox(&mut my_boolean, "Checkbox");
+//!
+//! #[derive(PartialEq)]
+//! enum Enum { First, Second, Third }
+//! # let mut my_enum = Enum::First;
+//! ui.horizontal(|ui| {
+//!     ui.radio_value(&mut my_enum, Enum::First, "First");
+//!     ui.radio_value(&mut my_enum, Enum::Second, "Second");
+//!     ui.radio_value(&mut my_enum, Enum::Third, "Third");
+//! });
+//!
+//! ui.separator();
+//!
+//! # let my_image = egui::TextureId::default();
+//! ui.image(my_image, [640.0, 480.0]);
+//!
+//! ui.collapsing("Click to see what is hidden!", |ui| {
+//!     ui.label("Not much, as it turns out");
+//! });
+//! # });
+//! ```
+//!
+//! ## Conventions
+//!
+//! Conventions unless otherwise specified:
+//!
+//! * angles are in radians
+//! * `Vec2::X` is right and `Vec2::Y` is down.
+//! * `Pos2::ZERO` is left top.
+//! * Positions and sizes are measured in _points_. Each point may consist of many physical pixels.
+//!
+//! # Integrating with egui
+//!
+//! Most likely you are using an existing `egui` backend/integration such as [`eframe`](https://docs.rs/eframe), [`bevy_egui`](https://docs.rs/bevy_egui),
+//! or [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad),
+//! but if you want to integrate `egui` into a new game engine, this is the section for you.
+//!
+//! To write your own integration for egui you need to do this:
+//!
+//! ``` no_run
+//! # fn handle_platform_output(_: egui::PlatformOutput) {}
+//! # fn gather_input() -> egui::RawInput { egui::RawInput::default() }
+//! # fn paint(textures_delta: egui::TexturesDelta, _: Vec<egui::ClippedPrimitive>) {}
+//! let mut ctx = egui::Context::default();
+//!
+//! // Game loop:
+//! loop {
+//!     let raw_input: egui::RawInput = gather_input();
+//!
+//!     let full_output = ctx.run(raw_input, |ctx| {
+//!         egui::CentralPanel::default().show(&ctx, |ui| {
+//!             ui.label("Hello world!");
+//!             if ui.button("Click me").clicked() {
+//!                 // take some action here
+//!             }
+//!         });
+//!     });
+//!     handle_platform_output(full_output.platform_output);
+//!     let clipped_primitives = ctx.tessellate(full_output.shapes); // create triangles to paint
+//!     paint(full_output.textures_delta, clipped_primitives);
+//! }
+//! ```
+//!
+//!
+//! # Understanding immediate mode
+//!
+//! `egui` is an immediate mode GUI library. It is useful to fully grok what "immediate mode" implies.
+//!
+//! Here is an example to illustrate it:
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! if ui.button("click me").clicked() {
+//!     take_action()
+//! }
+//! # });
+//! # fn take_action() {}
+//! ```
+//!
+//! This code is being executed each frame at maybe 60 frames per second.
+//! Each frame egui does these things:
+//!
+//! * lays out the letters `click me` in order to figure out the size of the button
+//! * decides where on screen to place the button
+//! * check if the mouse is hovering or clicking that location
+//! * chose button colors based on if it is being hovered or clicked
+//! * add a [`Shape::Rect`] and [`Shape::Text`] to the list of shapes to be painted later this frame
+//! * return a [`Response`] with the [`clicked`](`Response::clicked`) member so the user can check for interactions
+//!
+//! There is no button being created and stored somewhere.
+//! The only output of this call is some colored shapes, and a [`Response`].
+//!
+//! Similarly, consider this code:
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! # let mut value: f32 = 0.0;
+//! ui.add(egui::Slider::new(&mut value, 0.0..=100.0).text("My value"));
+//! # });
+//! ```
+//!
+//! Here egui will read `value` to display the slider, then look if the mouse is dragging the slider and if so change the `value`.
+//! Note that `egui` does not store the slider value for you - it only displays the current value, and changes it
+//! by how much the slider has been dragged in the previous few milliseconds.
+//! This means it is responsibility of the egui user to store the state (`value`) so that it persists between frames.
+//!
+//! It can be useful to read the code for the toggle switch example widget to get a better understanding
+//! of how egui works: <https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/demo/toggle_switch.rs>.
+//!
+//! Read more about the pros and cons of immediate mode at <https://github.com/emilk/egui#why-immediate-mode>.
+//!
+//! # Misc
+//!
+//! ## How widgets works
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! if ui.button("click me").clicked() { take_action() }
+//! # });
+//! # fn take_action() {}
+//! ```
+//!
+//! is short for
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! let button = egui::Button::new("click me");
+//! if ui.add(button).clicked() { take_action() }
+//! # });
+//! # fn take_action() {}
+//! ```
+//!
+//! which is short for
+//!
+//! ```
+//! # use egui::Widget;
+//! # egui::__run_test_ui(|ui| {
+//! let button = egui::Button::new("click me");
+//! let response = button.ui(ui);
+//! if response.clicked() { take_action() }
+//! # });
+//! # fn take_action() {}
+//! ```
+//!
+//! [`Button`] uses the builder pattern to create the data required to show it. The [`Button`] is then discarded.
+//!
+//! [`Button`] implements `trait` [`Widget`], which looks like this:
+//! ```
+//! # use egui::*;
+//! pub trait Widget {
+//!     /// Allocate space, interact, paint, and return a [`Response`].
+//!     fn ui(self, ui: &mut Ui) -> Response;
+//! }
+//! ```
+//!
+//! ## Auto-sizing panels and windows
+//! In egui, all panels and windows auto-shrink to fit the content.
+//! If the window or panel is also resizable, this can lead to a weird behavior
+//! where you can drag the edge of the panel/window to make it larger, and
+//! when you release the panel/window shrinks again.
+//! This is an artifact of immediate mode, and here are some alternatives on how to avoid it:
+//!
+//! 1. Turn off resizing with [`Window::resizable`], [`SidePanel::resizable`], [`TopBottomPanel::resizable`].
+//! 2. Wrap your panel contents in a [`ScrollArea`], or use [`Window::vscroll`] and [`Window::hscroll`].
+//! 3. Use a justified layout:
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! ui.with_layout(egui::Layout::top_down_justified(egui::Align::Center), |ui| {
+//!     ui.button("I am becoming wider as needed");
+//! });
+//! # });
+//! ```
+//!
+//! 4. Fill in extra space with emptiness:
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! ui.allocate_space(ui.available_size()); // put this LAST in your panel/window code
+//! # });
+//! ```
+//!
+//! ## Sizes
+//! You can control the size of widgets using [`Ui::add_sized`].
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! # let mut my_value = 0.0_f32;
+//! ui.add_sized([40.0, 20.0], egui::DragValue::new(&mut my_value));
+//! # });
+//! ```
+//!
+//! ## Code snippets
+//!
+//! ```
+//! # egui::__run_test_ui(|ui| {
+//! # let mut some_bool = true;
+//! // Miscellaneous tips and tricks
+//!
+//! ui.horizontal_wrapped(|ui| {
+//!     ui.spacing_mut().item_spacing.x = 0.0; // remove spacing between widgets
+//!     // `radio_value` also works for enums, integers, and more.
+//!     ui.radio_value(&mut some_bool, false, "Off");
+//!     ui.radio_value(&mut some_bool, true, "On");
+//! });
+//!
+//! ui.group(|ui| {
+//!     ui.label("Within a frame");
+//!     ui.set_min_height(200.0);
+//! });
+//!
+//! // A `scope` creates a temporary [`Ui`] in which you can change settings:
+//! ui.scope(|ui| {
+//!     ui.visuals_mut().override_text_color = Some(egui::Color32::RED);
+//!     ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+//!     ui.style_mut().wrap = Some(false);
+//!
+//!     ui.label("This text will be red, monospace, and won't wrap to a new line");
+//! }); // the temporary settings are reverted here
+//! # });
+//! ```
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![allow(clippy::manual_range_contains)]
+#![forbid(unsafe_code)]
+
+mod animation_manager;
+pub mod containers;
+mod context;
+mod data;
+mod frame_state;
+pub(crate) mod grid;
+pub mod gui_zoom;
+mod id;
+mod input_state;
+pub mod introspection;
+pub mod layers;
+mod layout;
+mod memory;
+pub mod menu;
+pub mod os;
+mod painter;
+pub(crate) mod placer;
+mod response;
+mod sense;
+pub mod style;
+mod ui;
+pub mod util;
+pub mod widget_text;
+pub mod widgets;
+
+#[cfg(feature = "accesskit")]
+pub use accesskit;
+
+pub use epaint;
+pub use epaint::ecolor;
+pub use epaint::emath;
+
+#[cfg(feature = "color-hex")]
+pub use ecolor::hex_color;
+pub use ecolor::{Color32, Rgba};
+pub use emath::{lerp, pos2, remap, remap_clamp, vec2, Align, Align2, NumExt, Pos2, Rect, Vec2};
+pub use epaint::{
+    mutex,
+    text::{FontData, FontDefinitions, FontFamily, FontId, FontTweak},
+    textures::{TextureFilter, TextureOptions, TexturesDelta},
+    ClippedPrimitive, ColorImage, FontImage, ImageData, Mesh, PaintCallback, PaintCallbackInfo,
+    Rounding, Shape, Stroke, TextureHandle, TextureId,
+};
+
+pub mod text {
+    pub use crate::text_edit::CCursorRange;
+    pub use epaint::text::{
+        cursor::CCursor, FontData, FontDefinitions, FontFamily, Fonts, Galley, LayoutJob,
+        LayoutSection, TextFormat, TAB_SIZE,
+    };
+}
+
+pub use {
+    containers::*,
+    context::Context,
+    data::{
+        input::*,
+        output::{self, CursorIcon, FullOutput, PlatformOutput, WidgetInfo},
+    },
+    grid::Grid,
+    id::{Id, IdMap},
+    input_state::{InputState, MultiTouchInfo, PointerState},
+    layers::{LayerId, Order},
+    layout::*,
+    memory::{Memory, Options},
+    painter::Painter,
+    response::{InnerResponse, Response},
+    sense::Sense,
+    style::{FontSelection, Margin, Style, TextStyle, Visuals},
+    text::{Galley, TextFormat},
+    ui::Ui,
+    widget_text::{RichText, WidgetText},
+    widgets::*,
+};
+
+// ----------------------------------------------------------------------------
+
+/// Helper function that adds a label when compiling with debug assertions enabled.
+pub fn warn_if_debug_build(ui: &mut crate::Ui) {
+    if cfg!(debug_assertions) {
+        ui.label(
+            RichText::new("⚠ Debug build ⚠")
+                .small()
+                .color(ui.visuals().warn_fg_color),
+        )
+        .on_hover_text("egui was compiled with debug assertions enabled.");
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Create a [`Hyperlink`](crate::Hyperlink) to the current [`file!()`] (and line) on Github
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// ui.add(egui::github_link_file_line!("https://github.com/YOUR/PROJECT/blob/master/", "(source code)"));
+/// # });
+/// ```
+#[macro_export]
+macro_rules! github_link_file_line {
+    ($github_url: expr, $label: expr) => {{
+        let url = format!("{}{}#L{}", $github_url, file!(), line!());
+        $crate::Hyperlink::from_label_and_url($label, url)
+    }};
+}
+
+/// Create a [`Hyperlink`](crate::Hyperlink) to the current [`file!()`] on github.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// ui.add(egui::github_link_file!("https://github.com/YOUR/PROJECT/blob/master/", "(source code)"));
+/// # });
+/// ```
+#[macro_export]
+macro_rules! github_link_file {
+    ($github_url: expr, $label: expr) => {{
+        let url = format!("{}{}", $github_url, file!());
+        $crate::Hyperlink::from_label_and_url($label, url)
+    }};
+}
+
+// ----------------------------------------------------------------------------
+
+/// Show debug info on hover when [`Context::set_debug_on_hover`] has been turned on.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// // Turn on tracing of widgets
+/// ui.ctx().set_debug_on_hover(true);
+///
+/// /// Show [`std::file`], [`std::line`] and argument on hover
+/// egui::trace!(ui, "MyWindow");
+///
+/// /// Show [`std::file`] and [`std::line`] on hover
+/// egui::trace!(ui);
+/// # });
+/// ```
+#[macro_export]
+macro_rules! trace {
+    ($ui: expr) => {{
+        $ui.trace_location(format!("{}:{}", file!(), line!()))
+    }};
+    ($ui: expr, $label: expr) => {{
+        $ui.trace_location(format!("{} - {}:{}", $label, file!(), line!()))
+    }};
+}
+
+// ----------------------------------------------------------------------------
+
+/// An assert that is only active when `egui` is compiled with the `extra_asserts` feature
+/// or with the `extra_debug_asserts` feature in debug builds.
+#[macro_export]
+macro_rules! egui_assert {
+    ($($arg: tt)*) => {
+        if cfg!(any(
+            feature = "extra_asserts",
+            all(feature = "extra_debug_asserts", debug_assertions),
+        )) {
+            assert!($($arg)*);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// The default egui fonts supports around 1216 emojis in total.
+/// Here are some of the most useful:
+/// ∞⊗⎗⎘⎙⏏⏴⏵⏶⏷
+/// ⏩⏪⏭⏮⏸⏹⏺■▶📾🔀🔁🔃
+/// ☀☁★☆☐☑☜☝☞☟⛃⛶✔
+/// ↺↻⟲⟳⬅➡⬆⬇⬈⬉⬊⬋⬌⬍⮨⮩⮪⮫
+/// ♡
+/// 📅📆
+/// 📈📉📊
+/// 📋📌📎📤📥🔆
+/// 🔈🔉🔊🔍🔎🔗🔘
+/// 🕓🖧🖩🖮🖱🖴🖵🖼🗀🗁🗋🗐🗑🗙🚫❓
+///
+/// NOTE: In egui all emojis are monochrome!
+///
+/// You can explore them all in the Font Book in [the online demo](https://www.egui.rs/#demo).
+///
+/// In addition, egui supports a few special emojis that are not part of the unicode standard.
+/// This module contains some of them:
+pub mod special_emojis {
+    /// Tux, the Linux penguin.
+    pub const OS_LINUX: char = '🐧';
+
+    /// The Windows logo.
+    pub const OS_WINDOWS: char = '';
+
+    /// The Android logo.
+    pub const OS_ANDROID: char = '';
+
+    /// The Apple logo.
+    pub const OS_APPLE: char = '';
+
+    /// The Github logo.
+    pub const GITHUB: char = '';
+
+    /// The Twitter bird.
+    pub const TWITTER: char = '';
+
+    /// The word `git`.
+    pub const GIT: char = '';
+
+    // I really would like to have ferris here.
+}
+
+/// The different types of built-in widgets in egui
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum WidgetType {
+    Label, // TODO(emilk): emit Label events
+
+    /// e.g. a hyperlink
+    Link,
+
+    TextEdit,
+
+    Button,
+
+    Checkbox,
+
+    RadioButton,
+
+    SelectableLabel,
+
+    ComboBox,
+
+    Slider,
+
+    DragValue,
+
+    ColorButton,
+
+    ImageButton,
+
+    CollapsingHeader,
+
+    /// If you cannot fit any of the above slots.
+    ///
+    /// If this is something you think should be added, file an issue.
+    Other,
+}
+
+// ----------------------------------------------------------------------------
+
+/// For use in tests; especially doctests.
+pub fn __run_test_ctx(mut run_ui: impl FnMut(&Context)) {
+    let ctx = Context::default();
+    ctx.set_fonts(FontDefinitions::empty()); // prevent fonts from being loaded (save CPU time)
+    let _ = ctx.run(Default::default(), |ctx| {
+        run_ui(ctx);
+    });
+}
+
+/// For use in tests; especially doctests.
+pub fn __run_test_ui(mut add_contents: impl FnMut(&mut Ui)) {
+    let ctx = Context::default();
+    ctx.set_fonts(FontDefinitions::empty()); // prevent fonts from being loaded (save CPU time)
+    let _ = ctx.run(Default::default(), |ctx| {
+        crate::CentralPanel::default().show(ctx, |ui| {
+            add_contents(ui);
+        });
+    });
+}
+
+#[cfg(feature = "accesskit")]
+pub fn accesskit_root_id() -> Id {
+    Id::new("accesskit_root")
+}
diff --git a/egui/crates/egui/src/memory.rs b/egui/crates/egui/src/memory.rs
new file mode 100644
index 0000000..c4299ed
--- /dev/null
+++ b/egui/crates/egui/src/memory.rs
@@ -0,0 +1,647 @@
+use crate::{area, window, Id, IdMap, InputState, LayerId, Pos2, Rect, Style};
+
+// ----------------------------------------------------------------------------
+
+/// The data that egui persists between frames.
+///
+/// This includes window positions and sizes,
+/// how far the user has scrolled in a [`ScrollArea`](crate::ScrollArea) etc.
+///
+/// If you want this to persist when closing your app you should serialize [`Memory`] and store it.
+/// For this you need to enable the `persistence`.
+///
+/// If you want to store data for your widgets, you should look at [`Memory::data`]
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "persistence", serde(default))]
+pub struct Memory {
+    pub options: Options,
+
+    /// This map stores some superficial state for all widgets with custom [`Id`]s.
+    ///
+    /// This includes storing if a [`crate::CollapsingHeader`] is open, how far scrolled a
+    /// [`crate::ScrollArea`] is, where the cursor in a [`crate::TextEdit`] is, etc.
+    ///
+    /// This is NOT meant to store any important data. Store that in your own structures!
+    ///
+    /// Each read clones the data, so keep your values cheap to clone.
+    /// If you want to store a lot of data you should wrap it in `Arc<Mutex<…>>` so it is cheap to clone.
+    ///
+    /// This will be saved between different program runs if you use the `persistence` feature.
+    ///
+    /// To store a state common for all your widgets (a singleton), use [`Id::null`] as the key.
+    pub data: crate::util::IdTypeMap,
+
+    // ------------------------------------------
+    /// Can be used to cache computations from one frame to another.
+    ///
+    /// This is for saving CPU when you have something that may take 1-100ms to compute.
+    /// Things that are very slow (>100ms) should instead be done async (i.e. in another thread)
+    /// so as not to lock the UI thread.
+    ///
+    /// ```
+    /// use egui::util::cache::{ComputerMut, FrameCache};
+    ///
+    /// #[derive(Default)]
+    /// struct CharCounter {}
+    /// impl ComputerMut<&str, usize> for CharCounter {
+    ///     fn compute(&mut self, s: &str) -> usize {
+    ///         s.chars().count() // you probably want to cache something more expensive than this
+    ///     }
+    /// }
+    /// type CharCountCache<'a> = FrameCache<usize, CharCounter>;
+    ///
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.memory_mut(|mem| {
+    ///     let cache = mem.caches.cache::<CharCountCache<'_>>();
+    ///     assert_eq!(cache.get("hello"), 5);
+    /// });
+    /// ```
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub caches: crate::util::cache::CacheStorage,
+
+    // ------------------------------------------
+    /// new scale that will be applied at the start of the next frame
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) new_pixels_per_point: Option<f32>,
+
+    /// new fonts that will be applied at the start of the next frame
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) new_font_definitions: Option<epaint::text::FontDefinitions>,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) interaction: Interaction,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) window_interaction: Option<window::WindowInteraction>,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) drag_value: crate::widgets::drag_value::MonoState,
+
+    pub(crate) areas: Areas,
+
+    /// Which popup-window is open (if any)?
+    /// Could be a combo box, color picker, menu etc.
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    popup: Option<Id>,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    everything_is_visible: bool,
+}
+
+// ----------------------------------------------------------------------------
+
+/// Some global options that you can read and write.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Options {
+    /// The default style for new [`Ui`](crate::Ui):s.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pub(crate) style: std::sync::Arc<Style>,
+
+    /// Controls the tessellator.
+    pub tessellation_options: epaint::TessellationOptions,
+
+    /// This is a signal to any backend that we want the [`crate::PlatformOutput::events`] read out loud.
+    ///
+    /// The only change to egui is that labels can be focused by pressing tab.
+    ///
+    /// Screen readers is an experimental feature of egui, and not supported on all platforms.
+    ///
+    /// `eframe` supports it only on web, using the `web_screen_reader` feature flag,
+    /// but you should consider using [AccessKit](https://github.com/AccessKit/accesskit) instead,
+    /// which `eframe` supports.
+    pub screen_reader: bool,
+
+    /// If true, the most common glyphs (ASCII) are pre-rendered to the texture atlas.
+    ///
+    /// Only the fonts in [`Style::text_styles`] will be pre-cached.
+    ///
+    /// This can lead to fewer texture operations, but may use up the texture atlas quicker
+    /// if you are changing [`Style::text_styles`], of have a lot of text styles.
+    pub preload_font_glyphs: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            style: Default::default(),
+            tessellation_options: Default::default(),
+            screen_reader: false,
+            preload_font_glyphs: true,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Say there is a button in a scroll area.
+/// If the user clicks the button, the button should click.
+/// If the user drags the button we should scroll the scroll area.
+/// So what we do is that when the mouse is pressed we register both the button
+/// and the scroll area (as `click_id`/`drag_id`).
+/// If the user releases the button without moving the mouse we register it as a click on `click_id`.
+/// If the cursor moves too much we clear the `click_id` and start passing move events to `drag_id`.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Interaction {
+    /// A widget interested in clicks that has a mouse press on it.
+    pub click_id: Option<Id>,
+
+    /// A widget interested in drags that has a mouse press on it.
+    pub drag_id: Option<Id>,
+
+    pub focus: Focus,
+
+    /// HACK: windows have low priority on dragging.
+    /// This is so that if you drag a slider in a window,
+    /// the slider will steal the drag away from the window.
+    /// This is needed because we do window interaction first (to prevent frame delay),
+    /// and then do content layout.
+    pub drag_is_window: bool,
+
+    /// Any interest in catching clicks this frame?
+    /// Cleared to false at start of each frame.
+    pub click_interest: bool,
+
+    /// Any interest in catching clicks this frame?
+    /// Cleared to false at start of each frame.
+    pub drag_interest: bool,
+}
+
+/// Keeps tracks of what widget has keyboard focus
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Focus {
+    /// The widget with keyboard focus (i.e. a text input field).
+    pub(crate) id: Option<Id>,
+
+    /// What had keyboard focus previous frame?
+    id_previous_frame: Option<Id>,
+
+    /// Give focus to this widget next frame
+    id_next_frame: Option<Id>,
+
+    #[cfg(feature = "accesskit")]
+    id_requested_by_accesskit: Option<accesskit::NodeId>,
+
+    /// If set, the next widget that is interested in focus will automatically get it.
+    /// Probably because the user pressed Tab.
+    give_to_next: bool,
+
+    /// The last widget interested in focus.
+    last_interested: Option<Id>,
+
+    /// If `true`, pressing tab will NOT move focus away from the current widget.
+    is_focus_locked: bool,
+
+    /// Set at the beginning of the frame, set to `false` when "used".
+    pressed_tab: bool,
+
+    /// Set at the beginning of the frame, set to `false` when "used".
+    pressed_shift_tab: bool,
+}
+
+impl Interaction {
+    /// Are we currently clicking or dragging an egui widget?
+    pub fn is_using_pointer(&self) -> bool {
+        self.click_id.is_some() || self.drag_id.is_some()
+    }
+
+    fn begin_frame(
+        &mut self,
+        prev_input: &crate::input_state::InputState,
+        new_input: &crate::data::input::RawInput,
+    ) {
+        self.click_interest = false;
+        self.drag_interest = false;
+
+        if !prev_input.pointer.could_any_button_be_click() {
+            self.click_id = None;
+        }
+
+        if !prev_input.pointer.any_down() || prev_input.pointer.latest_pos().is_none() {
+            // pointer button was not down last frame
+            self.click_id = None;
+            self.drag_id = None;
+        }
+
+        self.focus.begin_frame(new_input);
+    }
+}
+
+impl Focus {
+    /// Which widget currently has keyboard focus?
+    pub fn focused(&self) -> Option<Id> {
+        self.id
+    }
+
+    fn begin_frame(&mut self, new_input: &crate::data::input::RawInput) {
+        self.id_previous_frame = self.id;
+        if let Some(id) = self.id_next_frame.take() {
+            self.id = Some(id);
+        }
+
+        #[cfg(feature = "accesskit")]
+        {
+            self.id_requested_by_accesskit = None;
+        }
+
+        self.pressed_tab = false;
+        self.pressed_shift_tab = false;
+        for event in &new_input.events {
+            if matches!(
+                event,
+                crate::Event::Key {
+                    key: crate::Key::Escape,
+                    pressed: true,
+                    modifiers: _,
+                    ..
+                }
+            ) {
+                self.id = None;
+                self.is_focus_locked = false;
+                break;
+            }
+
+            if let crate::Event::Key {
+                key: crate::Key::Tab,
+                pressed: true,
+                modifiers,
+                ..
+            } = event
+            {
+                if !self.is_focus_locked {
+                    if modifiers.shift {
+                        self.pressed_shift_tab = true;
+                    } else {
+                        self.pressed_tab = true;
+                    }
+                }
+            }
+
+            #[cfg(feature = "accesskit")]
+            {
+                if let crate::Event::AccessKitActionRequest(accesskit::ActionRequest {
+                    action: accesskit::Action::Focus,
+                    target,
+                    data: None,
+                }) = event
+                {
+                    self.id_requested_by_accesskit = Some(*target);
+                }
+            }
+        }
+    }
+
+    pub(crate) fn end_frame(&mut self, used_ids: &IdMap<Rect>) {
+        if let Some(id) = self.id {
+            // Allow calling `request_focus` one frame and not using it until next frame
+            let recently_gained_focus = self.id_previous_frame != Some(id);
+
+            if !recently_gained_focus && !used_ids.contains_key(&id) {
+                // Dead-mans-switch: the widget with focus has disappeared!
+                self.id = None;
+            }
+        }
+    }
+
+    pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
+        self.id_previous_frame == Some(id)
+    }
+
+    fn interested_in_focus(&mut self, id: Id) {
+        #[cfg(feature = "accesskit")]
+        {
+            if self.id_requested_by_accesskit == Some(id.accesskit_id()) {
+                self.id = Some(id);
+                self.id_requested_by_accesskit = None;
+                self.give_to_next = false;
+                self.pressed_tab = false;
+                self.pressed_shift_tab = false;
+            }
+        }
+
+        if self.give_to_next && !self.had_focus_last_frame(id) {
+            self.id = Some(id);
+            self.give_to_next = false;
+        } else if self.id == Some(id) {
+            if self.pressed_tab && !self.is_focus_locked {
+                self.id = None;
+                self.give_to_next = true;
+                self.pressed_tab = false;
+            } else if self.pressed_shift_tab && !self.is_focus_locked {
+                self.id_next_frame = self.last_interested; // frame-delay so gained_focus works
+                self.pressed_shift_tab = false;
+            }
+        } else if self.pressed_tab && self.id.is_none() && !self.give_to_next {
+            // nothing has focus and the user pressed tab - give focus to the first widgets that wants it:
+            self.id = Some(id);
+            self.pressed_tab = false;
+        }
+
+        self.last_interested = Some(id);
+    }
+}
+
+impl Memory {
+    pub(crate) fn begin_frame(
+        &mut self,
+        prev_input: &crate::input_state::InputState,
+        new_input: &crate::data::input::RawInput,
+    ) {
+        self.interaction.begin_frame(prev_input, new_input);
+
+        if !prev_input.pointer.any_down() {
+            self.window_interaction = None;
+        }
+    }
+
+    pub(crate) fn end_frame(&mut self, input: &InputState, used_ids: &IdMap<Rect>) {
+        self.caches.update();
+        self.areas.end_frame();
+        self.interaction.focus.end_frame(used_ids);
+        self.drag_value.end_frame(input);
+    }
+
+    /// Top-most layer at the given position.
+    pub fn layer_id_at(&self, pos: Pos2, resize_interact_radius_side: f32) -> Option<LayerId> {
+        self.areas.layer_id_at(pos, resize_interact_radius_side)
+    }
+
+    /// An iterator over all layers. Back-to-front. Top is last.
+    pub fn layer_ids(&self) -> impl ExactSizeIterator<Item = LayerId> + '_ {
+        self.areas.order().iter().copied()
+    }
+
+    pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
+        self.interaction.focus.id_previous_frame == Some(id)
+    }
+
+    /// True if the given widget had keyboard focus last frame, but not this one.
+    pub(crate) fn lost_focus(&self, id: Id) -> bool {
+        self.had_focus_last_frame(id) && !self.has_focus(id)
+    }
+
+    /// True if the given widget has keyboard focus this frame, but didn't last frame.
+    pub(crate) fn gained_focus(&self, id: Id) -> bool {
+        !self.had_focus_last_frame(id) && self.has_focus(id)
+    }
+
+    /// Does this widget have keyboard focus?
+    ///
+    /// This function does not consider whether the UI as a whole (e.g. window)
+    /// has the keyboard focus. That makes this function suitable for deciding
+    /// widget state that should not be disrupted if the user moves away
+    /// from the window and back.
+    #[inline(always)]
+    pub fn has_focus(&self, id: Id) -> bool {
+        self.interaction.focus.id == Some(id)
+    }
+
+    /// Which widget has keyboard focus?
+    pub fn focus(&self) -> Option<Id> {
+        self.interaction.focus.id
+    }
+
+    /// Prevent keyboard focus from moving away from this widget even if users presses the tab key.
+    /// You must first give focus to the widget before calling this.
+    pub fn lock_focus(&mut self, id: Id, lock_focus: bool) {
+        if self.had_focus_last_frame(id) && self.has_focus(id) {
+            self.interaction.focus.is_focus_locked = lock_focus;
+        }
+    }
+
+    /// Is the keyboard focus locked on this widget? If so the focus won't move even if the user presses the tab key.
+    pub fn has_lock_focus(&self, id: Id) -> bool {
+        if self.had_focus_last_frame(id) && self.has_focus(id) {
+            self.interaction.focus.is_focus_locked
+        } else {
+            false
+        }
+    }
+
+    /// Give keyboard focus to a specific widget.
+    /// See also [`crate::Response::request_focus`].
+    #[inline(always)]
+    pub fn request_focus(&mut self, id: Id) {
+        self.interaction.focus.id = Some(id);
+        self.interaction.focus.is_focus_locked = false;
+    }
+
+    /// Surrender keyboard focus for a specific widget.
+    /// See also [`crate::Response::surrender_focus`].
+    #[inline(always)]
+    pub fn surrender_focus(&mut self, id: Id) {
+        if self.interaction.focus.id == Some(id) {
+            self.interaction.focus.id = None;
+            self.interaction.focus.is_focus_locked = false;
+        }
+    }
+
+    /// Register this widget as being interested in getting keyboard focus.
+    /// This will allow the user to select it with tab and shift-tab.
+    /// This is normally done automatically when handling interactions,
+    /// but it is sometimes useful to pre-register interest in focus,
+    /// e.g. before deciding which type of underlying widget to use,
+    /// as in the [`crate::DragValue`] widget, so a widget can be focused
+    /// and rendered correctly in a single frame.
+    #[inline(always)]
+    pub fn interested_in_focus(&mut self, id: Id) {
+        self.interaction.focus.interested_in_focus(id);
+    }
+
+    /// Stop editing of active [`TextEdit`](crate::TextEdit) (if any).
+    #[inline(always)]
+    pub fn stop_text_input(&mut self) {
+        self.interaction.focus.id = None;
+    }
+
+    #[inline(always)]
+    pub fn is_anything_being_dragged(&self) -> bool {
+        self.interaction.drag_id.is_some()
+    }
+
+    #[inline(always)]
+    pub fn is_being_dragged(&self, id: Id) -> bool {
+        self.interaction.drag_id == Some(id)
+    }
+
+    #[inline(always)]
+    pub fn set_dragged_id(&mut self, id: Id) {
+        self.interaction.drag_id = Some(id);
+    }
+
+    /// Forget window positions, sizes etc.
+    /// Can be used to auto-layout windows.
+    pub fn reset_areas(&mut self) {
+        self.areas = Default::default();
+    }
+}
+
+/// ## Popups
+/// Popups are things like combo-boxes, color pickers, menus etc.
+/// Only one can be be open at a time.
+impl Memory {
+    pub fn is_popup_open(&self, popup_id: Id) -> bool {
+        self.popup == Some(popup_id) || self.everything_is_visible()
+    }
+
+    pub fn any_popup_open(&self) -> bool {
+        self.popup.is_some() || self.everything_is_visible()
+    }
+
+    pub fn open_popup(&mut self, popup_id: Id) {
+        self.popup = Some(popup_id);
+    }
+
+    pub fn close_popup(&mut self) {
+        self.popup = None;
+    }
+
+    pub fn toggle_popup(&mut self, popup_id: Id) {
+        if self.is_popup_open(popup_id) {
+            self.close_popup();
+        } else {
+            self.open_popup(popup_id);
+        }
+    }
+
+    /// If true, all windows, menus, tooltips etc are to be visible at once.
+    ///
+    /// This is useful for testing, benchmarking, pre-caching, etc.
+    ///
+    /// Experimental feature!
+    #[inline(always)]
+    pub fn everything_is_visible(&self) -> bool {
+        self.everything_is_visible
+    }
+
+    /// If true, all windows, menus, tooltips etc are to be visible at once.
+    ///
+    /// This is useful for testing, benchmarking, pre-caching, etc.
+    ///
+    /// Experimental feature!
+    pub fn set_everything_is_visible(&mut self, value: bool) {
+        self.everything_is_visible = value;
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Keeps track of [`Area`](crate::containers::area::Area)s, which are free-floating [`Ui`](crate::Ui)s.
+/// These [`Area`](crate::containers::area::Area)s can be in any [`Order`](crate::Order).
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Areas {
+    areas: IdMap<area::State>,
+    /// Back-to-front. Top is last.
+    order: Vec<LayerId>,
+    visible_last_frame: ahash::HashSet<LayerId>,
+    visible_current_frame: ahash::HashSet<LayerId>,
+
+    /// When an area want to be on top, it is put in here.
+    /// At the end of the frame, this is used to reorder the layers.
+    /// This means if several layers want to be on top, they will keep their relative order.
+    /// So if you close three windows and then reopen them all in one frame,
+    /// they will all be sent to the top, but keep their previous internal order.
+    wants_to_be_on_top: ahash::HashSet<LayerId>,
+}
+
+impl Areas {
+    pub(crate) fn count(&self) -> usize {
+        self.areas.len()
+    }
+
+    pub(crate) fn get(&self, id: Id) -> Option<&area::State> {
+        self.areas.get(&id)
+    }
+
+    /// Back-to-front. Top is last.
+    pub(crate) fn order(&self) -> &[LayerId] {
+        &self.order
+    }
+
+    pub(crate) fn set_state(&mut self, layer_id: LayerId, state: area::State) {
+        self.visible_current_frame.insert(layer_id);
+        self.areas.insert(layer_id.id, state);
+        if !self.order.iter().any(|x| *x == layer_id) {
+            self.order.push(layer_id);
+        }
+    }
+
+    /// Top-most layer at the given position.
+    pub fn layer_id_at(&self, pos: Pos2, resize_interact_radius_side: f32) -> Option<LayerId> {
+        for layer in self.order.iter().rev() {
+            if self.is_visible(layer) {
+                if let Some(state) = self.areas.get(&layer.id) {
+                    let mut rect = state.rect();
+                    if state.interactable {
+                        // Allow us to resize by dragging just outside the window:
+                        rect = rect.expand(resize_interact_radius_side);
+                        if rect.contains(pos) {
+                            return Some(*layer);
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    pub fn visible_last_frame(&self, layer_id: &LayerId) -> bool {
+        self.visible_last_frame.contains(layer_id)
+    }
+
+    pub fn is_visible(&self, layer_id: &LayerId) -> bool {
+        self.visible_last_frame.contains(layer_id) || self.visible_current_frame.contains(layer_id)
+    }
+
+    pub fn visible_layer_ids(&self) -> ahash::HashSet<LayerId> {
+        self.visible_last_frame
+            .iter()
+            .copied()
+            .chain(self.visible_current_frame.iter().copied())
+            .collect()
+    }
+
+    pub(crate) fn visible_windows(&self) -> Vec<&area::State> {
+        self.visible_layer_ids()
+            .iter()
+            .filter(|layer| layer.order == crate::Order::Middle)
+            .filter_map(|layer| self.get(layer.id))
+            .collect()
+    }
+
+    pub fn move_to_top(&mut self, layer_id: LayerId) {
+        self.visible_current_frame.insert(layer_id);
+        self.wants_to_be_on_top.insert(layer_id);
+
+        if !self.order.iter().any(|x| *x == layer_id) {
+            self.order.push(layer_id);
+        }
+    }
+
+    pub(crate) fn end_frame(&mut self) {
+        let Self {
+            visible_last_frame,
+            visible_current_frame,
+            order,
+            wants_to_be_on_top,
+            ..
+        } = self;
+
+        std::mem::swap(visible_last_frame, visible_current_frame);
+        visible_current_frame.clear();
+        order.sort_by_key(|layer| (layer.order, wants_to_be_on_top.contains(layer)));
+        wants_to_be_on_top.clear();
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[test]
+fn memory_impl_send_sync() {
+    fn assert_send_sync<T: Send + Sync>() {}
+    assert_send_sync::<Memory>();
+}
diff --git a/egui/crates/egui/src/menu.rs b/egui/crates/egui/src/menu.rs
new file mode 100644
index 0000000..5e27e95
--- /dev/null
+++ b/egui/crates/egui/src/menu.rs
@@ -0,0 +1,690 @@
+//! Menu bar functionality (very basic so far).
+//!
+//! Usage:
+//! ```
+//! fn show_menu(ui: &mut egui::Ui) {
+//!     use egui::{menu, Button};
+//!
+//!     menu::bar(ui, |ui| {
+//!         ui.menu_button("File", |ui| {
+//!             if ui.button("Open").clicked() {
+//!                 // …
+//!             }
+//!         });
+//!     });
+//! }
+//! ```
+
+use super::{
+    style::WidgetVisuals, Align, Context, Id, InnerResponse, PointerState, Pos2, Rect, Response,
+    Sense, TextStyle, Ui, Vec2,
+};
+use crate::{widgets::*, *};
+use epaint::mutex::RwLock;
+use std::sync::Arc;
+
+/// What is saved between frames.
+#[derive(Clone, Default)]
+pub(crate) struct BarState {
+    open_menu: MenuRootManager,
+}
+
+impl BarState {
+    fn load(ctx: &Context, bar_id: Id) -> Self {
+        ctx.data_mut(|d| d.get_temp::<Self>(bar_id).unwrap_or_default())
+    }
+
+    fn store(self, ctx: &Context, bar_id: Id) {
+        ctx.data_mut(|d| d.insert_temp(bar_id, self));
+    }
+
+    /// Show a menu at pointer if primary-clicked response.
+    /// Should be called from [`Context`] on a [`Response`]
+    pub fn bar_menu<R>(
+        &mut self,
+        response: &Response,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        MenuRoot::stationary_click_interaction(response, &mut self.open_menu, response.id);
+        self.open_menu.show(response, add_contents)
+    }
+}
+
+impl std::ops::Deref for BarState {
+    type Target = MenuRootManager;
+
+    fn deref(&self) -> &Self::Target {
+        &self.open_menu
+    }
+}
+
+impl std::ops::DerefMut for BarState {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.open_menu
+    }
+}
+
+fn set_menu_style(style: &mut Style) {
+    style.spacing.button_padding = vec2(2.0, 0.0);
+    style.visuals.widgets.active.bg_stroke = Stroke::NONE;
+    style.visuals.widgets.hovered.bg_stroke = Stroke::NONE;
+    style.visuals.widgets.inactive.weak_bg_fill = Color32::TRANSPARENT;
+    style.visuals.widgets.inactive.bg_stroke = Stroke::NONE;
+}
+
+/// The menu bar goes well in a [`TopBottomPanel::top`],
+/// but can also be placed in a [`Window`].
+/// In the latter case you may want to wrap it in [`Frame`].
+pub fn bar<R>(ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+    ui.horizontal(|ui| {
+        set_menu_style(ui.style_mut());
+
+        // Take full width and fixed height:
+        let height = ui.spacing().interact_size.y;
+        ui.set_min_size(vec2(ui.available_width(), height));
+
+        add_contents(ui)
+    })
+}
+
+/// Construct a top level menu in a menu bar. This would be e.g. "File", "Edit" etc.
+///
+/// Responds to primary clicks.
+///
+/// Returns `None` if the menu is not open.
+pub fn menu_button<R>(
+    ui: &mut Ui,
+    title: impl Into<WidgetText>,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> InnerResponse<Option<R>> {
+    stationary_menu_impl(ui, title, Box::new(add_contents))
+}
+
+/// Construct a top level menu with an image in a menu bar. This would be e.g. "File", "Edit" etc.
+///
+/// Responds to primary clicks.
+///
+/// Returns `None` if the menu is not open.
+pub fn menu_image_button<R>(
+    ui: &mut Ui,
+    texture_id: TextureId,
+    image_size: impl Into<Vec2>,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> InnerResponse<Option<R>> {
+    stationary_menu_image_impl(ui, texture_id, image_size, Box::new(add_contents))
+}
+
+/// Construct a nested sub menu in another menu.
+///
+/// Opens on hover.
+///
+/// Returns `None` if the menu is not open.
+pub(crate) fn submenu_button<R>(
+    ui: &mut Ui,
+    parent_state: Arc<RwLock<MenuState>>,
+    title: impl Into<WidgetText>,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> InnerResponse<Option<R>> {
+    SubMenu::new(parent_state, title).show(ui, add_contents)
+}
+
+/// wrapper for the contents of every menu.
+pub(crate) fn menu_ui<'c, R>(
+    ctx: &Context,
+    menu_id: impl Into<Id>,
+    menu_state_arc: &Arc<RwLock<MenuState>>,
+    add_contents: impl FnOnce(&mut Ui) -> R + 'c,
+) -> InnerResponse<R> {
+    let pos = {
+        let mut menu_state = menu_state_arc.write();
+        menu_state.entry_count = 0;
+        menu_state.rect.min
+    };
+
+    let area = Area::new(menu_id)
+        .order(Order::Foreground)
+        .constrain(true)
+        .fixed_pos(pos)
+        .interactable(true)
+        .drag_bounds(ctx.screen_rect());
+
+    area.show(ctx, |ui| {
+        set_menu_style(ui.style_mut());
+
+        let frame = Frame::menu(ui.style()).show(ui, |ui| {
+            const DEFAULT_MENU_WIDTH: f32 = 150.0; // TODO(emilk): add to ui.spacing
+            ui.set_max_width(DEFAULT_MENU_WIDTH);
+            ui.set_menu_state(Some(menu_state_arc.clone()));
+            ui.with_layout(Layout::top_down_justified(Align::LEFT), add_contents)
+                .inner
+        });
+
+        menu_state_arc.write().rect = frame.response.rect;
+
+        frame.inner
+    })
+}
+
+/// Build a top level menu with a button.
+///
+/// Responds to primary clicks.
+fn stationary_menu_impl<'c, R>(
+    ui: &mut Ui,
+    title: impl Into<WidgetText>,
+    add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+) -> InnerResponse<Option<R>> {
+    let title = title.into();
+    let bar_id = ui.id();
+    let menu_id = bar_id.with(title.text());
+
+    let mut bar_state = BarState::load(ui.ctx(), bar_id);
+
+    let mut button = Button::new(title);
+
+    if bar_state.open_menu.is_menu_open(menu_id) {
+        button = button.fill(ui.visuals().widgets.open.weak_bg_fill);
+        button = button.stroke(ui.visuals().widgets.open.bg_stroke);
+    }
+
+    let button_response = ui.add(button);
+    let inner = bar_state.bar_menu(&button_response, add_contents);
+
+    bar_state.store(ui.ctx(), bar_id);
+    InnerResponse::new(inner.map(|r| r.inner), button_response)
+}
+
+/// Build a top level menu with an image button.
+///
+/// Responds to primary clicks.
+fn stationary_menu_image_impl<'c, R>(
+    ui: &mut Ui,
+    texture_id: TextureId,
+    image_size: impl Into<Vec2>,
+    add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+) -> InnerResponse<Option<R>> {
+    let bar_id = ui.id();
+
+    let mut bar_state = BarState::load(ui.ctx(), bar_id);
+    let button_response = ui.add(ImageButton::new(texture_id, image_size));
+    let inner = bar_state.bar_menu(&button_response, add_contents);
+
+    bar_state.store(ui.ctx(), bar_id);
+    InnerResponse::new(inner.map(|r| r.inner), button_response)
+}
+
+/// Response to secondary clicks (right-clicks) by showing the given menu.
+pub(crate) fn context_menu(
+    response: &Response,
+    add_contents: impl FnOnce(&mut Ui),
+) -> Option<InnerResponse<()>> {
+    let menu_id = Id::new("__egui::context_menu");
+    let mut bar_state = BarState::load(&response.ctx, menu_id);
+
+    MenuRoot::context_click_interaction(response, &mut bar_state, response.id);
+    let inner_response = bar_state.show(response, add_contents);
+
+    bar_state.store(&response.ctx, menu_id);
+    inner_response
+}
+
+/// Stores the state for the context menu.
+#[derive(Clone, Default)]
+pub(crate) struct MenuRootManager {
+    inner: Option<MenuRoot>,
+}
+
+impl MenuRootManager {
+    /// Show a menu at pointer if right-clicked response.
+    /// Should be called from [`Context`] on a [`Response`]
+    pub fn show<R>(
+        &mut self,
+        response: &Response,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        if let Some(root) = self.inner.as_mut() {
+            let (menu_response, inner_response) = root.show(response, add_contents);
+            if MenuResponse::Close == menu_response {
+                self.inner = None;
+            }
+            inner_response
+        } else {
+            None
+        }
+    }
+
+    fn is_menu_open(&self, id: Id) -> bool {
+        self.inner.as_ref().map(|m| m.id) == Some(id)
+    }
+}
+
+impl std::ops::Deref for MenuRootManager {
+    type Target = Option<MenuRoot>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl std::ops::DerefMut for MenuRootManager {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+/// Menu root associated with an Id from a Response
+#[derive(Clone)]
+pub(crate) struct MenuRoot {
+    pub menu_state: Arc<RwLock<MenuState>>,
+    pub id: Id,
+}
+
+impl MenuRoot {
+    pub fn new(position: Pos2, id: Id) -> Self {
+        Self {
+            menu_state: Arc::new(RwLock::new(MenuState::new(position))),
+            id,
+        }
+    }
+
+    pub fn show<R>(
+        &mut self,
+        response: &Response,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> (MenuResponse, Option<InnerResponse<R>>) {
+        if self.id == response.id {
+            let inner_response =
+                MenuState::show(&response.ctx, &self.menu_state, self.id, add_contents);
+            let menu_state = self.menu_state.read();
+
+            if menu_state.response.is_close() {
+                return (MenuResponse::Close, Some(inner_response));
+            }
+        }
+        (MenuResponse::Stay, None)
+    }
+
+    /// Interaction with a stationary menu, i.e. fixed in another Ui.
+    ///
+    /// Responds to primary clicks.
+    fn stationary_interaction(
+        response: &Response,
+        root: &mut MenuRootManager,
+        id: Id,
+    ) -> MenuResponse {
+        if (response.clicked() && root.is_menu_open(id))
+            || response.ctx.input(|i| i.key_pressed(Key::Escape))
+        {
+            // menu open and button clicked or esc pressed
+            return MenuResponse::Close;
+        } else if (response.clicked() && !root.is_menu_open(id))
+            || (response.hovered() && root.is_some())
+        {
+            // menu not open and button clicked
+            // or button hovered while other menu is open
+            let mut pos = response.rect.left_bottom();
+            if let Some(root) = root.inner.as_mut() {
+                let menu_rect = root.menu_state.read().rect;
+                let screen_rect = response.ctx.input(|i| i.screen_rect);
+
+                if pos.y + menu_rect.height() > screen_rect.max.y {
+                    pos.y = screen_rect.max.y - menu_rect.height() - response.rect.height();
+                }
+
+                if pos.x + menu_rect.width() > screen_rect.max.x {
+                    pos.x = screen_rect.max.x - menu_rect.width();
+                }
+            }
+
+            return MenuResponse::Create(pos, id);
+        } else if response
+            .ctx
+            .input(|i| i.pointer.any_pressed() && i.pointer.primary_down())
+        {
+            if let Some(pos) = response.ctx.input(|i| i.pointer.interact_pos()) {
+                if let Some(root) = root.inner.as_mut() {
+                    if root.id == id {
+                        // pressed somewhere while this menu is open
+                        let menu_state = root.menu_state.read();
+                        let in_menu = menu_state.area_contains(pos);
+                        if !in_menu {
+                            return MenuResponse::Close;
+                        }
+                    }
+                }
+            }
+        }
+        MenuResponse::Stay
+    }
+
+    /// Interaction with a context menu (secondary clicks).
+    fn context_interaction(
+        response: &Response,
+        root: &mut Option<MenuRoot>,
+        id: Id,
+    ) -> MenuResponse {
+        let response = response.interact(Sense::click());
+        response.ctx.input(|input| {
+            let pointer = &input.pointer;
+            if pointer.any_pressed() {
+                if let Some(pos) = pointer.interact_pos() {
+                    let mut destroy = false;
+                    let mut in_old_menu = false;
+                    if let Some(root) = root {
+                        let menu_state = root.menu_state.read();
+                        in_old_menu = menu_state.area_contains(pos);
+                        destroy = root.id == response.id;
+                    }
+                    if !in_old_menu {
+                        if response.hovered() && pointer.secondary_down() {
+                            return MenuResponse::Create(pos, id);
+                        } else if (response.hovered() && pointer.primary_down()) || destroy {
+                            return MenuResponse::Close;
+                        }
+                    }
+                }
+            }
+            MenuResponse::Stay
+        })
+    }
+
+    fn handle_menu_response(root: &mut MenuRootManager, menu_response: MenuResponse) {
+        match menu_response {
+            MenuResponse::Create(pos, id) => {
+                root.inner = Some(MenuRoot::new(pos, id));
+            }
+            MenuResponse::Close => root.inner = None,
+            MenuResponse::Stay => {}
+        }
+    }
+
+    /// Respond to secondary (right) clicks.
+    pub fn context_click_interaction(response: &Response, root: &mut MenuRootManager, id: Id) {
+        let menu_response = Self::context_interaction(response, root, id);
+        Self::handle_menu_response(root, menu_response);
+    }
+
+    // Responds to primary clicks.
+    pub fn stationary_click_interaction(response: &Response, root: &mut MenuRootManager, id: Id) {
+        let menu_response = Self::stationary_interaction(response, root, id);
+        Self::handle_menu_response(root, menu_response);
+    }
+}
+
+#[derive(Copy, Clone, PartialEq)]
+pub(crate) enum MenuResponse {
+    Close,
+    Stay,
+    Create(Pos2, Id),
+}
+
+impl MenuResponse {
+    pub fn is_close(&self) -> bool {
+        *self == Self::Close
+    }
+}
+
+pub struct SubMenuButton {
+    text: WidgetText,
+    icon: WidgetText,
+    index: usize,
+}
+
+impl SubMenuButton {
+    /// The `icon` can be an emoji (e.g. `⏵` right arrow), shown right of the label
+    fn new(text: impl Into<WidgetText>, icon: impl Into<WidgetText>, index: usize) -> Self {
+        Self {
+            text: text.into(),
+            icon: icon.into(),
+            index,
+        }
+    }
+
+    fn visuals<'a>(
+        ui: &'a Ui,
+        response: &'_ Response,
+        menu_state: &'_ MenuState,
+        sub_id: Id,
+    ) -> &'a WidgetVisuals {
+        if menu_state.is_open(sub_id) {
+            &ui.style().visuals.widgets.open
+        } else {
+            ui.style().interact(response)
+        }
+    }
+
+    pub fn icon(mut self, icon: impl Into<WidgetText>) -> Self {
+        self.icon = icon.into();
+        self
+    }
+
+    pub(crate) fn show(self, ui: &mut Ui, menu_state: &MenuState, sub_id: Id) -> Response {
+        let SubMenuButton { text, icon, .. } = self;
+
+        let text_style = TextStyle::Button;
+        let sense = Sense::click();
+
+        let button_padding = ui.spacing().button_padding;
+        let total_extra = button_padding + button_padding;
+        let text_available_width = ui.available_width() - total_extra.x;
+        let text_galley =
+            text.into_galley(ui, Some(true), text_available_width, text_style.clone());
+
+        let icon_available_width = text_available_width - text_galley.size().x;
+        let icon_galley = icon.into_galley(ui, Some(true), icon_available_width, text_style);
+        let text_and_icon_size = Vec2::new(
+            text_galley.size().x + icon_galley.size().x,
+            text_galley.size().y.max(icon_galley.size().y),
+        );
+        let mut desired_size = text_and_icon_size + 2.0 * button_padding;
+        desired_size.y = desired_size.y.at_least(ui.spacing().interact_size.y);
+
+        let (rect, response) = ui.allocate_at_least(desired_size, sense);
+        response.widget_info(|| {
+            crate::WidgetInfo::labeled(crate::WidgetType::Button, text_galley.text())
+        });
+
+        if ui.is_rect_visible(rect) {
+            let visuals = Self::visuals(ui, &response, menu_state, sub_id);
+            let text_pos = Align2::LEFT_CENTER
+                .align_size_within_rect(text_galley.size(), rect.shrink2(button_padding))
+                .min;
+            let icon_pos = Align2::RIGHT_CENTER
+                .align_size_within_rect(icon_galley.size(), rect.shrink2(button_padding))
+                .min;
+
+            if ui.visuals().button_frame {
+                ui.painter().rect_filled(
+                    rect.expand(visuals.expansion),
+                    visuals.rounding,
+                    visuals.weak_bg_fill,
+                );
+            }
+
+            let text_color = visuals.text_color();
+            text_galley.paint_with_fallback_color(ui.painter(), text_pos, text_color);
+            icon_galley.paint_with_fallback_color(ui.painter(), icon_pos, text_color);
+        }
+        response
+    }
+}
+
+pub struct SubMenu {
+    button: SubMenuButton,
+    parent_state: Arc<RwLock<MenuState>>,
+}
+
+impl SubMenu {
+    fn new(parent_state: Arc<RwLock<MenuState>>, text: impl Into<WidgetText>) -> Self {
+        let index = parent_state.write().next_entry_index();
+        Self {
+            button: SubMenuButton::new(text, "⏵", index),
+            parent_state,
+        }
+    }
+
+    pub fn show<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<Option<R>> {
+        let sub_id = ui.id().with(self.button.index);
+        let button = self.button.show(ui, &self.parent_state.read(), sub_id);
+        self.parent_state
+            .write()
+            .submenu_button_interaction(ui, sub_id, &button);
+        let inner = self
+            .parent_state
+            .write()
+            .show_submenu(ui.ctx(), sub_id, add_contents);
+        InnerResponse::new(inner, button)
+    }
+}
+
+pub(crate) struct MenuState {
+    /// The opened sub-menu and its [`Id`]
+    sub_menu: Option<(Id, Arc<RwLock<MenuState>>)>,
+
+    /// Bounding box of this menu (without the sub-menu)
+    pub rect: Rect,
+
+    /// Used to check if any menu in the tree wants to close
+    pub response: MenuResponse,
+
+    /// Used to hash different [`Id`]s for sub-menus
+    entry_count: usize,
+}
+
+impl MenuState {
+    pub fn new(position: Pos2) -> Self {
+        Self {
+            rect: Rect::from_min_size(position, Vec2::ZERO),
+            sub_menu: None,
+            response: MenuResponse::Stay,
+            entry_count: 0,
+        }
+    }
+
+    /// Close menu hierarchy.
+    pub fn close(&mut self) {
+        self.response = MenuResponse::Close;
+    }
+
+    pub fn show<R>(
+        ctx: &Context,
+        menu_state: &Arc<RwLock<Self>>,
+        id: Id,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        crate::menu::menu_ui(ctx, id, menu_state, add_contents)
+    }
+
+    fn show_submenu<R>(
+        &mut self,
+        ctx: &Context,
+        id: Id,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<R> {
+        let (sub_response, response) = self.submenu(id).map(|sub| {
+            let inner_response = Self::show(ctx, sub, id, add_contents);
+            (sub.read().response, inner_response.inner)
+        })?;
+        self.cascade_close_response(sub_response);
+        Some(response)
+    }
+
+    /// Check if position is in the menu hierarchy's area.
+    pub fn area_contains(&self, pos: Pos2) -> bool {
+        self.rect.contains(pos)
+            || self
+                .sub_menu
+                .as_ref()
+                .map_or(false, |(_, sub)| sub.read().area_contains(pos))
+    }
+
+    fn next_entry_index(&mut self) -> usize {
+        self.entry_count += 1;
+        self.entry_count - 1
+    }
+
+    /// Sense button interaction opening and closing submenu.
+    fn submenu_button_interaction(&mut self, ui: &mut Ui, sub_id: Id, button: &Response) {
+        let pointer = ui.input(|i| i.pointer.clone());
+        let open = self.is_open(sub_id);
+        if self.moving_towards_current_submenu(&pointer) {
+            // ensure to repaint once even when pointer is not moving
+            ui.ctx().request_repaint();
+        } else if !open && button.hovered() {
+            let pos = button.rect.right_top();
+            self.open_submenu(sub_id, pos);
+        } else if open && !button.hovered() && !self.hovering_current_submenu(&pointer) {
+            self.close_submenu();
+        }
+    }
+
+    /// Check if `dir` points from `pos` towards left side of `rect`.
+    fn points_at_left_of_rect(pos: Pos2, dir: Vec2, rect: Rect) -> bool {
+        let vel_a = dir.angle();
+        let top_a = (rect.left_top() - pos).angle();
+        let bottom_a = (rect.left_bottom() - pos).angle();
+        bottom_a - vel_a >= 0.0 && top_a - vel_a <= 0.0
+    }
+
+    /// Check if pointer is moving towards current submenu.
+    fn moving_towards_current_submenu(&self, pointer: &PointerState) -> bool {
+        if pointer.is_still() {
+            return false;
+        }
+        if let Some(sub_menu) = self.current_submenu() {
+            if let Some(pos) = pointer.hover_pos() {
+                return Self::points_at_left_of_rect(pos, pointer.velocity(), sub_menu.read().rect);
+            }
+        }
+        false
+    }
+
+    /// Check if pointer is hovering current submenu.
+    fn hovering_current_submenu(&self, pointer: &PointerState) -> bool {
+        if let Some(sub_menu) = self.current_submenu() {
+            if let Some(pos) = pointer.hover_pos() {
+                return sub_menu.read().area_contains(pos);
+            }
+        }
+        false
+    }
+
+    /// Cascade close response to menu root.
+    fn cascade_close_response(&mut self, response: MenuResponse) {
+        if response.is_close() {
+            self.response = response;
+        }
+    }
+
+    fn is_open(&self, id: Id) -> bool {
+        self.sub_id() == Some(id)
+    }
+
+    fn sub_id(&self) -> Option<Id> {
+        self.sub_menu.as_ref().map(|(id, _)| *id)
+    }
+
+    fn current_submenu(&self) -> Option<&Arc<RwLock<MenuState>>> {
+        self.sub_menu.as_ref().map(|(_, sub)| sub)
+    }
+
+    fn submenu(&mut self, id: Id) -> Option<&Arc<RwLock<MenuState>>> {
+        self.sub_menu
+            .as_ref()
+            .and_then(|(k, sub)| if id == *k { Some(sub) } else { None })
+    }
+
+    /// Open submenu at position, if not already open.
+    fn open_submenu(&mut self, id: Id, pos: Pos2) {
+        if !self.is_open(id) {
+            self.sub_menu = Some((id, Arc::new(RwLock::new(MenuState::new(pos)))));
+        }
+    }
+
+    fn close_submenu(&mut self) {
+        self.sub_menu = None;
+    }
+}
diff --git a/egui/crates/egui/src/os.rs b/egui/crates/egui/src/os.rs
new file mode 100644
index 0000000..530b20d
--- /dev/null
+++ b/egui/crates/egui/src/os.rs
@@ -0,0 +1,76 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum OperatingSystem {
+    /// Unknown OS - could be wasm
+    Unknown,
+
+    /// Android OS.
+    Android,
+
+    /// Apple iPhone OS.
+    IOS,
+
+    /// Linux or Unix other than Android.
+    Nix,
+
+    /// MacOS.
+    Mac,
+
+    /// Windows.
+    Windows,
+}
+
+impl Default for OperatingSystem {
+    fn default() -> Self {
+        Self::from_target_os()
+    }
+}
+
+impl OperatingSystem {
+    pub const fn from_target_os() -> Self {
+        if cfg!(target_arch = "wasm32") {
+            Self::Unknown
+        } else if cfg!(target_os = "android") {
+            Self::Android
+        } else if cfg!(target_os = "ios") {
+            Self::IOS
+        } else if cfg!(target_os = "macos") {
+            Self::Mac
+        } else if cfg!(target_os = "windows") {
+            Self::Windows
+        } else if cfg!(target_os = "linux")
+            || cfg!(target_os = "dragonfly")
+            || cfg!(target_os = "freebsd")
+            || cfg!(target_os = "netbsd")
+            || cfg!(target_os = "openbsd")
+        {
+            Self::Nix
+        } else {
+            Self::Unknown
+        }
+    }
+
+    /// Helper: try to guess from the user-agent of a browser.
+    pub fn from_user_agent(user_agent: &str) -> Self {
+        if user_agent.contains("Android") {
+            Self::Android
+        } else if user_agent.contains("like Mac") {
+            Self::IOS
+        } else if user_agent.contains("Win") {
+            Self::Windows
+        } else if user_agent.contains("Mac") {
+            Self::Mac
+        } else if user_agent.contains("Linux")
+            || user_agent.contains("X11")
+            || user_agent.contains("Unix")
+        {
+            Self::Nix
+        } else {
+            #[cfg(feature = "tracing")]
+            tracing::warn!(
+                "egui: Failed to guess operating system from User-Agent {:?}. Please file an issue at https://github.com/emilk/egui/issues",
+                user_agent);
+
+            Self::Unknown
+        }
+    }
+}
diff --git a/egui/crates/egui/src/painter.rs b/egui/crates/egui/src/painter.rs
new file mode 100644
index 0000000..214bbe1
--- /dev/null
+++ b/egui/crates/egui/src/painter.rs
@@ -0,0 +1,455 @@
+use std::ops::RangeInclusive;
+use std::sync::Arc;
+
+use crate::{
+    emath::{Align2, Pos2, Rect, Vec2},
+    layers::{LayerId, PaintList, ShapeIdx},
+    Color32, Context, FontId,
+};
+use epaint::{
+    text::{Fonts, Galley},
+    CircleShape, RectShape, Rounding, Shape, Stroke,
+};
+
+/// Helper to paint shapes and text to a specific region on a specific layer.
+///
+/// All coordinates are screen coordinates in the unit points (one point can consist of many physical pixels).
+#[derive(Clone)]
+pub struct Painter {
+    /// Source of fonts and destination of shapes
+    ctx: Context,
+
+    /// Where we paint
+    layer_id: LayerId,
+
+    /// Everything painted in this [`Painter`] will be clipped against this.
+    /// This means nothing outside of this rectangle will be visible on screen.
+    clip_rect: Rect,
+
+    /// If set, all shapes will have their colors modified to be closer to this.
+    /// This is used to implement grayed out interfaces.
+    fade_to_color: Option<Color32>,
+}
+
+impl Painter {
+    /// Create a painter to a specific layer within a certain clip rectangle.
+    pub fn new(ctx: Context, layer_id: LayerId, clip_rect: Rect) -> Self {
+        Self {
+            ctx,
+            layer_id,
+            clip_rect,
+            fade_to_color: None,
+        }
+    }
+
+    /// Redirect where you are painting.
+    #[must_use]
+    pub fn with_layer_id(self, layer_id: LayerId) -> Self {
+        Self {
+            ctx: self.ctx,
+            layer_id,
+            clip_rect: self.clip_rect,
+            fade_to_color: None,
+        }
+    }
+
+    /// Create a painter for a sub-region of this [`Painter`].
+    ///
+    /// The clip-rect of the returned [`Painter`] will be the intersection
+    /// of the given rectangle and the `clip_rect()` of the parent [`Painter`].
+    pub fn with_clip_rect(&self, rect: Rect) -> Self {
+        Self {
+            ctx: self.ctx.clone(),
+            layer_id: self.layer_id,
+            clip_rect: rect.intersect(self.clip_rect),
+            fade_to_color: self.fade_to_color,
+        }
+    }
+
+    /// Redirect where you are painting.
+    pub fn set_layer_id(&mut self, layer_id: LayerId) {
+        self.layer_id = layer_id;
+    }
+
+    /// If set, colors will be modified to look like this
+    pub(crate) fn set_fade_to_color(&mut self, fade_to_color: Option<Color32>) {
+        self.fade_to_color = fade_to_color;
+    }
+
+    pub(crate) fn is_visible(&self) -> bool {
+        self.fade_to_color != Some(Color32::TRANSPARENT)
+    }
+
+    /// If `false`, nothing added to the painter will be visible
+    pub(crate) fn set_invisible(&mut self) {
+        self.fade_to_color = Some(Color32::TRANSPARENT);
+    }
+
+    #[deprecated = "Use Painter::with_clip_rect"] // Deprecated in 2022-04-18, before egui 0.18
+    pub fn sub_region(&self, rect: Rect) -> Self {
+        Self {
+            ctx: self.ctx.clone(),
+            layer_id: self.layer_id,
+            clip_rect: rect.intersect(self.clip_rect),
+            fade_to_color: self.fade_to_color,
+        }
+    }
+}
+
+/// ## Accessors etc
+impl Painter {
+    /// Get a reference to the parent [`Context`].
+    #[inline(always)]
+    pub fn ctx(&self) -> &Context {
+        &self.ctx
+    }
+
+    /// Read-only access to the shared [`Fonts`].
+    ///
+    /// See [`Context`] documentation for how locks work.
+    #[inline(always)]
+    pub fn fonts<R>(&self, reader: impl FnOnce(&Fonts) -> R) -> R {
+        self.ctx.fonts(reader)
+    }
+
+    /// Where we paint
+    #[inline(always)]
+    pub fn layer_id(&self) -> LayerId {
+        self.layer_id
+    }
+
+    /// Everything painted in this [`Painter`] will be clipped against this.
+    /// This means nothing outside of this rectangle will be visible on screen.
+    #[inline(always)]
+    pub fn clip_rect(&self) -> Rect {
+        self.clip_rect
+    }
+
+    /// Everything painted in this [`Painter`] will be clipped against this.
+    /// This means nothing outside of this rectangle will be visible on screen.
+    #[inline(always)]
+    pub fn set_clip_rect(&mut self, clip_rect: Rect) {
+        self.clip_rect = clip_rect;
+    }
+
+    /// Useful for pixel-perfect rendering.
+    #[inline(always)]
+    pub fn round_to_pixel(&self, point: f32) -> f32 {
+        self.ctx().round_to_pixel(point)
+    }
+
+    /// Useful for pixel-perfect rendering.
+    #[inline(always)]
+    pub fn round_vec_to_pixels(&self, vec: Vec2) -> Vec2 {
+        self.ctx().round_vec_to_pixels(vec)
+    }
+
+    /// Useful for pixel-perfect rendering.
+    #[inline(always)]
+    pub fn round_pos_to_pixels(&self, pos: Pos2) -> Pos2 {
+        self.ctx().round_pos_to_pixels(pos)
+    }
+}
+
+/// ## Low level
+impl Painter {
+    #[inline]
+    fn paint_list<R>(&self, writer: impl FnOnce(&mut PaintList) -> R) -> R {
+        self.ctx.graphics_mut(|g| writer(g.list(self.layer_id)))
+    }
+
+    fn transform_shape(&self, shape: &mut Shape) {
+        if let Some(fade_to_color) = self.fade_to_color {
+            tint_shape_towards(shape, fade_to_color);
+        }
+    }
+
+    /// It is up to the caller to make sure there is room for this.
+    /// Can be used for free painting.
+    /// NOTE: all coordinates are screen coordinates!
+    pub fn add(&self, shape: impl Into<Shape>) -> ShapeIdx {
+        if self.fade_to_color == Some(Color32::TRANSPARENT) {
+            self.paint_list(|l| l.add(self.clip_rect, Shape::Noop))
+        } else {
+            let mut shape = shape.into();
+            self.transform_shape(&mut shape);
+            self.paint_list(|l| l.add(self.clip_rect, shape))
+        }
+    }
+
+    /// Add many shapes at once.
+    ///
+    /// Calling this once is generally faster than calling [`Self::add`] multiple times.
+    pub fn extend<I: IntoIterator<Item = Shape>>(&self, shapes: I) {
+        if self.fade_to_color == Some(Color32::TRANSPARENT) {
+            return;
+        }
+        if self.fade_to_color.is_some() {
+            let shapes = shapes.into_iter().map(|mut shape| {
+                self.transform_shape(&mut shape);
+                shape
+            });
+            self.paint_list(|l| l.extend(self.clip_rect, shapes));
+        } else {
+            self.paint_list(|l| l.extend(self.clip_rect, shapes));
+        };
+    }
+
+    /// Modify an existing [`Shape`].
+    pub fn set(&self, idx: ShapeIdx, shape: impl Into<Shape>) {
+        if self.fade_to_color == Some(Color32::TRANSPARENT) {
+            return;
+        }
+        let mut shape = shape.into();
+        self.transform_shape(&mut shape);
+        self.paint_list(|l| l.set(idx, self.clip_rect, shape));
+    }
+}
+
+/// ## Debug painting
+impl Painter {
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn debug_rect(&self, rect: Rect, color: Color32, text: impl ToString) {
+        self.rect(
+            rect,
+            0.0,
+            color.additive().linear_multiply(0.015),
+            (1.0, color),
+        );
+        self.text(
+            rect.min,
+            Align2::LEFT_TOP,
+            text.to_string(),
+            FontId::monospace(12.0),
+            color,
+        );
+    }
+
+    pub fn error(&self, pos: Pos2, text: impl std::fmt::Display) -> Rect {
+        let color = self.ctx.style().visuals.error_fg_color;
+        self.debug_text(pos, Align2::LEFT_TOP, color, format!("🔥 {}", text))
+    }
+
+    /// text with a background
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn debug_text(
+        &self,
+        pos: Pos2,
+        anchor: Align2,
+        color: Color32,
+        text: impl ToString,
+    ) -> Rect {
+        let galley = self.layout_no_wrap(text.to_string(), FontId::monospace(12.0), color);
+        let rect = anchor.anchor_rect(Rect::from_min_size(pos, galley.size()));
+        let frame_rect = rect.expand(2.0);
+        self.add(Shape::rect_filled(
+            frame_rect,
+            0.0,
+            Color32::from_black_alpha(150),
+        ));
+        self.galley(rect.min, galley);
+        frame_rect
+    }
+}
+
+/// # Paint different primitives
+impl Painter {
+    /// Paints a line from the first point to the second.
+    pub fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<Stroke>) {
+        self.add(Shape::LineSegment {
+            points,
+            stroke: stroke.into(),
+        });
+    }
+
+    /// Paints a horizontal line.
+    pub fn hline(&self, x: RangeInclusive<f32>, y: f32, stroke: impl Into<Stroke>) {
+        self.add(Shape::hline(x, y, stroke));
+    }
+
+    /// Paints a vertical line.
+    pub fn vline(&self, x: f32, y: RangeInclusive<f32>, stroke: impl Into<Stroke>) {
+        self.add(Shape::vline(x, y, stroke));
+    }
+
+    pub fn circle(
+        &self,
+        center: Pos2,
+        radius: f32,
+        fill_color: impl Into<Color32>,
+        stroke: impl Into<Stroke>,
+    ) {
+        self.add(CircleShape {
+            center,
+            radius,
+            fill: fill_color.into(),
+            stroke: stroke.into(),
+        });
+    }
+
+    pub fn circle_filled(&self, center: Pos2, radius: f32, fill_color: impl Into<Color32>) {
+        self.add(CircleShape {
+            center,
+            radius,
+            fill: fill_color.into(),
+            stroke: Default::default(),
+        });
+    }
+
+    pub fn circle_stroke(&self, center: Pos2, radius: f32, stroke: impl Into<Stroke>) {
+        self.add(CircleShape {
+            center,
+            radius,
+            fill: Default::default(),
+            stroke: stroke.into(),
+        });
+    }
+
+    pub fn rect(
+        &self,
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+        stroke: impl Into<Stroke>,
+    ) {
+        self.add(RectShape {
+            rect,
+            rounding: rounding.into(),
+            fill: fill_color.into(),
+            stroke: stroke.into(),
+        });
+    }
+
+    pub fn rect_filled(
+        &self,
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+    ) {
+        self.add(RectShape {
+            rect,
+            rounding: rounding.into(),
+            fill: fill_color.into(),
+            stroke: Default::default(),
+        });
+    }
+
+    pub fn rect_stroke(
+        &self,
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        stroke: impl Into<Stroke>,
+    ) {
+        self.add(RectShape {
+            rect,
+            rounding: rounding.into(),
+            fill: Default::default(),
+            stroke: stroke.into(),
+        });
+    }
+
+    /// Show an arrow starting at `origin` and going in the direction of `vec`, with the length `vec.length()`.
+    pub fn arrow(&self, origin: Pos2, vec: Vec2, stroke: Stroke) {
+        use crate::emath::*;
+        let rot = Rot2::from_angle(std::f32::consts::TAU / 10.0);
+        let tip_length = vec.length() / 4.0;
+        let tip = origin + vec;
+        let dir = vec.normalized();
+        self.line_segment([origin, tip], stroke);
+        self.line_segment([tip, tip - tip_length * (rot * dir)], stroke);
+        self.line_segment([tip, tip - tip_length * (rot.inverse() * dir)], stroke);
+    }
+
+    /// An image at the given position.
+    ///
+    /// `uv` should normally be `Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0))`
+    /// unless you want to crop or flip the image.
+    ///
+    /// `tint` is a color multiplier. Use [`Color32::WHITE`] if you don't want to tint the image.
+    pub fn image(&self, texture_id: epaint::TextureId, rect: Rect, uv: Rect, tint: Color32) {
+        self.add(Shape::image(texture_id, rect, uv, tint));
+    }
+}
+
+/// ## Text
+impl Painter {
+    /// Lay out and paint some text.
+    ///
+    /// To center the text at the given position, use `Align2::CENTER_CENTER`.
+    ///
+    /// To find out the size of text before painting it, use
+    /// [`Self::layout`] or [`Self::layout_no_wrap`].
+    ///
+    /// Returns where the text ended up.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn text(
+        &self,
+        pos: Pos2,
+        anchor: Align2,
+        text: impl ToString,
+        font_id: FontId,
+        text_color: Color32,
+    ) -> Rect {
+        let galley = self.layout_no_wrap(text.to_string(), font_id, text_color);
+        let rect = anchor.anchor_rect(Rect::from_min_size(pos, galley.size()));
+        self.galley(rect.min, galley);
+        rect
+    }
+
+    /// Will wrap text at the given width and line break at `\n`.
+    ///
+    /// Paint the results with [`Self::galley`].
+    #[inline(always)]
+    pub fn layout(
+        &self,
+        text: String,
+        font_id: FontId,
+        color: crate::Color32,
+        wrap_width: f32,
+    ) -> Arc<Galley> {
+        self.fonts(|f| f.layout(text, font_id, color, wrap_width))
+    }
+
+    /// Will line break at `\n`.
+    ///
+    /// Paint the results with [`Self::galley`].
+    #[inline(always)]
+    pub fn layout_no_wrap(
+        &self,
+        text: String,
+        font_id: FontId,
+        color: crate::Color32,
+    ) -> Arc<Galley> {
+        self.fonts(|f| f.layout(text, font_id, color, f32::INFINITY))
+    }
+
+    /// Paint text that has already been laid out in a [`Galley`].
+    ///
+    /// You can create the [`Galley`] with [`Self::layout`].
+    ///
+    /// If you want to change the color of the text, use [`Self::galley_with_color`].
+    #[inline(always)]
+    pub fn galley(&self, pos: Pos2, galley: Arc<Galley>) {
+        if !galley.is_empty() {
+            self.add(Shape::galley(pos, galley));
+        }
+    }
+
+    /// Paint text that has already been laid out in a [`Galley`].
+    ///
+    /// You can create the [`Galley`] with [`Self::layout`].
+    ///
+    /// The text color in the [`Galley`] will be replaced with the given color.
+    #[inline(always)]
+    pub fn galley_with_color(&self, pos: Pos2, galley: Arc<Galley>, text_color: Color32) {
+        if !galley.is_empty() {
+            self.add(Shape::galley_with_color(pos, galley, text_color));
+        }
+    }
+}
+
+fn tint_shape_towards(shape: &mut Shape, target: Color32) {
+    epaint::shape_transform::adjust_colors(shape, &|color| {
+        *color = crate::ecolor::tint_color_towards(*color, target);
+    });
+}
diff --git a/egui/crates/egui/src/placer.rs b/egui/crates/egui/src/placer.rs
new file mode 100644
index 0000000..c9f9dde
--- /dev/null
+++ b/egui/crates/egui/src/placer.rs
@@ -0,0 +1,279 @@
+use crate::*;
+
+pub(crate) struct Placer {
+    /// If set this will take precedence over [`layout`].
+    grid: Option<grid::GridLayout>,
+    layout: Layout,
+    region: Region,
+}
+
+impl Placer {
+    pub(crate) fn new(max_rect: Rect, layout: Layout) -> Self {
+        let region = layout.region_from_max_rect(max_rect);
+        Self {
+            grid: None,
+            layout,
+            region,
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn set_grid(&mut self, grid: grid::GridLayout) {
+        self.grid = Some(grid);
+    }
+
+    pub(crate) fn save_grid(&mut self) {
+        if let Some(grid) = &mut self.grid {
+            grid.save();
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn grid(&self) -> Option<&grid::GridLayout> {
+        self.grid.as_ref()
+    }
+
+    #[inline(always)]
+    pub(crate) fn is_grid(&self) -> bool {
+        self.grid.is_some()
+    }
+
+    #[inline(always)]
+    pub(crate) fn layout(&self) -> &Layout {
+        &self.layout
+    }
+
+    #[inline(always)]
+    pub(crate) fn prefer_right_to_left(&self) -> bool {
+        self.layout.prefer_right_to_left()
+    }
+
+    #[inline(always)]
+    pub(crate) fn min_rect(&self) -> Rect {
+        self.region.min_rect
+    }
+
+    #[inline(always)]
+    pub(crate) fn max_rect(&self) -> Rect {
+        self.region.max_rect
+    }
+
+    #[inline(always)]
+    pub(crate) fn force_set_min_rect(&mut self, min_rect: Rect) {
+        self.region.min_rect = min_rect;
+    }
+
+    #[inline(always)]
+    pub(crate) fn cursor(&self) -> Rect {
+        self.region.cursor
+    }
+
+    #[inline(always)]
+    pub(crate) fn set_cursor(&mut self, cursor: Rect) {
+        self.region.cursor = cursor;
+    }
+}
+
+impl Placer {
+    pub(crate) fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect {
+        if let Some(grid) = &self.grid {
+            grid.align_size_within_rect(size, outer)
+        } else {
+            self.layout.align_size_within_rect(size, outer)
+        }
+    }
+
+    pub(crate) fn available_rect_before_wrap(&self) -> Rect {
+        if let Some(grid) = &self.grid {
+            grid.available_rect(&self.region)
+        } else {
+            self.layout.available_rect_before_wrap(&self.region)
+        }
+    }
+
+    /// Amount of space available for a widget.
+    /// For wrapping layouts, this is the maximum (after wrap).
+    pub(crate) fn available_size(&self) -> Vec2 {
+        if let Some(grid) = &self.grid {
+            grid.available_rect(&self.region).size()
+        } else {
+            self.layout.available_size(&self.region)
+        }
+    }
+
+    /// Returns where to put the next widget that is of the given size.
+    /// The returned `frame_rect` will always be justified along the cross axis.
+    /// This is what you then pass to `advance_after_rects`.
+    /// Use `justify_and_align` to get the inner `widget_rect`.
+    pub(crate) fn next_space(&self, child_size: Vec2, item_spacing: Vec2) -> Rect {
+        egui_assert!(child_size.is_finite() && child_size.x >= 0.0 && child_size.y >= 0.0);
+        self.region.sanity_check();
+        if let Some(grid) = &self.grid {
+            grid.next_cell(self.region.cursor, child_size)
+        } else {
+            self.layout
+                .next_frame(&self.region, child_size, item_spacing)
+        }
+    }
+
+    /// Where do we expect a zero-sized widget to be placed?
+    pub(crate) fn next_widget_position(&self) -> Pos2 {
+        if let Some(grid) = &self.grid {
+            grid.next_cell(self.region.cursor, Vec2::ZERO).center()
+        } else {
+            self.layout.next_widget_position(&self.region)
+        }
+    }
+
+    /// Apply justify or alignment after calling `next_space`.
+    pub(crate) fn justify_and_align(&self, rect: Rect, child_size: Vec2) -> Rect {
+        crate::egui_assert!(!rect.any_nan());
+        crate::egui_assert!(!child_size.any_nan());
+
+        if let Some(grid) = &self.grid {
+            grid.justify_and_align(rect, child_size)
+        } else {
+            self.layout.justify_and_align(rect, child_size)
+        }
+    }
+
+    /// Advance the cursor by this many points.
+    /// [`Self::min_rect`] will expand to contain the cursor.
+    pub(crate) fn advance_cursor(&mut self, amount: f32) {
+        crate::egui_assert!(
+            self.grid.is_none(),
+            "You cannot advance the cursor when in a grid layout"
+        );
+        self.layout.advance_cursor(&mut self.region, amount);
+    }
+
+    /// Advance cursor after a widget was added to a specific rectangle
+    /// and expand the region `min_rect`.
+    ///
+    /// * `frame_rect`: the frame inside which a widget was e.g. centered
+    /// * `widget_rect`: the actual rect used by the widget
+    pub(crate) fn advance_after_rects(
+        &mut self,
+        frame_rect: Rect,
+        widget_rect: Rect,
+        item_spacing: Vec2,
+    ) {
+        egui_assert!(!frame_rect.any_nan());
+        egui_assert!(!widget_rect.any_nan());
+        self.region.sanity_check();
+
+        if let Some(grid) = &mut self.grid {
+            grid.advance(&mut self.region.cursor, frame_rect, widget_rect);
+        } else {
+            self.layout.advance_after_rects(
+                &mut self.region.cursor,
+                frame_rect,
+                widget_rect,
+                item_spacing,
+            );
+        }
+
+        self.expand_to_include_rect(frame_rect); // e.g. for centered layouts: pretend we used whole frame
+
+        self.region.sanity_check();
+    }
+
+    /// Move to the next row in a grid layout or wrapping layout.
+    /// Otherwise does nothing.
+    pub(crate) fn end_row(&mut self, item_spacing: Vec2, painter: &Painter) {
+        if let Some(grid) = &mut self.grid {
+            grid.end_row(&mut self.region.cursor, painter);
+        } else {
+            self.layout.end_row(&mut self.region, item_spacing);
+        }
+    }
+
+    /// Set row height in horizontal wrapping layout.
+    pub(crate) fn set_row_height(&mut self, height: f32) {
+        self.layout.set_row_height(&mut self.region, height);
+    }
+}
+
+impl Placer {
+    /// Expand the `min_rect` and `max_rect` of this ui to include a child at the given rect.
+    pub(crate) fn expand_to_include_rect(&mut self, rect: Rect) {
+        self.region.expand_to_include_rect(rect);
+    }
+
+    /// Expand the `min_rect` and `max_rect` of this ui to include a child at the given x-coordinate.
+    pub(crate) fn expand_to_include_x(&mut self, x: f32) {
+        self.region.expand_to_include_x(x);
+    }
+
+    /// Expand the `min_rect` and `max_rect` of this ui to include a child at the given y-coordinate.
+    pub(crate) fn expand_to_include_y(&mut self, y: f32) {
+        self.region.expand_to_include_y(y);
+    }
+
+    fn next_widget_space_ignore_wrap_justify(&self, size: Vec2) -> Rect {
+        self.layout
+            .next_widget_space_ignore_wrap_justify(&self.region, size)
+    }
+
+    /// Set the maximum width of the ui.
+    /// You won't be able to shrink it below the current minimum size.
+    pub(crate) fn set_max_width(&mut self, width: f32) {
+        let rect = self.next_widget_space_ignore_wrap_justify(vec2(width, 0.0));
+        let region = &mut self.region;
+        region.max_rect.min.x = rect.min.x;
+        region.max_rect.max.x = rect.max.x;
+        region.max_rect = region.max_rect.union(region.min_rect); // make sure we didn't shrink too much
+
+        region.cursor.min.x = region.max_rect.min.x;
+        region.cursor.max.x = region.max_rect.max.x;
+
+        region.sanity_check();
+    }
+
+    /// Set the maximum height of the ui.
+    /// You won't be able to shrink it below the current minimum size.
+    pub(crate) fn set_max_height(&mut self, height: f32) {
+        let rect = self.next_widget_space_ignore_wrap_justify(vec2(0.0, height));
+        let region = &mut self.region;
+        region.max_rect.min.y = rect.min.y;
+        region.max_rect.max.y = rect.max.y;
+        region.max_rect = region.max_rect.union(region.min_rect); // make sure we didn't shrink too much
+
+        region.cursor.min.y = region.max_rect.min.y;
+        region.cursor.max.y = region.max_rect.max.y;
+
+        region.sanity_check();
+    }
+
+    /// Set the minimum width of the ui.
+    /// This can't shrink the ui, only make it larger.
+    pub(crate) fn set_min_width(&mut self, width: f32) {
+        let rect = self.next_widget_space_ignore_wrap_justify(vec2(width, 0.0));
+        self.region.expand_to_include_x(rect.min.x);
+        self.region.expand_to_include_x(rect.max.x);
+    }
+
+    /// Set the minimum height of the ui.
+    /// This can't shrink the ui, only make it larger.
+    pub(crate) fn set_min_height(&mut self, height: f32) {
+        let rect = self.next_widget_space_ignore_wrap_justify(vec2(0.0, height));
+        self.region.expand_to_include_y(rect.min.y);
+        self.region.expand_to_include_y(rect.max.y);
+    }
+}
+
+impl Placer {
+    pub(crate) fn debug_paint_cursor(&self, painter: &crate::Painter, text: impl ToString) {
+        let stroke = Stroke::new(1.0, Color32::DEBUG_COLOR);
+
+        if let Some(grid) = &self.grid {
+            let rect = grid.next_cell(self.cursor(), Vec2::splat(0.0));
+            painter.rect_stroke(rect, 1.0, stroke);
+            let align = Align2::CENTER_CENTER;
+            painter.debug_text(align.pos_in_rect(&rect), align, stroke.color, text);
+        } else {
+            self.layout
+                .paint_text_at_cursor(painter, &self.region, stroke, text);
+        }
+    }
+}
diff --git a/egui/crates/egui/src/response.rs b/egui/crates/egui/src/response.rs
new file mode 100644
index 0000000..ac40882
--- /dev/null
+++ b/egui/crates/egui/src/response.rs
@@ -0,0 +1,820 @@
+use crate::{
+    emath::{Align, Pos2, Rect, Vec2},
+    menu, Context, CursorIcon, Id, LayerId, PointerButton, Sense, Ui, WidgetText,
+    NUM_POINTER_BUTTONS,
+};
+
+// ----------------------------------------------------------------------------
+
+/// The result of adding a widget to a [`Ui`].
+///
+/// A [`Response`] lets you know whether or not a widget is being hovered, clicked or dragged.
+/// It also lets you easily show a tooltip on hover.
+///
+/// Whenever something gets added to a [`Ui`], a [`Response`] object is returned.
+/// [`ui.add`] returns a [`Response`], as does [`ui.button`], and all similar shortcuts.
+// TODO(emilk): we should be using bit sets instead of so many bools
+#[derive(Clone)]
+pub struct Response {
+    // CONTEXT:
+    /// Used for optionally showing a tooltip and checking for more interactions.
+    pub ctx: Context,
+
+    // IN:
+    /// Which layer the widget is part of.
+    pub layer_id: LayerId,
+
+    /// The [`Id`] of the widget/area this response pertains.
+    pub id: Id,
+
+    /// The area of the screen we are talking about.
+    pub rect: Rect,
+
+    /// The senses (click and/or drag) that the widget was interested in (if any).
+    pub sense: Sense,
+
+    /// Was the widget enabled?
+    /// If `false`, there was no interaction attempted (not even hover).
+    #[doc(hidden)]
+    pub enabled: bool,
+
+    // OUT:
+    /// The pointer is hovering above this widget or the widget was clicked/tapped this frame.
+    #[doc(hidden)]
+    pub hovered: bool,
+
+    /// The widget is highlighted via a call to [`Self::highlight`] or [`Context::highlight_widget`].
+    #[doc(hidden)]
+    pub highlighted: bool,
+
+    /// The pointer clicked this thing this frame.
+    #[doc(hidden)]
+    pub clicked: [bool; NUM_POINTER_BUTTONS],
+
+    // TODO(emilk): `released` for sliders
+    /// The thing was double-clicked.
+    #[doc(hidden)]
+    pub double_clicked: [bool; NUM_POINTER_BUTTONS],
+
+    /// The thing was triple-clicked.
+    #[doc(hidden)]
+    pub triple_clicked: [bool; NUM_POINTER_BUTTONS],
+
+    /// The widgets is being dragged
+    #[doc(hidden)]
+    pub dragged: bool,
+
+    /// The widget was being dragged, but now it has been released.
+    #[doc(hidden)]
+    pub drag_released: bool,
+
+    /// Is the pointer button currently down on this widget?
+    /// This is true if the pointer is pressing down or dragging a widget
+    #[doc(hidden)]
+    pub is_pointer_button_down_on: bool,
+
+    /// Where the pointer (mouse/touch) were when when this widget was clicked or dragged.
+    /// `None` if the widget is not being interacted with.
+    #[doc(hidden)]
+    pub interact_pointer_pos: Option<Pos2>,
+
+    /// What the underlying data changed?
+    ///
+    /// e.g. the slider was dragged, text was entered in a [`TextEdit`](crate::TextEdit) etc.
+    /// Always `false` for something like a [`Button`](crate::Button).
+    #[doc(hidden)]
+    pub changed: bool,
+}
+
+impl std::fmt::Debug for Response {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self {
+            ctx: _,
+            layer_id,
+            id,
+            rect,
+            sense,
+            enabled,
+            hovered,
+            highlighted,
+            clicked,
+            double_clicked,
+            triple_clicked,
+            dragged,
+            drag_released,
+            is_pointer_button_down_on,
+            interact_pointer_pos,
+            changed,
+        } = self;
+        f.debug_struct("Response")
+            .field("layer_id", layer_id)
+            .field("id", id)
+            .field("rect", rect)
+            .field("sense", sense)
+            .field("enabled", enabled)
+            .field("hovered", hovered)
+            .field("highlighted", highlighted)
+            .field("clicked", clicked)
+            .field("double_clicked", double_clicked)
+            .field("triple_clicked", triple_clicked)
+            .field("dragged", dragged)
+            .field("drag_released", drag_released)
+            .field("is_pointer_button_down_on", is_pointer_button_down_on)
+            .field("interact_pointer_pos", interact_pointer_pos)
+            .field("changed", changed)
+            .finish()
+    }
+}
+
+impl Response {
+    /// Returns true if this widget was clicked this frame by the primary button.
+    ///
+    /// A click is registered when the mouse or touch is released within
+    /// a certain amount of time and distance from when and where it was pressed.
+    ///
+    /// Note that the widget must be sensing clicks with [`Sense::click`].
+    /// [`crate::Button`] senses clicks; [`crate::Label`] does not (unless you call [`crate::Label::sense`]).
+    ///
+    /// You can use [`Self::interact`] to sense more things *after* adding a widget.
+    #[inline(always)]
+    pub fn clicked(&self) -> bool {
+        self.clicked[PointerButton::Primary as usize]
+    }
+
+    /// Returns true if this widget was clicked this frame by the given button.
+    pub fn clicked_by(&self, button: PointerButton) -> bool {
+        self.clicked[button as usize]
+    }
+
+    /// Returns true if this widget was clicked this frame by the secondary mouse button (e.g. the right mouse button).
+    pub fn secondary_clicked(&self) -> bool {
+        self.clicked[PointerButton::Secondary as usize]
+    }
+
+    /// Returns true if this widget was clicked this frame by the middle mouse button.
+    pub fn middle_clicked(&self) -> bool {
+        self.clicked[PointerButton::Middle as usize]
+    }
+
+    /// Returns true if this widget was double-clicked this frame by the primary button.
+    pub fn double_clicked(&self) -> bool {
+        self.double_clicked[PointerButton::Primary as usize]
+    }
+
+    /// Returns true if this widget was triple-clicked this frame by the primary button.
+    pub fn triple_clicked(&self) -> bool {
+        self.triple_clicked[PointerButton::Primary as usize]
+    }
+
+    /// Returns true if this widget was double-clicked this frame by the given button.
+    pub fn double_clicked_by(&self, button: PointerButton) -> bool {
+        self.double_clicked[button as usize]
+    }
+
+    /// Returns true if this widget was triple-clicked this frame by the given button.
+    pub fn triple_clicked_by(&self, button: PointerButton) -> bool {
+        self.triple_clicked[button as usize]
+    }
+
+    /// `true` if there was a click *outside* this widget this frame.
+    pub fn clicked_elsewhere(&self) -> bool {
+        // We do not use self.clicked(), because we want to catch all clicks within our frame,
+        // even if we aren't clickable (or even enabled).
+        // This is important for windows and such that should close then the user clicks elsewhere.
+        self.ctx.input(|i| {
+            let pointer = &i.pointer;
+
+            if pointer.any_click() {
+                // We detect clicks/hover on a "interact_rect" that is slightly larger than
+                // self.rect. See Context::interact.
+                // This means we can be hovered and clicked even though `!self.rect.contains(pos)` is true,
+                // hence the extra complexity here.
+                if self.hovered() {
+                    false
+                } else if let Some(pos) = pointer.interact_pos() {
+                    !self.rect.contains(pos)
+                } else {
+                    false // clicked without a pointer, weird
+                }
+            } else {
+                false
+            }
+        })
+    }
+
+    /// Was the widget enabled?
+    /// If false, there was no interaction attempted
+    /// and the widget should be drawn in a gray disabled look.
+    #[inline(always)]
+    pub fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// The pointer is hovering above this widget or the widget was clicked/tapped this frame.
+    ///
+    /// Note that this is slightly different from checking `response.rect.contains(pointer_pos)`.
+    /// For one, the hover rectangle is slightly larger, by half of the current item spacing
+    /// (to make it easier to click things). But `hovered` also checks that no other area
+    /// is covering this response rectangle.
+    #[inline(always)]
+    pub fn hovered(&self) -> bool {
+        self.hovered
+    }
+
+    /// The widget is highlighted via a call to [`Self::highlight`] or [`Context::highlight_widget`].
+    #[doc(hidden)]
+    pub fn highlighted(&self) -> bool {
+        self.highlighted
+    }
+
+    /// This widget has the keyboard focus (i.e. is receiving key presses).
+    ///
+    /// This function only returns true if the UI as a whole (e.g. window)
+    /// also has the keyboard focus. That makes this function suitable
+    /// for style choices, e.g. a thicker border around focused widgets.
+    pub fn has_focus(&self) -> bool {
+        self.ctx.input(|i| i.raw.has_focus) && self.ctx.memory(|mem| mem.has_focus(self.id))
+    }
+
+    /// True if this widget has keyboard focus this frame, but didn't last frame.
+    pub fn gained_focus(&self) -> bool {
+        self.ctx.memory(|mem| mem.gained_focus(self.id))
+    }
+
+    /// The widget had keyboard focus and lost it,
+    /// either because the user pressed tab or clicked somewhere else,
+    /// or (in case of a [`crate::TextEdit`]) because the user pressed enter.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_text = String::new();
+    /// # fn do_request(_: &str) {}
+    /// let response = ui.text_edit_singleline(&mut my_text);
+    /// if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+    ///     do_request(&my_text);
+    /// }
+    /// # });
+    /// ```
+    pub fn lost_focus(&self) -> bool {
+        self.ctx.memory(|mem| mem.lost_focus(self.id))
+    }
+
+    /// Request that this widget get keyboard focus.
+    pub fn request_focus(&self) {
+        self.ctx.memory_mut(|mem| mem.request_focus(self.id));
+    }
+
+    /// Surrender keyboard focus for this widget.
+    pub fn surrender_focus(&self) {
+        self.ctx.memory_mut(|mem| mem.surrender_focus(self.id));
+    }
+
+    /// The widgets is being dragged.
+    ///
+    /// To find out which button(s), query [`crate::PointerState::button_down`]
+    /// (`ui.input(|i| i.pointer.button_down(…))`).
+    ///
+    /// Note that the widget must be sensing drags with [`Sense::drag`].
+    /// [`crate::DragValue`] senses drags; [`crate::Label`] does not (unless you call [`crate::Label::sense`]).
+    ///
+    /// You can use [`Self::interact`] to sense more things *after* adding a widget.
+    #[inline(always)]
+    pub fn dragged(&self) -> bool {
+        self.dragged
+    }
+
+    pub fn dragged_by(&self, button: PointerButton) -> bool {
+        self.dragged() && self.ctx.input(|i| i.pointer.button_down(button))
+    }
+
+    /// Did a drag on this widgets begin this frame?
+    pub fn drag_started(&self) -> bool {
+        self.dragged && self.ctx.input(|i| i.pointer.any_pressed())
+    }
+
+    /// Did a drag on this widgets by the button begin this frame?
+    pub fn drag_started_by(&self, button: PointerButton) -> bool {
+        self.drag_started() && self.ctx.input(|i| i.pointer.button_pressed(button))
+    }
+
+    /// The widget was being dragged, but now it has been released.
+    pub fn drag_released(&self) -> bool {
+        self.drag_released
+    }
+
+    /// The widget was being dragged by the button, but now it has been released.
+    pub fn drag_released_by(&self, button: PointerButton) -> bool {
+        self.drag_released() && self.ctx.input(|i| i.pointer.button_released(button))
+    }
+
+    /// If dragged, how many points were we dragged and in what direction?
+    pub fn drag_delta(&self) -> Vec2 {
+        if self.dragged() {
+            self.ctx.input(|i| i.pointer.delta())
+        } else {
+            Vec2::ZERO
+        }
+    }
+
+    /// Where the pointer (mouse/touch) were when when this widget was clicked or dragged.
+    /// `None` if the widget is not being interacted with.
+    pub fn interact_pointer_pos(&self) -> Option<Pos2> {
+        self.interact_pointer_pos
+    }
+
+    /// If it is a good idea to show a tooltip, where is pointer?
+    /// None if the pointer is outside the response area.
+    pub fn hover_pos(&self) -> Option<Pos2> {
+        if self.hovered() {
+            self.ctx.input(|i| i.pointer.hover_pos())
+        } else {
+            None
+        }
+    }
+
+    /// Is the pointer button currently down on this widget?
+    /// This is true if the pointer is pressing down or dragging a widget
+    #[inline(always)]
+    pub fn is_pointer_button_down_on(&self) -> bool {
+        self.is_pointer_button_down_on
+    }
+
+    /// What the underlying data changed?
+    ///
+    /// e.g. the slider was dragged, text was entered in a [`TextEdit`](crate::TextEdit) etc.
+    /// Always `false` for something like a [`Button`](crate::Button).
+    ///
+    /// Can sometimes be `true` even though the data didn't changed
+    /// (e.g. if the user entered a character and erased it the same frame).
+    ///
+    /// This is not set if the *view* of the data was changed.
+    /// For instance, moving the cursor in a [`TextEdit`](crate::TextEdit) does not set this to `true`.
+    #[inline(always)]
+    pub fn changed(&self) -> bool {
+        self.changed
+    }
+
+    /// Report the data shown by this widget changed.
+    ///
+    /// This must be called by widgets that represent some mutable data,
+    /// e.g. checkboxes, sliders etc.
+    ///
+    /// This should be called when the *content* changes, but not when the view does.
+    /// So we call this when the text of a [`crate::TextEdit`], but not when the cursors changes.
+    #[inline(always)]
+    pub fn mark_changed(&mut self) {
+        self.changed = true;
+    }
+
+    /// Show this UI if the widget was hovered (i.e. a tooltip).
+    ///
+    /// The text will not be visible if the widget is not enabled.
+    /// For that, use [`Self::on_disabled_hover_ui`] instead.
+    ///
+    /// If you call this multiple times the tooltips will stack underneath the previous ones.
+    #[doc(alias = "tooltip")]
+    pub fn on_hover_ui(self, add_contents: impl FnOnce(&mut Ui)) -> Self {
+        if self.should_show_hover_ui() {
+            crate::containers::show_tooltip_for(
+                &self.ctx,
+                self.id.with("__tooltip"),
+                &self.rect,
+                add_contents,
+            );
+        }
+        self
+    }
+
+    /// Show this UI when hovering if the widget is disabled.
+    pub fn on_disabled_hover_ui(self, add_contents: impl FnOnce(&mut Ui)) -> Self {
+        if !self.enabled && self.ctx.rect_contains_pointer(self.layer_id, self.rect) {
+            crate::containers::show_tooltip_for(
+                &self.ctx,
+                self.id.with("__tooltip"),
+                &self.rect,
+                add_contents,
+            );
+        }
+        self
+    }
+
+    /// Like `on_hover_ui`, but show the ui next to cursor.
+    pub fn on_hover_ui_at_pointer(self, add_contents: impl FnOnce(&mut Ui)) -> Self {
+        if self.should_show_hover_ui() {
+            crate::containers::show_tooltip_at_pointer(
+                &self.ctx,
+                self.id.with("__tooltip"),
+                add_contents,
+            );
+        }
+        self
+    }
+
+    /// Was the tooltip open last frame?
+    pub fn is_tooltip_open(&self) -> bool {
+        crate::popup::was_tooltip_open_last_frame(&self.ctx, self.id.with("__tooltip"))
+    }
+
+    fn should_show_hover_ui(&self) -> bool {
+        if self.ctx.memory(|mem| mem.everything_is_visible()) {
+            return true;
+        }
+
+        if !self.hovered || !self.ctx.input(|i| i.pointer.has_pointer()) {
+            return false;
+        }
+
+        if self.ctx.style().interaction.show_tooltips_only_when_still {
+            // We only show the tooltip when the mouse pointer is still,
+            // but once shown we keep showing it until the mouse leaves the parent.
+
+            if !self.ctx.input(|i| i.pointer.is_still()) && !self.is_tooltip_open() {
+                // wait for mouse to stop
+                self.ctx.request_repaint();
+                return false;
+            }
+        }
+
+        // We don't want tooltips of things while we are dragging them,
+        // but we do want tooltips while holding down on an item on a touch screen.
+        if self
+            .ctx
+            .input(|i| i.pointer.any_down() && i.pointer.has_moved_too_much_for_a_click)
+        {
+            return false;
+        }
+
+        true
+    }
+
+    /// Like `on_hover_text`, but show the text next to cursor.
+    #[doc(alias = "tooltip")]
+    pub fn on_hover_text_at_pointer(self, text: impl Into<WidgetText>) -> Self {
+        self.on_hover_ui_at_pointer(|ui| {
+            ui.add(crate::widgets::Label::new(text));
+        })
+    }
+
+    /// Show this text if the widget was hovered (i.e. a tooltip).
+    ///
+    /// The text will not be visible if the widget is not enabled.
+    /// For that, use [`Self::on_disabled_hover_text`] instead.
+    ///
+    /// If you call this multiple times the tooltips will stack underneath the previous ones.
+    #[doc(alias = "tooltip")]
+    pub fn on_hover_text(self, text: impl Into<WidgetText>) -> Self {
+        self.on_hover_ui(|ui| {
+            ui.add(crate::widgets::Label::new(text));
+        })
+    }
+
+    /// Highlight this widget, to make it look like it is hovered, even if it isn't.
+    ///
+    /// The highlight takes on frame to take effect if you call this after the widget has been fully rendered.
+    ///
+    /// See also [`Context::highlight_widget`].
+    pub fn highlight(mut self) -> Self {
+        self.ctx.highlight_widget(self.id);
+        self.highlighted = true;
+        self
+    }
+
+    /// Show this text when hovering if the widget is disabled.
+    pub fn on_disabled_hover_text(self, text: impl Into<WidgetText>) -> Self {
+        self.on_disabled_hover_ui(|ui| {
+            ui.add(crate::widgets::Label::new(text));
+        })
+    }
+
+    /// When hovered, use this icon for the mouse cursor.
+    pub fn on_hover_cursor(self, cursor: CursorIcon) -> Self {
+        if self.hovered() {
+            self.ctx.set_cursor_icon(cursor);
+        }
+        self
+    }
+
+    /// When hovered or dragged, use this icon for the mouse cursor.
+    pub fn on_hover_and_drag_cursor(self, cursor: CursorIcon) -> Self {
+        if self.hovered() || self.dragged() {
+            self.ctx.set_cursor_icon(cursor);
+        }
+        self
+    }
+
+    /// Check for more interactions (e.g. sense clicks on a [`Response`] returned from a label).
+    ///
+    /// Note that this call will not add any hover-effects to the widget, so when possible
+    /// it is better to give the widget a [`Sense`] instead, e.g. using [`crate::Label::sense`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// let response = ui.label("hello");
+    /// assert!(!response.clicked()); // labels don't sense clicks by default
+    /// let response = response.interact(egui::Sense::click());
+    /// if response.clicked() { /* … */ }
+    /// # });
+    /// ```
+    #[must_use]
+    pub fn interact(&self, sense: Sense) -> Self {
+        self.ctx.interact_with_hovered(
+            self.layer_id,
+            self.id,
+            self.rect,
+            sense,
+            self.enabled,
+            self.hovered,
+        )
+    }
+
+    /// Adjust the scroll position until this UI becomes visible.
+    ///
+    /// If `align` is `None`, it'll scroll enough to bring the UI into view.
+    ///
+    /// See also: [`Ui::scroll_to_cursor`], [`Ui::scroll_to_rect`]. [`Ui::scroll_with_delta`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// egui::ScrollArea::vertical().show(ui, |ui| {
+    ///     for i in 0..1000 {
+    ///         let response = ui.button("Scroll to me");
+    ///         if response.clicked() {
+    ///             response.scroll_to_me(Some(egui::Align::Center));
+    ///         }
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn scroll_to_me(&self, align: Option<Align>) {
+        self.ctx.frame_state_mut(|state| {
+            state.scroll_target[0] = Some((self.rect.x_range(), align));
+            state.scroll_target[1] = Some((self.rect.y_range(), align));
+        });
+    }
+
+    /// For accessibility.
+    ///
+    /// Call after interacting and potential calls to [`Self::mark_changed`].
+    pub fn widget_info(&self, make_info: impl Fn() -> crate::WidgetInfo) {
+        use crate::output::OutputEvent;
+        let event = if self.clicked() {
+            Some(OutputEvent::Clicked(make_info()))
+        } else if self.double_clicked() {
+            Some(OutputEvent::DoubleClicked(make_info()))
+        } else if self.triple_clicked() {
+            Some(OutputEvent::TripleClicked(make_info()))
+        } else if self.gained_focus() {
+            Some(OutputEvent::FocusGained(make_info()))
+        } else if self.changed {
+            Some(OutputEvent::ValueChanged(make_info()))
+        } else {
+            None
+        };
+        if let Some(event) = event {
+            self.output_event(event);
+        } else {
+            #[cfg(feature = "accesskit")]
+            self.ctx.accesskit_node_builder(self.id, |builder| {
+                self.fill_accesskit_node_from_widget_info(builder, make_info());
+            });
+        }
+    }
+
+    pub fn output_event(&self, event: crate::output::OutputEvent) {
+        #[cfg(feature = "accesskit")]
+        self.ctx.accesskit_node_builder(self.id, |builder| {
+            self.fill_accesskit_node_from_widget_info(builder, event.widget_info().clone());
+        });
+        self.ctx.output_mut(|o| o.events.push(event));
+    }
+
+    #[cfg(feature = "accesskit")]
+    pub(crate) fn fill_accesskit_node_common(&self, builder: &mut accesskit::NodeBuilder) {
+        builder.set_bounds(accesskit::Rect {
+            x0: self.rect.min.x.into(),
+            y0: self.rect.min.y.into(),
+            x1: self.rect.max.x.into(),
+            y1: self.rect.max.y.into(),
+        });
+        if self.sense.focusable {
+            builder.add_action(accesskit::Action::Focus);
+        }
+        if self.sense.click && builder.default_action_verb().is_none() {
+            builder.set_default_action_verb(accesskit::DefaultActionVerb::Click);
+        }
+    }
+
+    #[cfg(feature = "accesskit")]
+    fn fill_accesskit_node_from_widget_info(
+        &self,
+        builder: &mut accesskit::NodeBuilder,
+        info: crate::WidgetInfo,
+    ) {
+        use crate::WidgetType;
+        use accesskit::{CheckedState, Role};
+
+        self.fill_accesskit_node_common(builder);
+        builder.set_role(match info.typ {
+            WidgetType::Label => Role::StaticText,
+            WidgetType::Link => Role::Link,
+            WidgetType::TextEdit => Role::TextField,
+            WidgetType::Button | WidgetType::ImageButton | WidgetType::CollapsingHeader => {
+                Role::Button
+            }
+            WidgetType::Checkbox => Role::CheckBox,
+            WidgetType::RadioButton => Role::RadioButton,
+            WidgetType::SelectableLabel => Role::ToggleButton,
+            WidgetType::ComboBox => Role::PopupButton,
+            WidgetType::Slider => Role::Slider,
+            WidgetType::DragValue => Role::SpinButton,
+            WidgetType::ColorButton => Role::ColorWell,
+            WidgetType::Other => Role::Unknown,
+        });
+        if let Some(label) = info.label {
+            builder.set_name(label);
+        }
+        if let Some(value) = info.current_text_value {
+            builder.set_value(value);
+        }
+        if let Some(value) = info.value {
+            builder.set_numeric_value(value);
+        }
+        if let Some(selected) = info.selected {
+            builder.set_checked_state(if selected {
+                CheckedState::True
+            } else {
+                CheckedState::False
+            });
+        }
+    }
+
+    /// Associate a label with a control for accessibility.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut text = "Arthur".to_string();
+    /// ui.horizontal(|ui| {
+    ///     let label = ui.label("Your name: ");
+    ///     ui.text_edit_singleline(&mut text).labelled_by(label.id);
+    /// });
+    /// # });
+    /// ```
+    pub fn labelled_by(self, id: Id) -> Self {
+        #[cfg(feature = "accesskit")]
+        self.ctx.accesskit_node_builder(self.id, |builder| {
+            builder.push_labelled_by(id.accesskit_id());
+        });
+        #[cfg(not(feature = "accesskit"))]
+        {
+            let _ = id;
+        }
+
+        self
+    }
+
+    /// Response to secondary clicks (right-clicks) by showing the given menu.
+    ///
+    /// ```
+    /// # use egui::{Label, Sense};
+    /// # egui::__run_test_ui(|ui| {
+    /// let response = ui.add(Label::new("Right-click me!").sense(Sense::click()));
+    /// response.context_menu(|ui| {
+    ///     if ui.button("Close the menu").clicked() {
+    ///         ui.close_menu();
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// See also: [`Ui::menu_button`] and [`Ui::close_menu`].
+    pub fn context_menu(self, add_contents: impl FnOnce(&mut Ui)) -> Self {
+        menu::context_menu(&self, add_contents);
+        self
+    }
+}
+
+impl Response {
+    /// A logical "or" operation.
+    /// For instance `a.union(b).hovered` means "was either a or b hovered?".
+    ///
+    /// The resulting [`Self::id`] will come from the first (`self`) argument.
+    pub fn union(&self, other: Self) -> Self {
+        assert!(self.ctx == other.ctx);
+        crate::egui_assert!(
+            self.layer_id == other.layer_id,
+            "It makes no sense to combine Responses from two different layers"
+        );
+        Self {
+            ctx: other.ctx,
+            layer_id: self.layer_id,
+            id: self.id,
+            rect: self.rect.union(other.rect),
+            sense: self.sense.union(other.sense),
+            enabled: self.enabled || other.enabled,
+            hovered: self.hovered || other.hovered,
+            highlighted: self.highlighted || other.highlighted,
+            clicked: [
+                self.clicked[0] || other.clicked[0],
+                self.clicked[1] || other.clicked[1],
+                self.clicked[2] || other.clicked[2],
+                self.clicked[3] || other.clicked[3],
+                self.clicked[4] || other.clicked[4],
+            ],
+            double_clicked: [
+                self.double_clicked[0] || other.double_clicked[0],
+                self.double_clicked[1] || other.double_clicked[1],
+                self.double_clicked[2] || other.double_clicked[2],
+                self.double_clicked[3] || other.double_clicked[3],
+                self.double_clicked[4] || other.double_clicked[4],
+            ],
+            triple_clicked: [
+                self.triple_clicked[0] || other.triple_clicked[0],
+                self.triple_clicked[1] || other.triple_clicked[1],
+                self.triple_clicked[2] || other.triple_clicked[2],
+                self.triple_clicked[3] || other.triple_clicked[3],
+                self.triple_clicked[4] || other.triple_clicked[4],
+            ],
+            dragged: self.dragged || other.dragged,
+            drag_released: self.drag_released || other.drag_released,
+            is_pointer_button_down_on: self.is_pointer_button_down_on
+                || other.is_pointer_button_down_on,
+            interact_pointer_pos: self.interact_pointer_pos.or(other.interact_pointer_pos),
+            changed: self.changed || other.changed,
+        }
+    }
+}
+
+impl Response {
+    /// Returns a response with a modified [`Self::rect`].
+    pub fn with_new_rect(self, rect: Rect) -> Self {
+        Self { rect, ..self }
+    }
+}
+
+/// To summarize the response from many widgets you can use this pattern:
+///
+/// ```
+/// use egui::*;
+/// fn draw_vec2(ui: &mut Ui, v: &mut Vec2) -> Response {
+///     ui.add(DragValue::new(&mut v.x)) | ui.add(DragValue::new(&mut v.y))
+/// }
+/// ```
+///
+/// Now `draw_vec2(ui, foo).hovered` is true if either [`DragValue`](crate::DragValue) were hovered.
+impl std::ops::BitOr for Response {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self {
+        self.union(rhs)
+    }
+}
+
+/// To summarize the response from many widgets you can use this pattern:
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # let (widget_a, widget_b, widget_c) = (egui::Label::new("a"), egui::Label::new("b"), egui::Label::new("c"));
+/// let mut response = ui.add(widget_a);
+/// response |= ui.add(widget_b);
+/// response |= ui.add(widget_c);
+/// if response.hovered() { ui.label("You hovered at least one of the widgets"); }
+/// # });
+/// ```
+impl std::ops::BitOrAssign for Response {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = self.union(rhs);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Returned when we wrap some ui-code and want to return both
+/// the results of the inner function and the ui as a whole, e.g.:
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// let inner_resp = ui.horizontal(|ui| {
+///     ui.label("Blah blah");
+///     42
+/// });
+/// inner_resp.response.on_hover_text("You hovered the horizontal layout");
+/// assert_eq!(inner_resp.inner, 42);
+/// # });
+/// ```
+#[derive(Debug)]
+pub struct InnerResponse<R> {
+    /// What the user closure returned.
+    pub inner: R,
+
+    /// The response of the area.
+    pub response: Response,
+}
+
+impl<R> InnerResponse<R> {
+    #[inline]
+    pub fn new(inner: R, response: Response) -> Self {
+        Self { inner, response }
+    }
+}
diff --git a/egui/crates/egui/src/sense.rs b/egui/crates/egui/src/sense.rs
new file mode 100644
index 0000000..06c3a2b
--- /dev/null
+++ b/egui/crates/egui/src/sense.rs
@@ -0,0 +1,79 @@
+/// What sort of interaction is a widget sensitive to?
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+// #[cfg_attr(feature = "serde", derive(serde::Serialize))]
+pub struct Sense {
+    /// buttons, sliders, windows, …
+    pub click: bool,
+
+    /// sliders, windows, scroll bars, scroll areas, …
+    pub drag: bool,
+
+    /// this widgets want focus.
+    /// Anything interactive + labels that can be focused
+    /// for the benefit of screen readers.
+    pub focusable: bool,
+}
+
+impl Sense {
+    /// Senses no clicks or drags. Only senses mouse hover.
+    #[doc(alias = "none")]
+    pub fn hover() -> Self {
+        Self {
+            click: false,
+            drag: false,
+            focusable: false,
+        }
+    }
+
+    /// Senses no clicks or drags, but can be focused with the keyboard.
+    /// Used for labels that can be focused for the benefit of screen readers.
+    pub fn focusable_noninteractive() -> Self {
+        Self {
+            click: false,
+            drag: false,
+            focusable: true,
+        }
+    }
+
+    /// Sense clicks and hover, but not drags.
+    pub fn click() -> Self {
+        Self {
+            click: true,
+            drag: false,
+            focusable: true,
+        }
+    }
+
+    /// Sense drags and hover, but not clicks.
+    pub fn drag() -> Self {
+        Self {
+            click: false,
+            drag: true,
+            focusable: true,
+        }
+    }
+
+    /// Sense both clicks, drags and hover (e.g. a slider or window).
+    pub fn click_and_drag() -> Self {
+        Self {
+            click: true,
+            drag: true,
+            focusable: true,
+        }
+    }
+
+    /// The logical "or" of two [`Sense`]s.
+    #[must_use]
+    pub fn union(self, other: Self) -> Self {
+        Self {
+            click: self.click | other.click,
+            drag: self.drag | other.drag,
+            focusable: self.focusable | other.focusable,
+        }
+    }
+
+    /// Returns true if we sense either clicks or drags.
+    pub fn interactive(&self) -> bool {
+        self.click || self.drag
+    }
+}
diff --git a/egui/crates/egui/src/style.rs b/egui/crates/egui/src/style.rs
new file mode 100644
index 0000000..eb3b603
--- /dev/null
+++ b/egui/crates/egui/src/style.rs
@@ -0,0 +1,1507 @@
+//! egui theme (spacing, colors, etc).
+
+#![allow(clippy::if_same_then_else)]
+
+use crate::{ecolor::*, emath::*, FontFamily, FontId, Response, RichText, WidgetText};
+use epaint::{Rounding, Shadow, Stroke};
+use std::collections::BTreeMap;
+
+// ----------------------------------------------------------------------------
+
+/// Alias for a [`FontId`] (font of a certain size).
+///
+/// The font is found via look-up in [`Style::text_styles`].
+/// You can use [`TextStyle::resolve`] to do this lookup.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum TextStyle {
+    /// Used when small text is needed.
+    Small,
+
+    /// Normal labels. Easily readable, doesn't take up too much space.
+    Body,
+
+    /// Same size as [`Self::Body`], but used when monospace is important (for code snippets, aligning numbers, etc).
+    Monospace,
+
+    /// Buttons. Maybe slightly bigger than [`Self::Body`].
+    ///
+    /// Signifies that he item can be interacted with.
+    Button,
+
+    /// Heading. Probably larger than [`Self::Body`].
+    Heading,
+
+    /// A user-chosen style, found in [`Style::text_styles`].
+    /// ```
+    /// egui::TextStyle::Name("footing".into());
+    /// ````
+    Name(std::sync::Arc<str>),
+}
+
+impl std::fmt::Display for TextStyle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Small => "Small".fmt(f),
+            Self::Body => "Body".fmt(f),
+            Self::Monospace => "Monospace".fmt(f),
+            Self::Button => "Button".fmt(f),
+            Self::Heading => "Heading".fmt(f),
+            Self::Name(name) => (*name).fmt(f),
+        }
+    }
+}
+
+impl TextStyle {
+    /// Look up this [`TextStyle`] in [`Style::text_styles`].
+    pub fn resolve(&self, style: &Style) -> FontId {
+        style.text_styles.get(self).cloned().unwrap_or_else(|| {
+            panic!(
+                "Failed to find {:?} in Style::text_styles. Available styles:\n{:#?}",
+                self,
+                style.text_styles()
+            )
+        })
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A way to select [`FontId`], either by picking one directly or by using a [`TextStyle`].
+pub enum FontSelection {
+    /// Default text style - will use [`TextStyle::Body`], unless
+    /// [`Style::override_font_id`] or [`Style::override_text_style`] is set.
+    Default,
+
+    /// Directly select size and font family
+    FontId(FontId),
+
+    /// Use a [`TextStyle`] to look up the [`FontId`] in [`Style::text_styles`].
+    Style(TextStyle),
+}
+
+impl Default for FontSelection {
+    #[inline]
+    fn default() -> Self {
+        Self::Default
+    }
+}
+
+impl FontSelection {
+    pub fn resolve(self, style: &Style) -> FontId {
+        match self {
+            Self::Default => {
+                if let Some(override_font_id) = &style.override_font_id {
+                    override_font_id.clone()
+                } else if let Some(text_style) = &style.override_text_style {
+                    text_style.resolve(style)
+                } else {
+                    TextStyle::Body.resolve(style)
+                }
+            }
+            Self::FontId(font_id) => font_id,
+            Self::Style(text_style) => text_style.resolve(style),
+        }
+    }
+}
+
+impl From<FontId> for FontSelection {
+    #[inline(always)]
+    fn from(font_id: FontId) -> Self {
+        Self::FontId(font_id)
+    }
+}
+
+impl From<TextStyle> for FontSelection {
+    #[inline(always)]
+    fn from(text_style: TextStyle) -> Self {
+        Self::Style(text_style)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Specifies the look and feel of egui.
+///
+/// You can change the visuals of a [`Ui`] with [`Ui::style_mut`]
+/// and of everything with [`crate::Context::set_style`].
+///
+/// If you want to change fonts, use [`crate::Context::set_fonts`] instead.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Style {
+    /// If set this will change the default [`TextStyle`] for all widgets.
+    ///
+    /// On most widgets you can also set an explicit text style,
+    /// which will take precedence over this.
+    pub override_text_style: Option<TextStyle>,
+
+    /// If set this will change the font family and size for all widgets.
+    ///
+    /// On most widgets you can also set an explicit text style,
+    /// which will take precedence over this.
+    pub override_font_id: Option<FontId>,
+
+    /// The [`FontFamily`] and size you want to use for a specific [`TextStyle`].
+    ///
+    /// The most convenient way to look something up in this is to use [`TextStyle::resolve`].
+    ///
+    /// If you would like to overwrite app text_styles
+    ///
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// use egui::FontFamily::Proportional;
+    /// use egui::FontId;
+    /// use egui::TextStyle::*;
+    ///
+    /// // Get current context style
+    /// let mut style = (*ctx.style()).clone();
+    ///
+    /// // Redefine text_styles
+    /// style.text_styles = [
+    ///   (Heading, FontId::new(30.0, Proportional)),
+    ///   (Name("Heading2".into()), FontId::new(25.0, Proportional)),
+    ///   (Name("Context".into()), FontId::new(23.0, Proportional)),
+    ///   (Body, FontId::new(18.0, Proportional)),
+    ///   (Monospace, FontId::new(14.0, Proportional)),
+    ///   (Button, FontId::new(14.0, Proportional)),
+    ///   (Small, FontId::new(10.0, Proportional)),
+    /// ].into();
+    ///
+    /// // Mutate global style with above changes
+    /// ctx.set_style(style);
+    /// ```
+    pub text_styles: BTreeMap<TextStyle, FontId>,
+
+    /// The style to use for [`DragValue`] text.
+    pub drag_value_text_style: TextStyle,
+
+    /// If set, labels buttons wtc will use this to determine whether or not
+    /// to wrap the text at the right edge of the [`Ui`] they are in.
+    /// By default this is `None`.
+    ///
+    /// * `None`: follow layout
+    /// * `Some(true)`: default on
+    /// * `Some(false)`: default off
+    pub wrap: Option<bool>,
+
+    /// Sizes and distances between widgets
+    pub spacing: Spacing,
+
+    /// How and when interaction happens.
+    pub interaction: Interaction,
+
+    /// Colors etc.
+    pub visuals: Visuals,
+
+    /// How many seconds a typical animation should last.
+    pub animation_time: f32,
+
+    /// Options to help debug why egui behaves strangely.
+    pub debug: DebugOptions,
+
+    /// Show tooltips explaining [`DragValue`]:s etc when hovered.
+    ///
+    /// This only affects a few egui widgets.
+    pub explanation_tooltips: bool,
+}
+
+impl Style {
+    // TODO(emilk): rename style.interact() to maybe... `style.interactive` ?
+    /// Use this style for interactive things.
+    /// Note that you must already have a response,
+    /// i.e. you must allocate space and interact BEFORE painting the widget!
+    pub fn interact(&self, response: &Response) -> &WidgetVisuals {
+        self.visuals.widgets.style(response)
+    }
+
+    pub fn interact_selectable(&self, response: &Response, selected: bool) -> WidgetVisuals {
+        let mut visuals = *self.visuals.widgets.style(response);
+        if selected {
+            visuals.weak_bg_fill = self.visuals.selection.bg_fill;
+            visuals.bg_fill = self.visuals.selection.bg_fill;
+            // visuals.bg_stroke = self.visuals.selection.stroke;
+            visuals.fg_stroke = self.visuals.selection.stroke;
+        }
+        visuals
+    }
+
+    /// Style to use for non-interactive widgets.
+    pub fn noninteractive(&self) -> &WidgetVisuals {
+        &self.visuals.widgets.noninteractive
+    }
+
+    /// All known text styles.
+    pub fn text_styles(&self) -> Vec<TextStyle> {
+        self.text_styles.keys().cloned().collect()
+    }
+}
+
+/// Controls the sizes and distances between widgets.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Spacing {
+    /// Horizontal and vertical spacing between widgets.
+    ///
+    /// To add extra space between widgets, use [`Ui::add_space`].
+    ///
+    /// `item_spacing` is inserted _after_ adding a widget, so to increase the spacing between
+    /// widgets `A` and `B` you need to change `item_spacing` before adding `A`.
+    pub item_spacing: Vec2,
+
+    /// Horizontal and vertical margins within a window frame.
+    pub window_margin: Margin,
+
+    /// Button size is text size plus this on each side
+    pub button_padding: Vec2,
+
+    /// Horizontal and vertical margins within a menu frame.
+    pub menu_margin: Margin,
+
+    /// Indent collapsing regions etc by this much.
+    pub indent: f32,
+
+    /// Minimum size of a [`DragValue`], color picker button, and other small widgets.
+    /// `interact_size.y` is the default height of button, slider, etc.
+    /// Anything clickable should be (at least) this size.
+    pub interact_size: Vec2, // TODO(emilk): rename min_interact_size ?
+
+    /// Default width of a [`Slider`].
+    pub slider_width: f32,
+
+    /// Default (minimum) width of a [`ComboBox`](crate::ComboBox).
+    pub combo_width: f32,
+
+    /// Default width of a [`TextEdit`].
+    pub text_edit_width: f32,
+
+    /// Checkboxes, radio button and collapsing headers have an icon at the start.
+    /// This is the width/height of the outer part of this icon (e.g. the BOX of the checkbox).
+    pub icon_width: f32,
+
+    /// Checkboxes, radio button and collapsing headers have an icon at the start.
+    /// This is the width/height of the inner part of this icon (e.g. the check of the checkbox).
+    pub icon_width_inner: f32,
+
+    /// Checkboxes, radio button and collapsing headers have an icon at the start.
+    /// This is the spacing between the icon and the text
+    pub icon_spacing: f32,
+
+    /// Width of a tooltip (`on_hover_ui`, `on_hover_text` etc).
+    pub tooltip_width: f32,
+
+    /// End indented regions with a horizontal line
+    pub indent_ends_with_horizontal_line: bool,
+
+    /// Height of a combo-box before showing scroll bars.
+    pub combo_height: f32,
+
+    pub scroll_bar_width: f32,
+
+    /// Make sure the scroll handle is at least this big
+    pub scroll_handle_min_length: f32,
+
+    /// Margin between contents and scroll bar.
+    pub scroll_bar_inner_margin: f32,
+
+    /// Margin between scroll bar and the outer container (e.g. right of a vertical scroll bar).
+    pub scroll_bar_outer_margin: f32,
+}
+
+impl Spacing {
+    /// Returns small icon rectangle and big icon rectangle
+    pub fn icon_rectangles(&self, rect: Rect) -> (Rect, Rect) {
+        let icon_width = self.icon_width;
+        let big_icon_rect = Rect::from_center_size(
+            pos2(rect.left() + icon_width / 2.0, rect.center().y),
+            vec2(icon_width, icon_width),
+        );
+
+        let small_icon_rect =
+            Rect::from_center_size(big_icon_rect.center(), Vec2::splat(self.icon_width_inner));
+
+        (small_icon_rect, big_icon_rect)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Margin {
+    pub left: f32,
+    pub right: f32,
+    pub top: f32,
+    pub bottom: f32,
+}
+
+impl Margin {
+    #[inline]
+    pub fn same(margin: f32) -> Self {
+        Self {
+            left: margin,
+            right: margin,
+            top: margin,
+            bottom: margin,
+        }
+    }
+
+    /// Margins with the same size on opposing sides
+    #[inline]
+    pub fn symmetric(x: f32, y: f32) -> Self {
+        Self {
+            left: x,
+            right: x,
+            top: y,
+            bottom: y,
+        }
+    }
+
+    /// Total margins on both sides
+    pub fn sum(&self) -> Vec2 {
+        vec2(self.left + self.right, self.top + self.bottom)
+    }
+
+    pub fn left_top(&self) -> Vec2 {
+        vec2(self.left, self.top)
+    }
+
+    pub fn right_bottom(&self) -> Vec2 {
+        vec2(self.right, self.bottom)
+    }
+
+    pub fn is_same(&self) -> bool {
+        self.left == self.right && self.left == self.top && self.left == self.bottom
+    }
+}
+
+impl From<f32> for Margin {
+    fn from(v: f32) -> Self {
+        Self::same(v)
+    }
+}
+
+impl From<Vec2> for Margin {
+    fn from(v: Vec2) -> Self {
+        Self::symmetric(v.x, v.y)
+    }
+}
+
+impl std::ops::Add for Margin {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self {
+            left: self.left + other.left,
+            right: self.right + other.right,
+            top: self.top + other.top,
+            bottom: self.bottom + other.bottom,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// How and when interaction happens.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Interaction {
+    /// Mouse must be this close to the side of a window to resize
+    pub resize_grab_radius_side: f32,
+
+    /// Mouse must be this close to the corner of a window to resize
+    pub resize_grab_radius_corner: f32,
+
+    /// If `false`, tooltips will show up anytime you hover anything, even is mouse is still moving
+    pub show_tooltips_only_when_still: bool,
+}
+
+/// Controls the visual style (colors etc) of egui.
+///
+/// You can change the visuals of a [`Ui`] with [`Ui::visuals_mut`]
+/// and of everything with [`crate::Context::set_visuals`].
+///
+/// If you want to change fonts, use [`crate::Context::set_fonts`] instead.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Visuals {
+    /// If true, the visuals are overall dark with light text.
+    /// If false, the visuals are overall light with dark text.
+    ///
+    /// NOTE: setting this does very little by itself,
+    /// this is more to provide a convenient summary of the rest of the settings.
+    pub dark_mode: bool,
+
+    /// Override default text color for all text.
+    ///
+    /// This is great for setting the color of text for any widget.
+    ///
+    /// If `text_color` is `None` (default), then the text color will be the same as the
+    /// foreground stroke color (`WidgetVisuals::fg_stroke`)
+    /// and will depend on whether or not the widget is being interacted with.
+    ///
+    /// In the future we may instead modulate
+    /// the `text_color` based on whether or not it is interacted with
+    /// so that `visuals.text_color` is always used,
+    /// but its alpha may be different based on whether or not
+    /// it is disabled, non-interactive, hovered etc.
+    pub override_text_color: Option<Color32>,
+
+    /// Visual styles of widgets
+    pub widgets: Widgets,
+
+    pub selection: Selection,
+
+    /// The color used for [`Hyperlink`],
+    pub hyperlink_color: Color32,
+
+    /// Something just barely different from the background color.
+    /// Used for [`crate::Grid::striped`].
+    pub faint_bg_color: Color32,
+
+    /// Very dark or light color (for corresponding theme).
+    /// Used as the background of text edits, scroll bars and others things
+    /// that needs to look different from other interactive stuff.
+    pub extreme_bg_color: Color32,
+
+    /// Background color behind code-styled monospaced labels.
+    pub code_bg_color: Color32,
+
+    /// A good color for warning text (e.g. orange).
+    pub warn_fg_color: Color32,
+
+    /// A good color for error text (e.g. red).
+    pub error_fg_color: Color32,
+
+    pub window_rounding: Rounding,
+    pub window_shadow: Shadow,
+    pub window_fill: Color32,
+    pub window_stroke: Stroke,
+
+    pub menu_rounding: Rounding,
+
+    /// Panel background color
+    pub panel_fill: Color32,
+
+    pub popup_shadow: Shadow,
+
+    pub resize_corner_size: f32,
+
+    pub text_cursor_width: f32,
+
+    /// show where the text cursor would be if you clicked
+    pub text_cursor_preview: bool,
+
+    /// Allow child widgets to be just on the border and still have a stroke with some thickness
+    pub clip_rect_margin: f32,
+
+    /// Show a background behind buttons.
+    pub button_frame: bool,
+
+    /// Show a background behind collapsing headers.
+    pub collapsing_header_frame: bool,
+
+    /// Draw a vertical lien left of indented region, in e.g. [`crate::CollapsingHeader`].
+    pub indent_has_left_vline: bool,
+
+    /// Whether or not Grids and Tables should be striped by default
+    /// (have alternating rows differently colored).
+    pub striped: bool,
+
+    /// Show trailing color behind the circle of a [`Slider`]. Default is OFF.
+    ///
+    /// Enabling this will affect ALL sliders, and can be enabled/disabled per slider with [`Slider::trailing_fill`].
+    pub slider_trailing_fill: bool,
+}
+
+impl Visuals {
+    #[inline(always)]
+    pub fn noninteractive(&self) -> &WidgetVisuals {
+        &self.widgets.noninteractive
+    }
+
+    pub fn text_color(&self) -> Color32 {
+        self.override_text_color
+            .unwrap_or_else(|| self.widgets.noninteractive.text_color())
+    }
+
+    pub fn weak_text_color(&self) -> Color32 {
+        self.gray_out(self.text_color())
+    }
+
+    #[inline(always)]
+    pub fn strong_text_color(&self) -> Color32 {
+        self.widgets.active.text_color()
+    }
+
+    /// Window background color.
+    #[inline(always)]
+    pub fn window_fill(&self) -> Color32 {
+        self.window_fill
+    }
+
+    #[inline(always)]
+    pub fn window_stroke(&self) -> Stroke {
+        self.window_stroke
+    }
+
+    /// When fading out things, we fade the colors towards this.
+    // TODO(emilk): replace with an alpha
+    #[inline(always)]
+    pub fn fade_out_to_color(&self) -> Color32 {
+        self.widgets.noninteractive.weak_bg_fill
+    }
+
+    /// Returned a "grayed out" version of the given color.
+    #[inline(always)]
+    pub fn gray_out(&self, color: Color32) -> Color32 {
+        crate::ecolor::tint_color_towards(color, self.fade_out_to_color())
+    }
+}
+
+/// Selected text, selected elements etc
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Selection {
+    pub bg_fill: Color32,
+    pub stroke: Stroke,
+}
+
+/// The visuals of widgets for different states of interaction.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Widgets {
+    /// The style of a widget that you cannot interact with.
+    /// * `noninteractive.bg_stroke` is the outline of windows.
+    /// * `noninteractive.bg_fill` is the background color of windows.
+    /// * `noninteractive.fg_stroke` is the normal text color.
+    pub noninteractive: WidgetVisuals,
+
+    /// The style of an interactive widget, such as a button, at rest.
+    pub inactive: WidgetVisuals,
+
+    /// The style of an interactive widget while you hover it, or when it is highlighted.
+    ///
+    /// See [`Response::hovered`], [`Response::highlighted`] and [`Response::highlight`].
+    pub hovered: WidgetVisuals,
+
+    /// The style of an interactive widget as you are clicking or dragging it.
+    pub active: WidgetVisuals,
+
+    /// The style of a button that has an open menu beneath it (e.g. a combo-box)
+    pub open: WidgetVisuals,
+}
+
+impl Widgets {
+    pub fn style(&self, response: &Response) -> &WidgetVisuals {
+        if !response.sense.interactive() {
+            &self.noninteractive
+        } else if response.is_pointer_button_down_on() || response.has_focus() {
+            &self.active
+        } else if response.hovered() || response.highlighted() {
+            &self.hovered
+        } else {
+            &self.inactive
+        }
+    }
+}
+
+/// bg = background, fg = foreground.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WidgetVisuals {
+    /// Background color of widgets that must have a background fill,
+    /// such as the slider background, a checkbox background, or a radio button background.
+    ///
+    /// Must never be [`Color32::TRANSPARENT`].
+    pub bg_fill: Color32,
+
+    /// Background color of widgets that can _optionally_ have a background fill, such as buttons.
+    ///
+    /// May be [`Color32::TRANSPARENT`].
+    pub weak_bg_fill: Color32,
+
+    /// For surrounding rectangle of things that need it,
+    /// like buttons, the box of the checkbox, etc.
+    /// Should maybe be called `frame_stroke`.
+    pub bg_stroke: Stroke,
+
+    /// Button frames etc.
+    pub rounding: Rounding,
+
+    /// Stroke and text color of the interactive part of a component (button text, slider grab, check-mark, …).
+    pub fg_stroke: Stroke,
+
+    /// Make the frame this much larger.
+    pub expansion: f32,
+}
+
+impl WidgetVisuals {
+    #[inline(always)]
+    pub fn text_color(&self) -> Color32 {
+        self.fg_stroke.color
+    }
+}
+
+/// Options for help debug egui by adding extra visualization
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct DebugOptions {
+    /// However over widgets to see their rectangles
+    pub debug_on_hover: bool,
+
+    /// Show which widgets make their parent wider
+    pub show_expand_width: bool,
+
+    /// Show which widgets make their parent higher
+    pub show_expand_height: bool,
+
+    pub show_resize: bool,
+
+    /// Show an overlay on all interactive widgets.
+    pub show_interactive_widgets: bool,
+
+    /// Show what widget blocks the interaction of another widget.
+    pub show_blocking_widget: bool,
+}
+
+// ----------------------------------------------------------------------------
+
+/// The default text styles of the default egui theme.
+pub fn default_text_styles() -> BTreeMap<TextStyle, FontId> {
+    use FontFamily::{Monospace, Proportional};
+
+    [
+        (TextStyle::Small, FontId::new(9.0, Proportional)),
+        (TextStyle::Body, FontId::new(12.5, Proportional)),
+        (TextStyle::Button, FontId::new(12.5, Proportional)),
+        (TextStyle::Heading, FontId::new(18.0, Proportional)),
+        (TextStyle::Monospace, FontId::new(12.0, Monospace)),
+    ]
+    .into()
+}
+
+impl Default for Style {
+    fn default() -> Self {
+        Self {
+            override_font_id: None,
+            override_text_style: None,
+            text_styles: default_text_styles(),
+            drag_value_text_style: TextStyle::Button,
+            wrap: None,
+            spacing: Spacing::default(),
+            interaction: Interaction::default(),
+            visuals: Visuals::default(),
+            animation_time: 1.0 / 12.0,
+            debug: Default::default(),
+            explanation_tooltips: false,
+        }
+    }
+}
+
+impl Default for Spacing {
+    fn default() -> Self {
+        Self {
+            item_spacing: vec2(8.0, 3.0),
+            window_margin: Margin::same(6.0),
+            menu_margin: Margin::same(6.0),
+            button_padding: vec2(4.0, 1.0),
+            indent: 18.0, // match checkbox/radio-button with `button_padding.x + icon_width + icon_spacing`
+            interact_size: vec2(40.0, 18.0),
+            slider_width: 100.0,
+            combo_width: 100.0,
+            text_edit_width: 280.0,
+            icon_width: 14.0,
+            icon_width_inner: 8.0,
+            icon_spacing: 4.0,
+            tooltip_width: 600.0,
+            combo_height: 200.0,
+            scroll_bar_width: 8.0,
+            scroll_handle_min_length: 12.0,
+            scroll_bar_inner_margin: 4.0,
+            scroll_bar_outer_margin: 0.0,
+            indent_ends_with_horizontal_line: false,
+        }
+    }
+}
+
+impl Default for Interaction {
+    fn default() -> Self {
+        Self {
+            resize_grab_radius_side: 5.0,
+            resize_grab_radius_corner: 10.0,
+            show_tooltips_only_when_still: true,
+        }
+    }
+}
+
+impl Visuals {
+    /// Default dark theme.
+    pub fn dark() -> Self {
+        Self {
+            dark_mode: true,
+            override_text_color: None,
+            widgets: Widgets::default(),
+            selection: Selection::default(),
+            hyperlink_color: Color32::from_rgb(90, 170, 255),
+            faint_bg_color: Color32::from_additive_luminance(5), // visible, but barely so
+            extreme_bg_color: Color32::from_gray(10),            // e.g. TextEdit background
+            code_bg_color: Color32::from_gray(64),
+            warn_fg_color: Color32::from_rgb(255, 143, 0), // orange
+            error_fg_color: Color32::from_rgb(255, 0, 0),  // red
+
+            window_rounding: Rounding::same(6.0),
+            window_shadow: Shadow::big_dark(),
+            window_fill: Color32::from_gray(27),
+            window_stroke: Stroke::new(1.0, Color32::from_gray(60)),
+
+            menu_rounding: Rounding::same(6.0),
+
+            panel_fill: Color32::from_gray(27),
+
+            popup_shadow: Shadow::small_dark(),
+            resize_corner_size: 12.0,
+            text_cursor_width: 2.0,
+            text_cursor_preview: false,
+            clip_rect_margin: 3.0, // should be at least half the size of the widest frame stroke + max WidgetVisuals::expansion
+            button_frame: true,
+            collapsing_header_frame: false,
+            indent_has_left_vline: true,
+
+            striped: false,
+
+            slider_trailing_fill: false,
+        }
+    }
+
+    /// Default light theme.
+    pub fn light() -> Self {
+        Self {
+            dark_mode: false,
+            widgets: Widgets::light(),
+            selection: Selection::light(),
+            hyperlink_color: Color32::from_rgb(0, 155, 255),
+            faint_bg_color: Color32::from_additive_luminance(5), // visible, but barely so
+            extreme_bg_color: Color32::from_gray(255),           // e.g. TextEdit background
+            code_bg_color: Color32::from_gray(230),
+            warn_fg_color: Color32::from_rgb(255, 100, 0), // slightly orange red. it's difficult to find a warning color that pops on bright background.
+            error_fg_color: Color32::from_rgb(255, 0, 0),  // red
+
+            window_shadow: Shadow::big_light(),
+            window_fill: Color32::from_gray(248),
+            window_stroke: Stroke::new(1.0, Color32::from_gray(190)),
+
+            panel_fill: Color32::from_gray(248),
+
+            popup_shadow: Shadow::small_light(),
+            ..Self::dark()
+        }
+    }
+}
+
+impl Default for Visuals {
+    fn default() -> Self {
+        Self::dark()
+    }
+}
+
+impl Selection {
+    fn dark() -> Self {
+        Self {
+            bg_fill: Color32::from_rgb(0, 92, 128),
+            stroke: Stroke::new(1.0, Color32::from_rgb(192, 222, 255)),
+        }
+    }
+
+    fn light() -> Self {
+        Self {
+            bg_fill: Color32::from_rgb(144, 209, 255),
+            stroke: Stroke::new(1.0, Color32::from_rgb(0, 83, 125)),
+        }
+    }
+}
+
+impl Default for Selection {
+    fn default() -> Self {
+        Self::dark()
+    }
+}
+
+impl Widgets {
+    pub fn dark() -> Self {
+        Self {
+            noninteractive: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(27),
+                bg_fill: Color32::from_gray(27),
+                bg_stroke: Stroke::new(1.0, Color32::from_gray(60)), // separators, indentation lines
+                fg_stroke: Stroke::new(1.0, Color32::from_gray(140)), // normal text color
+                rounding: Rounding::same(2.0),
+                expansion: 0.0,
+            },
+            inactive: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(60), // button background
+                bg_fill: Color32::from_gray(60),      // checkbox background
+                bg_stroke: Default::default(),
+                fg_stroke: Stroke::new(1.0, Color32::from_gray(180)), // button text
+                rounding: Rounding::same(2.0),
+                expansion: 0.0,
+            },
+            hovered: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(70),
+                bg_fill: Color32::from_gray(70),
+                bg_stroke: Stroke::new(1.0, Color32::from_gray(150)), // e.g. hover over window edge or button
+                fg_stroke: Stroke::new(1.5, Color32::from_gray(240)),
+                rounding: Rounding::same(3.0),
+                expansion: 1.0,
+            },
+            active: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(55),
+                bg_fill: Color32::from_gray(55),
+                bg_stroke: Stroke::new(1.0, Color32::WHITE),
+                fg_stroke: Stroke::new(2.0, Color32::WHITE),
+                rounding: Rounding::same(2.0),
+                expansion: 1.0,
+            },
+            open: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(27),
+                bg_fill: Color32::from_gray(27),
+                bg_stroke: Stroke::new(1.0, Color32::from_gray(60)),
+                fg_stroke: Stroke::new(1.0, Color32::from_gray(210)),
+                rounding: Rounding::same(2.0),
+                expansion: 0.0,
+            },
+        }
+    }
+
+    pub fn light() -> Self {
+        Self {
+            noninteractive: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(248),
+                bg_fill: Color32::from_gray(248),
+                bg_stroke: Stroke::new(1.0, Color32::from_gray(190)), // separators, indentation lines
+                fg_stroke: Stroke::new(1.0, Color32::from_gray(80)),  // normal text color
+                rounding: Rounding::same(2.0),
+                expansion: 0.0,
+            },
+            inactive: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(230), // button background
+                bg_fill: Color32::from_gray(230),      // checkbox background
+                bg_stroke: Default::default(),
+                fg_stroke: Stroke::new(1.0, Color32::from_gray(60)), // button text
+                rounding: Rounding::same(2.0),
+                expansion: 0.0,
+            },
+            hovered: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(220),
+                bg_fill: Color32::from_gray(220),
+                bg_stroke: Stroke::new(1.0, Color32::from_gray(105)), // e.g. hover over window edge or button
+                fg_stroke: Stroke::new(1.5, Color32::BLACK),
+                rounding: Rounding::same(3.0),
+                expansion: 1.0,
+            },
+            active: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(165),
+                bg_fill: Color32::from_gray(165),
+                bg_stroke: Stroke::new(1.0, Color32::BLACK),
+                fg_stroke: Stroke::new(2.0, Color32::BLACK),
+                rounding: Rounding::same(2.0),
+                expansion: 1.0,
+            },
+            open: WidgetVisuals {
+                weak_bg_fill: Color32::from_gray(220),
+                bg_fill: Color32::from_gray(220),
+                bg_stroke: Stroke::new(1.0, Color32::from_gray(160)),
+                fg_stroke: Stroke::new(1.0, Color32::BLACK),
+                rounding: Rounding::same(2.0),
+                expansion: 0.0,
+            },
+        }
+    }
+}
+
+impl Default for Widgets {
+    fn default() -> Self {
+        Self::dark()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+use crate::{widgets::*, Ui};
+
+impl Style {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            override_font_id,
+            override_text_style,
+            text_styles,
+            drag_value_text_style,
+            wrap: _,
+            spacing,
+            interaction,
+            visuals,
+            animation_time,
+            debug,
+            explanation_tooltips,
+        } = self;
+
+        visuals.light_dark_radio_buttons(ui);
+
+        crate::Grid::new("_options").show(ui, |ui| {
+            ui.label("Override font id:");
+            ui.horizontal(|ui| {
+                ui.radio_value(override_font_id, None, "None");
+                if ui.radio(override_font_id.is_some(), "override").clicked() {
+                    *override_font_id = Some(FontId::default());
+                }
+                if let Some(override_font_id) = override_font_id {
+                    crate::introspection::font_id_ui(ui, override_font_id);
+                }
+            });
+            ui.end_row();
+
+            ui.label("Override text style:");
+            crate::ComboBox::from_id_source("Override text style")
+                .selected_text(match override_text_style {
+                    None => "None".to_owned(),
+                    Some(override_text_style) => override_text_style.to_string(),
+                })
+                .show_ui(ui, |ui| {
+                    ui.selectable_value(override_text_style, None, "None");
+                    let all_text_styles = ui.style().text_styles();
+                    for style in all_text_styles {
+                        let text =
+                            crate::RichText::new(style.to_string()).text_style(style.clone());
+                        ui.selectable_value(override_text_style, Some(style), text);
+                    }
+                });
+            ui.end_row();
+
+            ui.label("Text style of DragValue:");
+            crate::ComboBox::from_id_source("drag_value_text_style")
+                .selected_text(drag_value_text_style.to_string())
+                .show_ui(ui, |ui| {
+                    let all_text_styles = ui.style().text_styles();
+                    for style in all_text_styles {
+                        let text =
+                            crate::RichText::new(style.to_string()).text_style(style.clone());
+                        ui.selectable_value(drag_value_text_style, style, text);
+                    }
+                });
+            ui.end_row();
+
+            ui.label("Animation duration:");
+            ui.add(
+                Slider::new(animation_time, 0.0..=1.0)
+                    .clamp_to_range(true)
+                    .suffix(" s"),
+            );
+            ui.end_row();
+        });
+
+        ui.collapsing("🔠 Text Styles", |ui| text_styles_ui(ui, text_styles));
+        ui.collapsing("📏 Spacing", |ui| spacing.ui(ui));
+        ui.collapsing("☝ Interaction", |ui| interaction.ui(ui));
+        ui.collapsing("🎨 Visuals", |ui| visuals.ui(ui));
+        ui.collapsing("🐛 Debug", |ui| debug.ui(ui));
+
+        ui.checkbox(explanation_tooltips, "Explanation tooltips")
+            .on_hover_text(
+                "Show explanatory text when hovering DragValue:s and other egui widgets",
+            );
+
+        ui.vertical_centered(|ui| reset_button(ui, self));
+    }
+}
+
+fn text_styles_ui(ui: &mut Ui, text_styles: &mut BTreeMap<TextStyle, FontId>) -> Response {
+    ui.vertical(|ui| {
+        crate::Grid::new("text_styles").show(ui, |ui| {
+            for (text_style, font_id) in text_styles.iter_mut() {
+                ui.label(RichText::new(text_style.to_string()).font(font_id.clone()));
+                crate::introspection::font_id_ui(ui, font_id);
+                ui.end_row();
+            }
+        });
+        crate::reset_button_with(ui, text_styles, default_text_styles());
+    })
+    .response
+}
+
+impl Spacing {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            item_spacing,
+            window_margin,
+            menu_margin,
+            button_padding,
+            indent,
+            interact_size,
+            slider_width,
+            combo_width,
+            text_edit_width,
+            icon_width,
+            icon_width_inner,
+            icon_spacing,
+            tooltip_width,
+            indent_ends_with_horizontal_line,
+            combo_height,
+            scroll_bar_width,
+            scroll_handle_min_length,
+            scroll_bar_inner_margin,
+            scroll_bar_outer_margin,
+        } = self;
+
+        ui.add(slider_vec2(item_spacing, 0.0..=20.0, "Item spacing"));
+
+        margin_ui(ui, "Window margin:", window_margin);
+        margin_ui(ui, "Menu margin:", menu_margin);
+
+        ui.add(slider_vec2(button_padding, 0.0..=20.0, "Button padding"));
+        ui.add(slider_vec2(interact_size, 4.0..=60.0, "Interact size"))
+            .on_hover_text("Minimum size of an interactive widget");
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(indent).clamp_range(0.0..=100.0));
+            ui.label("Indent");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(slider_width).clamp_range(0.0..=1000.0));
+            ui.label("Slider width");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(combo_width).clamp_range(0.0..=1000.0));
+            ui.label("ComboBox width");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(text_edit_width).clamp_range(0.0..=1000.0));
+            ui.label("TextEdit width");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(scroll_bar_width).clamp_range(0.0..=32.0));
+            ui.label("Scroll-bar width");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(scroll_handle_min_length).clamp_range(0.0..=32.0));
+            ui.label("Scroll-bar handle min length");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(scroll_bar_inner_margin).clamp_range(0.0..=32.0));
+            ui.label("Scroll-bar inner margin");
+        });
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(scroll_bar_outer_margin).clamp_range(0.0..=32.0));
+            ui.label("Scroll-bar outer margin");
+        });
+
+        ui.horizontal(|ui| {
+            ui.label("Checkboxes etc:");
+            ui.add(
+                DragValue::new(icon_width)
+                    .prefix("outer icon width:")
+                    .clamp_range(0.0..=60.0),
+            );
+            ui.add(
+                DragValue::new(icon_width_inner)
+                    .prefix("inner icon width:")
+                    .clamp_range(0.0..=60.0),
+            );
+            ui.add(
+                DragValue::new(icon_spacing)
+                    .prefix("spacing:")
+                    .clamp_range(0.0..=10.0),
+            );
+        });
+
+        ui.horizontal(|ui| {
+            ui.add(DragValue::new(tooltip_width).clamp_range(0.0..=1000.0));
+            ui.label("Tooltip wrap width");
+        });
+
+        ui.checkbox(
+            indent_ends_with_horizontal_line,
+            "End indented regions with a horizontal separator",
+        );
+
+        ui.horizontal(|ui| {
+            ui.label("Max height of a combo box");
+            ui.add(DragValue::new(combo_height).clamp_range(0.0..=1000.0));
+        });
+
+        ui.vertical_centered(|ui| reset_button(ui, self));
+    }
+}
+
+fn margin_ui(ui: &mut Ui, text: &str, margin: &mut Margin) {
+    let margin_range = 0.0..=20.0;
+
+    ui.horizontal(|ui| {
+        ui.label(text);
+
+        let mut same = margin.is_same();
+        ui.checkbox(&mut same, "Same");
+
+        if same {
+            let mut value = margin.left;
+            ui.add(DragValue::new(&mut value).clamp_range(margin_range.clone()));
+            *margin = Margin::same(value);
+        } else {
+            if margin.is_same() {
+                // HACK: prevent collapse:
+                margin.right = margin.left + 1.0;
+                margin.bottom = margin.left + 2.0;
+                margin.top = margin.left + 3.0;
+            }
+
+            ui.add(
+                DragValue::new(&mut margin.left)
+                    .clamp_range(margin_range.clone())
+                    .prefix("L: "),
+            )
+            .on_hover_text("Left margin");
+            ui.add(
+                DragValue::new(&mut margin.right)
+                    .clamp_range(margin_range.clone())
+                    .prefix("R: "),
+            )
+            .on_hover_text("Right margin");
+            ui.add(
+                DragValue::new(&mut margin.top)
+                    .clamp_range(margin_range.clone())
+                    .prefix("T: "),
+            )
+            .on_hover_text("Top margin");
+            ui.add(
+                DragValue::new(&mut margin.bottom)
+                    .clamp_range(margin_range)
+                    .prefix("B: "),
+            )
+            .on_hover_text("Bottom margin");
+        }
+    });
+}
+
+impl Interaction {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            resize_grab_radius_side,
+            resize_grab_radius_corner,
+            show_tooltips_only_when_still,
+        } = self;
+        ui.add(Slider::new(resize_grab_radius_side, 0.0..=20.0).text("resize_grab_radius_side"));
+        ui.add(
+            Slider::new(resize_grab_radius_corner, 0.0..=20.0).text("resize_grab_radius_corner"),
+        );
+        ui.checkbox(
+            show_tooltips_only_when_still,
+            "Only show tooltips if mouse is still",
+        );
+
+        ui.vertical_centered(|ui| reset_button(ui, self));
+    }
+}
+
+impl Widgets {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            active,
+            hovered,
+            inactive,
+            noninteractive,
+            open,
+        } = self;
+
+        ui.collapsing("Noninteractive", |ui| {
+            ui.label(
+                "The style of a widget that you cannot interact with, e.g. labels and separators.",
+            );
+            noninteractive.ui(ui);
+        });
+        ui.collapsing("Interactive but inactive", |ui| {
+            ui.label("The style of an interactive widget, such as a button, at rest.");
+            inactive.ui(ui);
+        });
+        ui.collapsing("Interactive and hovered", |ui| {
+            ui.label("The style of an interactive widget while you hover it.");
+            hovered.ui(ui);
+        });
+        ui.collapsing("Interactive and active", |ui| {
+            ui.label("The style of an interactive widget as you are clicking or dragging it.");
+            active.ui(ui);
+        });
+        ui.collapsing("Open menu", |ui| {
+            ui.label("The style of an open combo-box or menu button");
+            open.ui(ui);
+        });
+
+        // ui.vertical_centered(|ui| reset_button(ui, self));
+    }
+}
+
+impl Selection {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self { bg_fill, stroke } = self;
+        ui.label("Selectable labels");
+        ui_color(ui, bg_fill, "background fill");
+        stroke_ui(ui, stroke, "stroke");
+    }
+}
+
+impl WidgetVisuals {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            weak_bg_fill,
+            bg_fill: mandatory_bg_fill,
+            bg_stroke,
+            rounding,
+            fg_stroke,
+            expansion,
+        } = self;
+        ui_color(ui, weak_bg_fill, "optional background fill")
+            .on_hover_text("For buttons, combo-boxes, etc");
+        ui_color(ui, mandatory_bg_fill, "mandatory background fill")
+            .on_hover_text("For checkboxes, sliders, etc");
+        stroke_ui(ui, bg_stroke, "background stroke");
+
+        rounding_ui(ui, rounding);
+
+        stroke_ui(ui, fg_stroke, "foreground stroke (text)");
+        ui.add(Slider::new(expansion, -5.0..=5.0).text("expansion"))
+            .on_hover_text("make shapes this much larger");
+    }
+}
+
+impl Visuals {
+    /// Show radio-buttons to switch between light and dark mode.
+    pub fn light_dark_radio_buttons(&mut self, ui: &mut crate::Ui) {
+        ui.horizontal(|ui| {
+            ui.selectable_value(self, Self::light(), "☀ Light");
+            ui.selectable_value(self, Self::dark(), "🌙 Dark");
+        });
+    }
+
+    /// Show small toggle-button for light and dark mode.
+    #[must_use]
+    pub fn light_dark_small_toggle_button(&self, ui: &mut crate::Ui) -> Option<Self> {
+        #![allow(clippy::collapsible_else_if)]
+        if self.dark_mode {
+            if ui
+                .add(Button::new("☀").frame(false))
+                .on_hover_text("Switch to light mode")
+                .clicked()
+            {
+                return Some(Self::light());
+            }
+        } else {
+            if ui
+                .add(Button::new("🌙").frame(false))
+                .on_hover_text("Switch to dark mode")
+                .clicked()
+            {
+                return Some(Self::dark());
+            }
+        }
+        None
+    }
+
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            dark_mode: _,
+            override_text_color: _,
+            widgets,
+            selection,
+            hyperlink_color,
+            faint_bg_color,
+            extreme_bg_color,
+            code_bg_color,
+            warn_fg_color,
+            error_fg_color,
+
+            window_rounding,
+            window_shadow,
+            window_fill,
+            window_stroke,
+
+            menu_rounding,
+
+            panel_fill,
+
+            popup_shadow,
+
+            resize_corner_size,
+            text_cursor_width,
+            text_cursor_preview,
+            clip_rect_margin,
+            button_frame,
+            collapsing_header_frame,
+            indent_has_left_vline,
+
+            striped,
+
+            slider_trailing_fill,
+        } = self;
+
+        ui.collapsing("Background Colors", |ui| {
+            ui_color(ui, &mut widgets.inactive.weak_bg_fill, "Buttons");
+            ui_color(ui, window_fill, "Windows");
+            ui_color(ui, panel_fill, "Panels");
+            ui_color(ui, faint_bg_color, "Faint accent").on_hover_text(
+                "Used for faint accentuation of interactive things, like striped grids.",
+            );
+            ui_color(ui, extreme_bg_color, "Extreme")
+                .on_hover_text("Background of plots and paintings");
+        });
+
+        ui.collapsing("Window", |ui| {
+            ui_color(ui, window_fill, "Fill");
+            stroke_ui(ui, window_stroke, "Outline");
+            rounding_ui(ui, window_rounding);
+            shadow_ui(ui, window_shadow, "Shadow");
+        });
+
+        ui.collapsing("Menus and popups", |ui| {
+            rounding_ui(ui, menu_rounding);
+            shadow_ui(ui, popup_shadow, "Shadow");
+        });
+
+        ui.collapsing("Widgets", |ui| widgets.ui(ui));
+        ui.collapsing("Selection", |ui| selection.ui(ui));
+
+        ui.horizontal(|ui| {
+            ui_color(
+                ui,
+                &mut widgets.noninteractive.fg_stroke.color,
+                "Text color",
+            );
+            ui_color(ui, warn_fg_color, RichText::new("Warnings"));
+            ui_color(ui, error_fg_color, RichText::new("Errors"));
+        });
+
+        ui_color(ui, code_bg_color, RichText::new("Code background").code()).on_hover_ui(|ui| {
+            ui.horizontal(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("For monospaced inlined text ");
+                ui.code("like this");
+                ui.label(".");
+            });
+        });
+
+        ui_color(ui, hyperlink_color, "hyperlink_color");
+        ui.add(Slider::new(resize_corner_size, 0.0..=20.0).text("resize_corner_size"));
+        ui.add(Slider::new(text_cursor_width, 0.0..=4.0).text("text_cursor_width"));
+        ui.checkbox(text_cursor_preview, "Preview text cursor on hover");
+        ui.add(Slider::new(clip_rect_margin, 0.0..=20.0).text("clip_rect_margin"));
+
+        ui.checkbox(button_frame, "Button has a frame");
+        ui.checkbox(collapsing_header_frame, "Collapsing header has a frame");
+        ui.checkbox(
+            indent_has_left_vline,
+            "Paint a vertical line to the left of indented regions",
+        );
+
+        ui.checkbox(striped, "By default, add stripes to grids and tables?");
+
+        ui.checkbox(slider_trailing_fill, "Add trailing color to sliders");
+
+        ui.vertical_centered(|ui| reset_button(ui, self));
+    }
+}
+
+impl DebugOptions {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            debug_on_hover,
+            show_expand_width,
+            show_expand_height,
+            show_resize,
+            show_interactive_widgets,
+            show_blocking_widget,
+        } = self;
+
+        ui.checkbox(debug_on_hover, "Show debug info on hover");
+        ui.checkbox(
+            show_expand_width,
+            "Show which widgets make their parent wider",
+        );
+        ui.checkbox(
+            show_expand_height,
+            "Show which widgets make their parent higher",
+        );
+        ui.checkbox(show_resize, "Debug Resize");
+
+        ui.checkbox(
+            show_interactive_widgets,
+            "Show an overlay on all interactive widgets",
+        );
+
+        ui.checkbox(
+            show_blocking_widget,
+            "Show which widget blocks the interaction of another widget",
+        );
+
+        ui.vertical_centered(|ui| reset_button(ui, self));
+    }
+}
+
+// TODO(emilk): improve and standardize `slider_vec2`
+fn slider_vec2<'a>(
+    value: &'a mut Vec2,
+    range: std::ops::RangeInclusive<f32>,
+    text: &'a str,
+) -> impl Widget + 'a {
+    move |ui: &mut crate::Ui| {
+        ui.horizontal(|ui| {
+            ui.add(
+                DragValue::new(&mut value.x)
+                    .clamp_range(range.clone())
+                    .prefix("x: "),
+            );
+            ui.add(
+                DragValue::new(&mut value.y)
+                    .clamp_range(range.clone())
+                    .prefix("y: "),
+            );
+            ui.label(text);
+        })
+        .response
+    }
+}
+
+fn ui_color(ui: &mut Ui, srgba: &mut Color32, label: impl Into<WidgetText>) -> Response {
+    ui.horizontal(|ui| {
+        ui.color_edit_button_srgba(srgba);
+        ui.label(label);
+    })
+    .response
+}
+
+fn rounding_ui(ui: &mut Ui, rounding: &mut Rounding) {
+    const MAX: f32 = 20.0;
+    let mut same = rounding.is_same();
+    ui.group(|ui| {
+        ui.horizontal(|ui| {
+            ui.label("Rounding: ");
+            ui.radio_value(&mut same, true, "Same");
+            ui.radio_value(&mut same, false, "Separate");
+        });
+
+        if same {
+            let mut cr = rounding.nw;
+            ui.add(Slider::new(&mut cr, 0.0..=MAX));
+            *rounding = Rounding::same(cr);
+        } else {
+            ui.add(Slider::new(&mut rounding.nw, 0.0..=MAX).text("North-West"));
+            ui.add(Slider::new(&mut rounding.ne, 0.0..=MAX).text("North-East"));
+            ui.add(Slider::new(&mut rounding.sw, 0.0..=MAX).text("South-West"));
+            ui.add(Slider::new(&mut rounding.se, 0.0..=MAX).text("South-East"));
+            if rounding.is_same() {
+                rounding.se *= 1.00001;
+            }
+        }
+    });
+}
diff --git a/egui/crates/egui/src/ui.rs b/egui/crates/egui/src/ui.rs
new file mode 100644
index 0000000..13b3e81
--- /dev/null
+++ b/egui/crates/egui/src/ui.rs
@@ -0,0 +1,2233 @@
+// #![warn(missing_docs)]
+
+use std::hash::Hash;
+use std::sync::Arc;
+
+use epaint::mutex::RwLock;
+
+use crate::{
+    containers::*, ecolor::*, epaint::text::Fonts, layout::*, menu::MenuState, placer::Placer,
+    util::IdTypeMap, widgets::*, *,
+};
+
+// ----------------------------------------------------------------------------
+
+/// This is what you use to place widgets.
+///
+/// Represents a region of the screen with a type of layout (horizontal or vertical).
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// ui.add(egui::Label::new("Hello World!"));
+/// ui.label("A shorter and more convenient way to add a label.");
+/// ui.horizontal(|ui| {
+///     ui.label("Add widgets");
+///     if ui.button("on the same row!").clicked() {
+///         /* … */
+///     }
+/// });
+/// # });
+/// ```
+pub struct Ui {
+    /// ID of this ui.
+    /// Generated based on id of parent ui together with
+    /// another source of child identity (e.g. window title).
+    /// Acts like a namespace for child uis.
+    /// Should be unique and persist predictably from one frame to next
+    /// so it can be used as a source for storing state (e.g. window position, or if a collapsing header is open).
+    id: Id,
+
+    /// This is used to create a unique interact ID for some widgets.
+    /// This value is based on where in the hierarchy of widgets this Ui is in,
+    /// and the value is increment with each added child widget.
+    /// This works as an Id source only as long as new widgets aren't added or removed.
+    /// They are therefore only good for Id:s that has no state.
+    next_auto_id_source: u64,
+
+    /// Specifies paint layer, clip rectangle and a reference to [`Context`].
+    painter: Painter,
+
+    /// The [`Style`] (visuals, spacing, etc) of this ui.
+    /// Commonly many [`Ui`]:s share the same [`Style`].
+    /// The [`Ui`] implements copy-on-write for this.
+    style: Arc<Style>,
+
+    /// Handles the [`Ui`] size and the placement of new widgets.
+    placer: Placer,
+
+    /// If false we are unresponsive to input,
+    /// and all widgets will assume a gray style.
+    enabled: bool,
+
+    /// Indicates whether this Ui belongs to a Menu.
+    menu_state: Option<Arc<RwLock<MenuState>>>,
+}
+
+impl Ui {
+    // ------------------------------------------------------------------------
+    // Creation:
+
+    /// Create a new [`Ui`].
+    ///
+    /// Normally you would not use this directly, but instead use
+    /// [`SidePanel`], [`TopBottomPanel`], [`CentralPanel`], [`Window`] or [`Area`].
+    pub fn new(ctx: Context, layer_id: LayerId, id: Id, max_rect: Rect, clip_rect: Rect) -> Self {
+        let style = ctx.style();
+        Ui {
+            id,
+            next_auto_id_source: id.with("auto").value(),
+            painter: Painter::new(ctx, layer_id, clip_rect),
+            style,
+            placer: Placer::new(max_rect, Layout::default()),
+            enabled: true,
+            menu_state: None,
+        }
+    }
+
+    /// Create a new [`Ui`] at a specific region.
+    pub fn child_ui(&mut self, max_rect: Rect, layout: Layout) -> Self {
+        self.child_ui_with_id_source(max_rect, layout, "child")
+    }
+
+    /// Create a new [`Ui`] at a specific region with a specific id.
+    pub fn child_ui_with_id_source(
+        &mut self,
+        max_rect: Rect,
+        layout: Layout,
+        id_source: impl Hash,
+    ) -> Self {
+        crate::egui_assert!(!max_rect.any_nan());
+        let next_auto_id_source = Id::new(self.next_auto_id_source).with("child").value();
+        self.next_auto_id_source = self.next_auto_id_source.wrapping_add(1);
+        let menu_state = self.menu_state();
+        Ui {
+            id: self.id.with(id_source),
+            next_auto_id_source,
+            painter: self.painter.clone(),
+            style: self.style.clone(),
+            placer: Placer::new(max_rect, layout),
+            enabled: self.enabled,
+            menu_state,
+        }
+    }
+
+    // -------------------------------------------------
+
+    /// A unique identity of this [`Ui`].
+    #[inline]
+    pub fn id(&self) -> Id {
+        self.id
+    }
+
+    /// Style options for this [`Ui`] and its children.
+    ///
+    /// Note that this may be a different [`Style`] than that of [`Context::style`].
+    #[inline]
+    pub fn style(&self) -> &Arc<Style> {
+        &self.style
+    }
+
+    /// Mutably borrow internal [`Style`].
+    /// Changes apply to this [`Ui`] and its subsequent children.
+    ///
+    /// To set the style of all [`Ui`]:s, use [`Context::set_style`].
+    ///
+    /// Example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.style_mut().override_text_style = Some(egui::TextStyle::Heading);
+    /// # });
+    /// ```
+    pub fn style_mut(&mut self) -> &mut Style {
+        Arc::make_mut(&mut self.style) // clone-on-write
+    }
+
+    /// Changes apply to this [`Ui`] and its subsequent children.
+    ///
+    /// To set the visuals of all [`Ui`]:s, use [`Context::set_visuals`].
+    pub fn set_style(&mut self, style: impl Into<Arc<Style>>) {
+        self.style = style.into();
+    }
+
+    /// Reset to the default style set in [`Context`].
+    pub fn reset_style(&mut self) {
+        self.style = self.ctx().style();
+    }
+
+    /// The current spacing options for this [`Ui`].
+    /// Short for `ui.style().spacing`.
+    #[inline]
+    pub fn spacing(&self) -> &crate::style::Spacing {
+        &self.style.spacing
+    }
+
+    /// Mutably borrow internal [`Spacing`](crate::style::Spacing).
+    /// Changes apply to this [`Ui`] and its subsequent children.
+    ///
+    /// Example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.spacing_mut().item_spacing = egui::vec2(10.0, 2.0);
+    /// # });
+    /// ```
+    pub fn spacing_mut(&mut self) -> &mut crate::style::Spacing {
+        &mut self.style_mut().spacing
+    }
+
+    /// The current visuals settings of this [`Ui`].
+    /// Short for `ui.style().visuals`.
+    #[inline]
+    pub fn visuals(&self) -> &crate::Visuals {
+        &self.style.visuals
+    }
+
+    /// Mutably borrow internal `visuals`.
+    /// Changes apply to this [`Ui`] and its subsequent children.
+    ///
+    /// To set the visuals of all [`Ui`]:s, use [`Context::set_visuals`].
+    ///
+    /// Example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.visuals_mut().override_text_color = Some(egui::Color32::RED);
+    /// # });
+    /// ```
+    pub fn visuals_mut(&mut self) -> &mut crate::Visuals {
+        &mut self.style_mut().visuals
+    }
+
+    /// Get a reference to the parent [`Context`].
+    #[inline]
+    pub fn ctx(&self) -> &Context {
+        self.painter.ctx()
+    }
+
+    /// Use this to paint stuff within this [`Ui`].
+    #[inline]
+    pub fn painter(&self) -> &Painter {
+        &self.painter
+    }
+
+    /// If `false`, the [`Ui`] does not allow any interaction and
+    /// the widgets in it will draw with a gray look.
+    #[inline]
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// Calling `set_enabled(false)` will cause the [`Ui`] to deny all future interaction
+    /// and all the widgets will draw with a gray look.
+    ///
+    /// Usually it is more convenient to use [`Self::add_enabled_ui`] or [`Self::add_enabled`].
+    ///
+    /// Calling `set_enabled(true)` has no effect - it will NOT re-enable the [`Ui`] once disabled.
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut enabled = true;
+    /// ui.group(|ui| {
+    ///     ui.checkbox(&mut enabled, "Enable subsection");
+    ///     ui.set_enabled(enabled);
+    ///     if ui.button("Button that is not always clickable").clicked() {
+    ///         /* … */
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn set_enabled(&mut self, enabled: bool) {
+        self.enabled &= enabled;
+        if !self.enabled && self.is_visible() {
+            self.painter
+                .set_fade_to_color(Some(self.visuals().fade_out_to_color()));
+        }
+    }
+
+    /// If `false`, any widgets added to the [`Ui`] will be invisible and non-interactive.
+    #[inline]
+    pub fn is_visible(&self) -> bool {
+        self.painter.is_visible()
+    }
+
+    #[deprecated = "Renamed is_visible"]
+    pub fn visible(&self) -> bool {
+        self.painter.is_visible()
+    }
+
+    /// Calling `set_visible(false)` will cause all further widgets to be invisible,
+    /// yet still allocate space.
+    ///
+    /// The widgets will not be interactive (`set_visible(false)` implies `set_enabled(false)`).
+    ///
+    /// Calling `set_visible(true)` has no effect.
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut visible = true;
+    /// ui.group(|ui| {
+    ///     ui.checkbox(&mut visible, "Show subsection");
+    ///     ui.set_visible(visible);
+    ///     if ui.button("Button that is not always shown").clicked() {
+    ///         /* … */
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn set_visible(&mut self, visible: bool) {
+        self.set_enabled(visible);
+        if !visible {
+            self.painter.set_invisible();
+        }
+    }
+
+    #[inline]
+    pub fn layout(&self) -> &Layout {
+        self.placer.layout()
+    }
+
+    /// Should text wrap in this [`Ui`]?
+    ///
+    /// This is determined first by [`Style::wrap`], and then by the layout of this [`Ui`].
+    pub fn wrap_text(&self) -> bool {
+        if let Some(wrap) = self.style.wrap {
+            wrap
+        } else if let Some(grid) = self.placer.grid() {
+            grid.wrap_text()
+        } else {
+            let layout = self.layout();
+            layout.is_vertical() || layout.is_horizontal() && layout.main_wrap()
+        }
+    }
+
+    /// Create a painter for a sub-region of this Ui.
+    ///
+    /// The clip-rect of the returned [`Painter`] will be the intersection
+    /// of the given rectangle and the `clip_rect()` of this [`Ui`].
+    pub fn painter_at(&self, rect: Rect) -> Painter {
+        self.painter().with_clip_rect(rect)
+    }
+
+    /// Use this to paint stuff within this [`Ui`].
+    #[inline]
+    pub fn layer_id(&self) -> LayerId {
+        self.painter().layer_id()
+    }
+
+    /// The height of text of this text style
+    pub fn text_style_height(&self, style: &TextStyle) -> f32 {
+        self.fonts(|f| f.row_height(&style.resolve(self.style())))
+    }
+
+    /// Screen-space rectangle for clipping what we paint in this ui.
+    /// This is used, for instance, to avoid painting outside a window that is smaller than its contents.
+    #[inline]
+    pub fn clip_rect(&self) -> Rect {
+        self.painter.clip_rect()
+    }
+
+    /// Screen-space rectangle for clipping what we paint in this ui.
+    /// This is used, for instance, to avoid painting outside a window that is smaller than its contents.
+    pub fn set_clip_rect(&mut self, clip_rect: Rect) {
+        self.painter.set_clip_rect(clip_rect);
+    }
+
+    /// Can be used for culling: if `false`, then no part of `rect` will be visible on screen.
+    pub fn is_rect_visible(&self, rect: Rect) -> bool {
+        self.is_visible() && rect.intersects(self.clip_rect())
+    }
+}
+
+/// # Helpers for accessing the underlying [`Context`].
+/// These functions all lock the [`Context`] owned by this [`Ui`].
+/// Please see the documentation of [`Context`] for how locking works!
+impl Ui {
+    /// Read-only access to the shared [`InputState`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// if ui.input(|i| i.key_pressed(egui::Key::A)) {
+    ///     // …
+    /// }
+    /// # });
+    /// ```
+    #[inline]
+    pub fn input<R>(&self, reader: impl FnOnce(&InputState) -> R) -> R {
+        self.ctx().input(reader)
+    }
+
+    /// Read-write access to the shared [`InputState`].
+    #[inline]
+    pub fn input_mut<R>(&self, writer: impl FnOnce(&mut InputState) -> R) -> R {
+        self.ctx().input_mut(writer)
+    }
+
+    /// Read-only access to the shared [`Memory`].
+    #[inline]
+    pub fn memory<R>(&self, reader: impl FnOnce(&Memory) -> R) -> R {
+        self.ctx().memory(reader)
+    }
+
+    /// Read-write access to the shared [`Memory`].
+    #[inline]
+    pub fn memory_mut<R>(&self, writer: impl FnOnce(&mut Memory) -> R) -> R {
+        self.ctx().memory_mut(writer)
+    }
+
+    /// Read-only access to the shared [`IdTypeMap`], which stores superficial widget state.
+    #[inline]
+    pub fn data<R>(&self, reader: impl FnOnce(&IdTypeMap) -> R) -> R {
+        self.ctx().data(reader)
+    }
+
+    /// Read-write access to the shared [`IdTypeMap`], which stores superficial widget state.
+    #[inline]
+    pub fn data_mut<R>(&self, writer: impl FnOnce(&mut IdTypeMap) -> R) -> R {
+        self.ctx().data_mut(writer)
+    }
+
+    /// Read-only access to the shared [`PlatformOutput`].
+    ///
+    /// This is what egui outputs each frame.
+    ///
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::Progress);
+    /// ```
+    #[inline]
+    pub fn output<R>(&self, reader: impl FnOnce(&PlatformOutput) -> R) -> R {
+        self.ctx().output(reader)
+    }
+
+    /// Read-write access to the shared [`PlatformOutput`].
+    ///
+    /// This is what egui outputs each frame.
+    ///
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.output_mut(|o| o.cursor_icon = egui::CursorIcon::Progress);
+    /// ```
+    #[inline]
+    pub fn output_mut<R>(&self, writer: impl FnOnce(&mut PlatformOutput) -> R) -> R {
+        self.ctx().output_mut(writer)
+    }
+
+    /// Read-only access to [`Fonts`].
+    #[inline]
+    pub fn fonts<R>(&self, reader: impl FnOnce(&Fonts) -> R) -> R {
+        self.ctx().fonts(reader)
+    }
+}
+
+// ------------------------------------------------------------------------
+
+/// # Sizes etc
+impl Ui {
+    /// Where and how large the [`Ui`] is already.
+    /// All widgets that have been added to this [`Ui`] fits within this rectangle.
+    ///
+    /// No matter what, the final Ui will be at least this large.
+    ///
+    /// This will grow as new widgets are added, but never shrink.
+    pub fn min_rect(&self) -> Rect {
+        self.placer.min_rect()
+    }
+
+    /// Size of content; same as `min_rect().size()`
+    pub fn min_size(&self) -> Vec2 {
+        self.min_rect().size()
+    }
+
+    /// New widgets will *try* to fit within this rectangle.
+    ///
+    /// Text labels will wrap to fit within `max_rect`.
+    /// Separator lines will span the `max_rect`.
+    ///
+    /// If a new widget doesn't fit within the `max_rect` then the
+    /// [`Ui`] will make room for it by expanding both `min_rect` and `max_rect`.
+    pub fn max_rect(&self) -> Rect {
+        self.placer.max_rect()
+    }
+
+    /// Used for animation, kind of hacky
+    pub(crate) fn force_set_min_rect(&mut self, min_rect: Rect) {
+        self.placer.force_set_min_rect(min_rect);
+    }
+
+    // ------------------------------------------------------------------------
+
+    /// Set the maximum size of the ui.
+    /// You won't be able to shrink it below the current minimum size.
+    pub fn set_max_size(&mut self, size: Vec2) {
+        self.set_max_width(size.x);
+        self.set_max_height(size.y);
+    }
+
+    /// Set the maximum width of the ui.
+    /// You won't be able to shrink it below the current minimum size.
+    pub fn set_max_width(&mut self, width: f32) {
+        self.placer.set_max_width(width);
+    }
+
+    /// Set the maximum height of the ui.
+    /// You won't be able to shrink it below the current minimum size.
+    pub fn set_max_height(&mut self, height: f32) {
+        self.placer.set_max_height(height);
+    }
+
+    // ------------------------------------------------------------------------
+
+    /// Set the minimum size of the ui.
+    /// This can't shrink the ui, only make it larger.
+    pub fn set_min_size(&mut self, size: Vec2) {
+        self.set_min_width(size.x);
+        self.set_min_height(size.y);
+    }
+
+    /// Set the minimum width of the ui.
+    /// This can't shrink the ui, only make it larger.
+    pub fn set_min_width(&mut self, width: f32) {
+        self.placer.set_min_width(width);
+    }
+
+    /// Set the minimum height of the ui.
+    /// This can't shrink the ui, only make it larger.
+    pub fn set_min_height(&mut self, height: f32) {
+        self.placer.set_min_height(height);
+    }
+
+    // ------------------------------------------------------------------------
+
+    /// Helper: shrinks the max width to the current width,
+    /// so further widgets will try not to be wider than previous widgets.
+    /// Useful for normal vertical layouts.
+    pub fn shrink_width_to_current(&mut self) {
+        self.set_max_width(self.min_rect().width());
+    }
+
+    /// Helper: shrinks the max height to the current height,
+    /// so further widgets will try not to be wider than previous widgets.
+    pub fn shrink_height_to_current(&mut self) {
+        self.set_max_height(self.min_rect().height());
+    }
+
+    /// Expand the `min_rect` and `max_rect` of this ui to include a child at the given rect.
+    pub fn expand_to_include_rect(&mut self, rect: Rect) {
+        self.placer.expand_to_include_rect(rect);
+    }
+
+    /// `ui.set_width_range(min..=max);` is equivalent to `ui.set_min_width(min); ui.set_max_width(max);`.
+    pub fn set_width_range(&mut self, width: std::ops::RangeInclusive<f32>) {
+        self.set_min_width(*width.start());
+        self.set_max_width(*width.end());
+    }
+
+    /// `ui.set_height_range(min..=max);` is equivalent to `ui.set_min_height(min); ui.set_max_height(max);`.
+    pub fn set_height_range(&mut self, height: std::ops::RangeInclusive<f32>) {
+        self.set_min_height(*height.start());
+        self.set_max_height(*height.end());
+    }
+
+    /// Set both the minimum and maximum width.
+    pub fn set_width(&mut self, width: f32) {
+        self.set_min_width(width);
+        self.set_max_width(width);
+    }
+
+    /// Set both the minimum and maximum height.
+    pub fn set_height(&mut self, height: f32) {
+        self.set_min_height(height);
+        self.set_max_height(height);
+    }
+
+    /// Ensure we are big enough to contain the given x-coordinate.
+    /// This is sometimes useful to expand an ui to stretch to a certain place.
+    pub fn expand_to_include_x(&mut self, x: f32) {
+        self.placer.expand_to_include_x(x);
+    }
+
+    /// Ensure we are big enough to contain the given y-coordinate.
+    /// This is sometimes useful to expand an ui to stretch to a certain place.
+    pub fn expand_to_include_y(&mut self, y: f32) {
+        self.placer.expand_to_include_y(y);
+    }
+
+    // ------------------------------------------------------------------------
+    // Layout related measures:
+
+    /// The available space at the moment, given the current cursor.
+    /// This how much more space we can take up without overflowing our parent.
+    /// Shrinks as widgets allocate space and the cursor moves.
+    /// A small size should be interpreted as "as little as possible".
+    /// An infinite size should be interpreted as "as much as you want".
+    pub fn available_size(&self) -> Vec2 {
+        self.placer.available_size()
+    }
+
+    pub fn available_width(&self) -> f32 {
+        self.available_size().x
+    }
+
+    pub fn available_height(&self) -> f32 {
+        self.available_size().y
+    }
+
+    /// In case of a wrapping layout, how much space is left on this row/column?
+    pub fn available_size_before_wrap(&self) -> Vec2 {
+        self.placer.available_rect_before_wrap().size()
+    }
+
+    pub fn available_rect_before_wrap(&self) -> Rect {
+        self.placer.available_rect_before_wrap()
+    }
+}
+
+/// # [`Id`] creation
+impl Ui {
+    /// Use this to generate widget ids for widgets that have persistent state in [`Memory`].
+    pub fn make_persistent_id<IdSource>(&self, id_source: IdSource) -> Id
+    where
+        IdSource: Hash,
+    {
+        self.id.with(&id_source)
+    }
+
+    /// This is the `Id` that will be assigned to the next widget added to this `Ui`.
+    pub fn next_auto_id(&self) -> Id {
+        Id::new(self.next_auto_id_source)
+    }
+
+    pub fn auto_id_with<IdSource>(&self, id_source: IdSource) -> Id
+    where
+        IdSource: Hash,
+    {
+        Id::new(self.next_auto_id_source).with(id_source)
+    }
+
+    pub fn skip_ahead_auto_ids(&mut self, count: usize) {
+        self.next_auto_id_source = self.next_auto_id_source.wrapping_add(count as u64);
+    }
+}
+
+/// # Interaction
+impl Ui {
+    /// Check for clicks, drags and/or hover on a specific region of this [`Ui`].
+    pub fn interact(&self, rect: Rect, id: Id, sense: Sense) -> Response {
+        self.ctx().interact(
+            self.clip_rect(),
+            self.spacing().item_spacing,
+            self.layer_id(),
+            id,
+            rect,
+            sense,
+            self.enabled,
+        )
+    }
+
+    /// Check for clicks, and drags on a specific region that is hovered.
+    /// This can be used once you have checked that some shape you are painting has been hovered,
+    /// and want to check for clicks and drags on hovered items this frame.
+    /// The given [`Rect`] should approximately be where the thing is,
+    /// as it is just where warnings will be painted if there is an [`Id`] clash.
+    pub fn interact_with_hovered(
+        &self,
+        rect: Rect,
+        hovered: bool,
+        id: Id,
+        sense: Sense,
+    ) -> Response {
+        self.ctx()
+            .interact_with_hovered(self.layer_id(), id, rect, sense, self.enabled, hovered)
+    }
+
+    /// Is the pointer (mouse/touch) above this rectangle in this [`Ui`]?
+    ///
+    /// The `clip_rect` and layer of this [`Ui`] will be respected, so, for instance,
+    /// if this [`Ui`] is behind some other window, this will always return `false`.
+    pub fn rect_contains_pointer(&self, rect: Rect) -> bool {
+        self.ctx()
+            .rect_contains_pointer(self.layer_id(), self.clip_rect().intersect(rect))
+    }
+
+    /// Is the pointer (mouse/touch) above this [`Ui`]?
+    /// Equivalent to `ui.rect_contains_pointer(ui.min_rect())`
+    pub fn ui_contains_pointer(&self) -> bool {
+        self.rect_contains_pointer(self.min_rect())
+    }
+}
+
+/// # Allocating space: where do I put my widgets?
+impl Ui {
+    /// Allocate space for a widget and check for interaction in the space.
+    /// Returns a [`Response`] which contains a rectangle, id, and interaction info.
+    ///
+    /// ## How sizes are negotiated
+    /// Each widget should have a *minimum desired size* and a *desired size*.
+    /// When asking for space, ask AT LEAST for your minimum, and don't ask for more than you need.
+    /// If you want to fill the space, ask about [`Ui::available_size`] and use that.
+    ///
+    /// You may get MORE space than you asked for, for instance
+    /// for justified layouts, like in menus.
+    ///
+    /// You will never get a rectangle that is smaller than the amount of space you asked for.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// let response = ui.allocate_response(egui::vec2(100.0, 200.0), egui::Sense::click());
+    /// if response.clicked() { /* … */ }
+    /// ui.painter().rect_stroke(response.rect, 0.0, (1.0, egui::Color32::WHITE));
+    /// # });
+    /// ```
+    pub fn allocate_response(&mut self, desired_size: Vec2, sense: Sense) -> Response {
+        let (id, rect) = self.allocate_space(desired_size);
+        self.interact(rect, id, sense)
+    }
+
+    /// Returns a [`Rect`] with exactly what you asked for.
+    ///
+    /// The response rect will be larger if this is part of a justified layout or similar.
+    /// This means that if this is a narrow widget in a wide justified layout, then
+    /// the widget will react to interactions outside the returned [`Rect`].
+    pub fn allocate_exact_size(&mut self, desired_size: Vec2, sense: Sense) -> (Rect, Response) {
+        let response = self.allocate_response(desired_size, sense);
+        let rect = self
+            .placer
+            .align_size_within_rect(desired_size, response.rect);
+        (rect, response)
+    }
+
+    /// Allocate at least as much space as needed, and interact with that rect.
+    ///
+    /// The returned [`Rect`] will be the same size as `Response::rect`.
+    pub fn allocate_at_least(&mut self, desired_size: Vec2, sense: Sense) -> (Rect, Response) {
+        let response = self.allocate_response(desired_size, sense);
+        (response.rect, response)
+    }
+
+    /// Reserve this much space and move the cursor.
+    /// Returns where to put the widget.
+    ///
+    /// ## How sizes are negotiated
+    /// Each widget should have a *minimum desired size* and a *desired size*.
+    /// When asking for space, ask AT LEAST for your minimum, and don't ask for more than you need.
+    /// If you want to fill the space, ask about [`Ui::available_size`] and use that.
+    ///
+    /// You may get MORE space than you asked for, for instance
+    /// for justified layouts, like in menus.
+    ///
+    /// You will never get a rectangle that is smaller than the amount of space you asked for.
+    ///
+    /// Returns an automatic [`Id`] (which you can use for interaction) and the [`Rect`] of where to put your widget.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// let (id, rect) = ui.allocate_space(egui::vec2(100.0, 200.0));
+    /// let response = ui.interact(rect, id, egui::Sense::click());
+    /// # });
+    /// ```
+    pub fn allocate_space(&mut self, desired_size: Vec2) -> (Id, Rect) {
+        // For debug rendering
+        let original_available = self.available_size_before_wrap();
+        let too_wide = desired_size.x > original_available.x;
+        let too_high = desired_size.y > original_available.y;
+
+        let rect = self.allocate_space_impl(desired_size);
+
+        if self.style().debug.debug_on_hover && self.rect_contains_pointer(rect) {
+            let painter = self.ctx().debug_painter();
+            painter.rect_stroke(rect, 4.0, (1.0, Color32::LIGHT_BLUE));
+            self.placer.debug_paint_cursor(&painter, "next");
+        }
+
+        let debug_expand_width = self.style().debug.show_expand_width;
+        let debug_expand_height = self.style().debug.show_expand_height;
+
+        if (debug_expand_width && too_wide) || (debug_expand_height && too_high) {
+            self.painter
+                .rect_stroke(rect, 0.0, (1.0, Color32::LIGHT_BLUE));
+
+            let stroke = Stroke::new(2.5, Color32::from_rgb(200, 0, 0));
+            let paint_line_seg = |a, b| self.painter().line_segment([a, b], stroke);
+
+            if debug_expand_width && too_wide {
+                paint_line_seg(rect.left_top(), rect.left_bottom());
+                paint_line_seg(rect.left_center(), rect.right_center());
+                paint_line_seg(
+                    pos2(rect.left() + original_available.x, rect.top()),
+                    pos2(rect.left() + original_available.x, rect.bottom()),
+                );
+                paint_line_seg(rect.right_top(), rect.right_bottom());
+            }
+
+            if debug_expand_height && too_high {
+                paint_line_seg(rect.left_top(), rect.right_top());
+                paint_line_seg(rect.center_top(), rect.center_bottom());
+                paint_line_seg(rect.left_bottom(), rect.right_bottom());
+            }
+        }
+
+        let id = Id::new(self.next_auto_id_source);
+        self.next_auto_id_source = self.next_auto_id_source.wrapping_add(1);
+
+        (id, rect)
+    }
+
+    /// Reserve this much space and move the cursor.
+    /// Returns where to put the widget.
+    fn allocate_space_impl(&mut self, desired_size: Vec2) -> Rect {
+        let item_spacing = self.spacing().item_spacing;
+        let frame_rect = self.placer.next_space(desired_size, item_spacing);
+        egui_assert!(!frame_rect.any_nan());
+        let widget_rect = self.placer.justify_and_align(frame_rect, desired_size);
+
+        self.placer
+            .advance_after_rects(frame_rect, widget_rect, item_spacing);
+
+        widget_rect
+    }
+
+    /// Allocate a specific part of the [`Ui`].
+    ///
+    /// Ignore the layout of the [`Ui`]: just put my widget here!
+    /// The layout cursor will advance to past this `rect`.
+    pub fn allocate_rect(&mut self, rect: Rect, sense: Sense) -> Response {
+        let id = self.advance_cursor_after_rect(rect);
+        self.interact(rect, id, sense)
+    }
+
+    pub(crate) fn advance_cursor_after_rect(&mut self, rect: Rect) -> Id {
+        egui_assert!(!rect.any_nan());
+        let item_spacing = self.spacing().item_spacing;
+        self.placer.advance_after_rects(rect, rect, item_spacing);
+
+        if self.style().debug.debug_on_hover && self.rect_contains_pointer(rect) {
+            let painter = self.ctx().debug_painter();
+            painter.rect_stroke(rect, 4.0, (1.0, Color32::LIGHT_BLUE));
+            self.placer.debug_paint_cursor(&painter, "next");
+        }
+
+        let id = Id::new(self.next_auto_id_source);
+        self.next_auto_id_source = self.next_auto_id_source.wrapping_add(1);
+        id
+    }
+
+    pub(crate) fn placer(&self) -> &Placer {
+        &self.placer
+    }
+
+    /// Where the next widget will be put.
+    ///
+    /// One side of this will always be infinite: the direction in which new widgets will be added.
+    /// The opposing side is what is incremented.
+    /// The crossing sides are initialized to `max_rect`.
+    ///
+    /// So one can think of `cursor` as a constraint on the available region.
+    ///
+    /// If something has already been added, this will point to `style.spacing.item_spacing` beyond the latest child.
+    /// The cursor can thus be `style.spacing.item_spacing` pixels outside of the `min_rect`.
+    pub fn cursor(&self) -> Rect {
+        self.placer.cursor()
+    }
+
+    pub(crate) fn set_cursor(&mut self, cursor: Rect) {
+        self.placer.set_cursor(cursor);
+    }
+
+    /// Where do we expect a zero-sized widget to be placed?
+    pub fn next_widget_position(&self) -> Pos2 {
+        self.placer.next_widget_position()
+    }
+
+    /// Allocated the given space and then adds content to that space.
+    /// If the contents overflow, more space will be allocated.
+    /// When finished, the amount of space actually used (`min_rect`) will be allocated.
+    /// So you can request a lot of space and then use less.
+    #[inline]
+    pub fn allocate_ui<R>(
+        &mut self,
+        desired_size: Vec2,
+        add_contents: impl FnOnce(&mut Self) -> R,
+    ) -> InnerResponse<R> {
+        self.allocate_ui_with_layout(desired_size, *self.layout(), add_contents)
+    }
+
+    /// Allocated the given space and then adds content to that space.
+    /// If the contents overflow, more space will be allocated.
+    /// When finished, the amount of space actually used (`min_rect`) will be allocated.
+    /// So you can request a lot of space and then use less.
+    #[inline]
+    pub fn allocate_ui_with_layout<R>(
+        &mut self,
+        desired_size: Vec2,
+        layout: Layout,
+        add_contents: impl FnOnce(&mut Self) -> R,
+    ) -> InnerResponse<R> {
+        self.allocate_ui_with_layout_dyn(desired_size, layout, Box::new(add_contents))
+    }
+
+    fn allocate_ui_with_layout_dyn<'c, R>(
+        &mut self,
+        desired_size: Vec2,
+        layout: Layout,
+        add_contents: Box<dyn FnOnce(&mut Self) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        crate::egui_assert!(desired_size.x >= 0.0 && desired_size.y >= 0.0);
+        let item_spacing = self.spacing().item_spacing;
+        let frame_rect = self.placer.next_space(desired_size, item_spacing);
+        let child_rect = self.placer.justify_and_align(frame_rect, desired_size);
+
+        let mut child_ui = self.child_ui(child_rect, layout);
+        let ret = add_contents(&mut child_ui);
+        let final_child_rect = child_ui.min_rect();
+
+        self.placer
+            .advance_after_rects(final_child_rect, final_child_rect, item_spacing);
+
+        if self.style().debug.debug_on_hover && self.rect_contains_pointer(final_child_rect) {
+            let painter = self.ctx().debug_painter();
+            painter.rect_stroke(frame_rect, 4.0, (1.0, Color32::LIGHT_BLUE));
+            painter.rect_stroke(final_child_rect, 4.0, (1.0, Color32::LIGHT_BLUE));
+            self.placer.debug_paint_cursor(&painter, "next");
+        }
+
+        let response = self.interact(final_child_rect, child_ui.id, Sense::hover());
+        InnerResponse::new(ret, response)
+    }
+
+    /// Allocated the given rectangle and then adds content to that rectangle.
+    /// If the contents overflow, more space will be allocated.
+    /// When finished, the amount of space actually used (`min_rect`) will be allocated.
+    /// So you can request a lot of space and then use less.
+    pub fn allocate_ui_at_rect<R>(
+        &mut self,
+        max_rect: Rect,
+        add_contents: impl FnOnce(&mut Self) -> R,
+    ) -> InnerResponse<R> {
+        egui_assert!(max_rect.is_finite());
+        let mut child_ui = self.child_ui(max_rect, *self.layout());
+        let ret = add_contents(&mut child_ui);
+        let final_child_rect = child_ui.min_rect();
+
+        self.placer.advance_after_rects(
+            final_child_rect,
+            final_child_rect,
+            self.spacing().item_spacing,
+        );
+
+        let response = self.interact(final_child_rect, child_ui.id, Sense::hover());
+        InnerResponse::new(ret, response)
+    }
+
+    /// Convenience function to get a region to paint on.
+    ///
+    /// Note that egui uses screen coordinates for everything.
+    ///
+    /// ```
+    /// # use egui::*;
+    /// # use std::f32::consts::TAU;
+    /// # egui::__run_test_ui(|ui| {
+    /// let size = Vec2::splat(16.0);
+    /// let (response, painter) = ui.allocate_painter(size, Sense::hover());
+    /// let rect = response.rect;
+    /// let c = rect.center();
+    /// let r = rect.width() / 2.0 - 1.0;
+    /// let color = Color32::from_gray(128);
+    /// let stroke = Stroke::new(1.0, color);
+    /// painter.circle_stroke(c, r, stroke);
+    /// painter.line_segment([c - vec2(0.0, r), c + vec2(0.0, r)], stroke);
+    /// painter.line_segment([c, c + r * Vec2::angled(TAU * 1.0 / 8.0)], stroke);
+    /// painter.line_segment([c, c + r * Vec2::angled(TAU * 3.0 / 8.0)], stroke);
+    /// # });
+    /// ```
+    pub fn allocate_painter(&mut self, desired_size: Vec2, sense: Sense) -> (Response, Painter) {
+        let response = self.allocate_response(desired_size, sense);
+        let clip_rect = self.clip_rect().intersect(response.rect); // Make sure we don't paint out of bounds
+        let painter = Painter::new(self.ctx().clone(), self.layer_id(), clip_rect);
+        (response, painter)
+    }
+
+    /// Adjust the scroll position of any parent [`ScrollArea`] so that the given [`Rect`] becomes visible.
+    ///
+    /// If `align` is `None`, it'll scroll enough to bring the cursor into view.
+    ///
+    /// See also: [`Response::scroll_to_me`], [`Ui::scroll_to_cursor`]. [`Ui::scroll_with_delta`]..
+    ///
+    /// ```
+    /// # use egui::Align;
+    /// # egui::__run_test_ui(|ui| {
+    /// egui::ScrollArea::vertical().show(ui, |ui| {
+    ///     // …
+    ///     let response = ui.button("Center on me.");
+    ///     if response.clicked() {
+    ///         ui.scroll_to_rect(response.rect, Some(Align::Center));
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn scroll_to_rect(&self, rect: Rect, align: Option<Align>) {
+        for d in 0..2 {
+            let range = rect.min[d]..=rect.max[d];
+            self.ctx()
+                .frame_state_mut(|state| state.scroll_target[d] = Some((range, align)));
+        }
+    }
+
+    /// Adjust the scroll position of any parent [`ScrollArea`] so that the cursor (where the next widget goes) becomes visible.
+    ///
+    /// If `align` is not provided, it'll scroll enough to bring the cursor into view.
+    ///
+    /// See also: [`Response::scroll_to_me`], [`Ui::scroll_to_rect`]. [`Ui::scroll_with_delta`].
+    ///
+    /// ```
+    /// # use egui::Align;
+    /// # egui::__run_test_ui(|ui| {
+    /// egui::ScrollArea::vertical().show(ui, |ui| {
+    ///     let scroll_bottom = ui.button("Scroll to bottom.").clicked();
+    ///     for i in 0..1000 {
+    ///         ui.label(format!("Item {}", i));
+    ///     }
+    ///
+    ///     if scroll_bottom {
+    ///         ui.scroll_to_cursor(Some(Align::BOTTOM));
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn scroll_to_cursor(&self, align: Option<Align>) {
+        let target = self.next_widget_position();
+        for d in 0..2 {
+            let target = target[d];
+            self.ctx()
+                .frame_state_mut(|state| state.scroll_target[d] = Some((target..=target, align)));
+        }
+    }
+
+    /// Scroll this many points in the given direction, in the parent [`ScrollArea`].
+    ///
+    /// The delta dictates how the _content_ (i.e. this UI) should move.
+    ///
+    /// A positive X-value indicates the content is being moved right,
+    /// as when swiping right on a touch-screen or track-pad with natural scrolling.
+    ///
+    /// A positive Y-value indicates the content is being moved down,
+    /// as when swiping down on a touch-screen or track-pad with natural scrolling.
+    ///
+    /// /// See also: [`Response::scroll_to_me`], [`Ui::scroll_to_rect`], [`Ui::scroll_to_cursor`]
+    ///
+    /// ```
+    /// # use egui::{Align, Vec2};
+    /// # egui::__run_test_ui(|ui| {
+    /// let mut scroll_delta = Vec2::ZERO;
+    /// if ui.button("Scroll down").clicked() {
+    ///     scroll_delta.y -= 64.0; // move content up
+    /// }
+    /// egui::ScrollArea::vertical().show(ui, |ui| {
+    ///     ui.scroll_with_delta(scroll_delta);
+    ///     for i in 0..1000 {
+    ///         ui.label(format!("Item {}", i));
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn scroll_with_delta(&self, delta: Vec2) {
+        self.ctx()
+            .frame_state_mut(|state| state.scroll_delta += delta);
+    }
+}
+
+/// # Adding widgets
+impl Ui {
+    /// Add a [`Widget`] to this [`Ui`] at a location dependent on the current [`Layout`].
+    ///
+    /// The returned [`Response`] can be used to check for interactions,
+    /// as well as adding tooltips using [`Response::on_hover_text`].
+    ///
+    /// See also [`Self::add_sized`] and [`Self::put`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_value = 42;
+    /// let response = ui.add(egui::Slider::new(&mut my_value, 0..=100));
+    /// response.on_hover_text("Drag me!");
+    /// # });
+    /// ```
+    #[inline]
+    pub fn add(&mut self, widget: impl Widget) -> Response {
+        widget.ui(self)
+    }
+
+    /// Add a [`Widget`] to this [`Ui`] with a given size.
+    /// The widget will attempt to fit within the given size, but some widgets may overflow.
+    ///
+    /// To fill all remaining area, use `ui.add_sized(ui.available_size(), widget);`
+    ///
+    /// See also [`Self::add`] and [`Self::put`].
+    ///
+    /// ```
+    /// # let mut my_value = 42;
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.add_sized([40.0, 20.0], egui::DragValue::new(&mut my_value));
+    /// # });
+    /// ```
+    pub fn add_sized(&mut self, max_size: impl Into<Vec2>, widget: impl Widget) -> Response {
+        // TODO(emilk): configure to overflow to main_dir instead of centered overflow
+        // to handle the bug mentioned at https://github.com/emilk/egui/discussions/318#discussioncomment-627578
+        // and fixed in https://github.com/emilk/egui/commit/035166276322b3f2324bd8b97ffcedc63fa8419f
+        //
+        // Make sure we keep the same main direction since it changes e.g. how text is wrapped:
+        let layout = Layout::centered_and_justified(self.layout().main_dir());
+        self.allocate_ui_with_layout(max_size.into(), layout, |ui| ui.add(widget))
+            .inner
+    }
+
+    /// Add a [`Widget`] to this [`Ui`] at a specific location (manual layout).
+    ///
+    /// See also [`Self::add`] and [`Self::add_sized`].
+    pub fn put(&mut self, max_rect: Rect, widget: impl Widget) -> Response {
+        self.allocate_ui_at_rect(max_rect, |ui| {
+            ui.centered_and_justified(|ui| ui.add(widget)).inner
+        })
+        .inner
+    }
+
+    /// Add a single [`Widget`] that is possibly disabled, i.e. greyed out and non-interactive.
+    ///
+    /// If you call `add_enabled` from within an already disabled [`Ui`],
+    /// the widget will always be disabled, even if the `enabled` argument is true.
+    ///
+    /// See also [`Self::add_enabled_ui`] and [`Self::is_enabled`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.add_enabled(false, egui::Button::new("Can't click this"));
+    /// # });
+    /// ```
+    pub fn add_enabled(&mut self, enabled: bool, widget: impl Widget) -> Response {
+        if self.is_enabled() && !enabled {
+            let old_painter = self.painter.clone();
+            self.set_enabled(false);
+            let response = self.add(widget);
+            self.enabled = true;
+            self.painter = old_painter;
+            response
+        } else {
+            self.add(widget)
+        }
+    }
+
+    /// Add a section that is possibly disabled, i.e. greyed out and non-interactive.
+    ///
+    /// If you call `add_enabled_ui` from within an already disabled [`Ui`],
+    /// the result will always be disabled, even if the `enabled` argument is true.
+    ///
+    /// See also [`Self::add_enabled`] and [`Self::is_enabled`].
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut enabled = true;
+    /// ui.checkbox(&mut enabled, "Enable subsection");
+    /// ui.add_enabled_ui(enabled, |ui| {
+    ///     if ui.button("Button that is not always clickable").clicked() {
+    ///         /* … */
+    ///     }
+    /// });
+    /// # });
+    /// ```
+    pub fn add_enabled_ui<R>(
+        &mut self,
+        enabled: bool,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.scope(|ui| {
+            ui.set_enabled(enabled);
+            add_contents(ui)
+        })
+    }
+
+    /// Add a single [`Widget`] that is possibly invisible.
+    ///
+    /// An invisible widget still takes up the same space as if it were visible.
+    ///
+    /// If you call `add_visible` from within an already invisible [`Ui`],
+    /// the widget will always be invisible, even if the `visible` argument is true.
+    ///
+    /// See also [`Self::add_visible_ui`], [`Self::set_visible`] and [`Self::is_visible`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.add_visible(false, egui::Label::new("You won't see me!"));
+    /// # });
+    /// ```
+    pub fn add_visible(&mut self, visible: bool, widget: impl Widget) -> Response {
+        if self.is_visible() && !visible {
+            // temporary make us invisible:
+            let old_painter = self.painter.clone();
+            let old_enabled = self.enabled;
+
+            self.set_visible(false);
+
+            let response = self.add(widget);
+
+            self.painter = old_painter;
+            self.enabled = old_enabled;
+            response
+        } else {
+            self.add(widget)
+        }
+    }
+
+    /// Add a section that is possibly invisible, i.e. greyed out and non-interactive.
+    ///
+    /// An invisible ui still takes up the same space as if it were visible.
+    ///
+    /// If you call `add_visible_ui` from within an already invisible [`Ui`],
+    /// the result will always be invisible, even if the `visible` argument is true.
+    ///
+    /// See also [`Self::add_visible`], [`Self::set_visible`] and [`Self::is_visible`].
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut visible = true;
+    /// ui.checkbox(&mut visible, "Show subsection");
+    /// ui.add_visible_ui(visible, |ui| {
+    ///     ui.label("Maybe you see this, maybe you don't!");
+    /// });
+    /// # });
+    /// ```
+    pub fn add_visible_ui<R>(
+        &mut self,
+        visible: bool,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.scope(|ui| {
+            ui.set_visible(visible);
+            add_contents(ui)
+        })
+    }
+
+    /// Add extra space before the next widget.
+    ///
+    /// The direction is dependent on the layout.
+    /// This will be in addition to the [`crate::style::Spacing::item_spacing`].
+    ///
+    /// [`Self::min_rect`] will expand to contain the space.
+    #[inline]
+    pub fn add_space(&mut self, amount: f32) {
+        self.placer.advance_cursor(amount);
+    }
+
+    /// Show some text.
+    ///
+    /// Shortcut for `add(Label::new(text))`
+    ///
+    /// See also [`Label`].
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// use egui::{RichText, FontId, Color32};
+    /// ui.label("Normal text");
+    /// ui.label(RichText::new("Large text").font(FontId::proportional(40.0)));
+    /// ui.label(RichText::new("Red text").color(Color32::RED));
+    /// # });
+    /// ```
+    #[inline]
+    pub fn label(&mut self, text: impl Into<WidgetText>) -> Response {
+        Label::new(text).ui(self)
+    }
+
+    /// Show colored text.
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).color(color))`
+    pub fn colored_label(
+        &mut self,
+        color: impl Into<Color32>,
+        text: impl Into<RichText>,
+    ) -> Response {
+        Label::new(text.into().color(color)).ui(self)
+    }
+
+    /// Show large text.
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).heading())`
+    pub fn heading(&mut self, text: impl Into<RichText>) -> Response {
+        Label::new(text.into().heading()).ui(self)
+    }
+
+    /// Show monospace (fixed width) text.
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).monospace())`
+    pub fn monospace(&mut self, text: impl Into<RichText>) -> Response {
+        Label::new(text.into().monospace()).ui(self)
+    }
+
+    /// Show text as monospace with a gray background.
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).code())`
+    pub fn code(&mut self, text: impl Into<RichText>) -> Response {
+        Label::new(text.into().code()).ui(self)
+    }
+
+    /// Show small text.
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).small())`
+    pub fn small(&mut self, text: impl Into<RichText>) -> Response {
+        Label::new(text.into().small()).ui(self)
+    }
+
+    /// Show text that stand out a bit (e.g. slightly brighter).
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).strong())`
+    pub fn strong(&mut self, text: impl Into<RichText>) -> Response {
+        Label::new(text.into().strong()).ui(self)
+    }
+
+    /// Show text that is weaker (fainter color).
+    ///
+    /// Shortcut for `ui.label(RichText::new(text).weak())`
+    pub fn weak(&mut self, text: impl Into<RichText>) -> Response {
+        Label::new(text.into().weak()).ui(self)
+    }
+
+    /// Looks like a hyperlink.
+    ///
+    /// Shortcut for `add(Link::new(text))`.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// if ui.link("Documentation").clicked() {
+    ///     // …
+    /// }
+    /// # });
+    /// ```
+    ///
+    /// See also [`Link`].
+    #[must_use = "You should check if the user clicked this with `if ui.link(…).clicked() { … } "]
+    pub fn link(&mut self, text: impl Into<WidgetText>) -> Response {
+        Link::new(text).ui(self)
+    }
+
+    /// Link to a web page.
+    ///
+    /// Shortcut for `add(Hyperlink::new(url))`.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.hyperlink("https://www.egui.rs/");
+    /// # });
+    /// ```
+    ///
+    /// See also [`Hyperlink`].
+    pub fn hyperlink(&mut self, url: impl ToString) -> Response {
+        Hyperlink::new(url).ui(self)
+    }
+
+    /// Shortcut for `add(Hyperlink::new(url).text(label))`.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.hyperlink_to("egui on GitHub", "https://www.github.com/emilk/egui/");
+    /// # });
+    /// ```
+    ///
+    /// See also [`Hyperlink`].
+    pub fn hyperlink_to(&mut self, label: impl Into<WidgetText>, url: impl ToString) -> Response {
+        Hyperlink::from_label_and_url(label, url).ui(self)
+    }
+
+    /// No newlines (`\n`) allowed. Pressing enter key will result in the [`TextEdit`] losing focus (`response.lost_focus`).
+    ///
+    /// See also [`TextEdit`].
+    pub fn text_edit_singleline<S: widgets::text_edit::TextBuffer>(
+        &mut self,
+        text: &mut S,
+    ) -> Response {
+        TextEdit::singleline(text).ui(self)
+    }
+
+    /// A [`TextEdit`] for multiple lines. Pressing enter key will create a new line.
+    ///
+    /// See also [`TextEdit`].
+    pub fn text_edit_multiline<S: widgets::text_edit::TextBuffer>(
+        &mut self,
+        text: &mut S,
+    ) -> Response {
+        TextEdit::multiline(text).ui(self)
+    }
+
+    /// A [`TextEdit`] for code editing.
+    ///
+    /// This will be multiline, monospace, and will insert tabs instead of moving focus.
+    ///
+    /// See also [`TextEdit::code_editor`].
+    pub fn code_editor<S: widgets::text_edit::TextBuffer>(&mut self, text: &mut S) -> Response {
+        self.add(TextEdit::multiline(text).code_editor())
+    }
+
+    /// Usage: `if ui.button("Click me").clicked() { … }`
+    ///
+    /// Shortcut for `add(Button::new(text))`
+    ///
+    /// See also [`Button`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// if ui.button("Click me!").clicked() {
+    ///     // …
+    /// }
+    ///
+    /// # use egui::{RichText, Color32};
+    /// if ui.button(RichText::new("delete").color(Color32::RED)).clicked() {
+    ///     // …
+    /// }
+    /// # });
+    /// ```
+    #[must_use = "You should check if the user clicked this with `if ui.button(…).clicked() { … } "]
+    #[inline]
+    pub fn button(&mut self, text: impl Into<WidgetText>) -> Response {
+        Button::new(text).ui(self)
+    }
+
+    /// A button as small as normal body text.
+    ///
+    /// Usage: `if ui.small_button("Click me").clicked() { … }`
+    ///
+    /// Shortcut for `add(Button::new(text).small())`
+    #[must_use = "You should check if the user clicked this with `if ui.small_button(…).clicked() { … } "]
+    pub fn small_button(&mut self, text: impl Into<WidgetText>) -> Response {
+        Button::new(text).small().ui(self)
+    }
+
+    /// Show a checkbox.
+    ///
+    /// See also [`Self::toggle_value`].
+    #[inline]
+    pub fn checkbox(&mut self, checked: &mut bool, text: impl Into<WidgetText>) -> Response {
+        Checkbox::new(checked, text).ui(self)
+    }
+
+    /// Acts like a checkbox, but looks like a [`SelectableLabel`].
+    ///
+    /// Click to toggle to bool.
+    ///
+    /// See also [`Self::checkbox`].
+    pub fn toggle_value(&mut self, selected: &mut bool, text: impl Into<WidgetText>) -> Response {
+        let mut response = self.selectable_label(*selected, text);
+        if response.clicked() {
+            *selected = !*selected;
+            response.mark_changed();
+        }
+        response
+    }
+
+    /// Show a [`RadioButton`].
+    /// Often you want to use [`Self::radio_value`] instead.
+    #[must_use = "You should check if the user clicked this with `if ui.radio(…).clicked() { … } "]
+    #[inline]
+    pub fn radio(&mut self, selected: bool, text: impl Into<WidgetText>) -> Response {
+        RadioButton::new(selected, text).ui(self)
+    }
+
+    /// Show a [`RadioButton`]. It is selected if `*current_value == selected_value`.
+    /// If clicked, `selected_value` is assigned to `*current_value`.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    ///
+    /// #[derive(PartialEq)]
+    /// enum Enum { First, Second, Third }
+    /// let mut my_enum = Enum::First;
+    ///
+    /// ui.radio_value(&mut my_enum, Enum::First, "First");
+    ///
+    /// // is equivalent to:
+    ///
+    /// if ui.add(egui::RadioButton::new(my_enum == Enum::First, "First")).clicked() {
+    ///     my_enum = Enum::First
+    /// }
+    /// # });
+    /// ```
+    pub fn radio_value<Value: PartialEq>(
+        &mut self,
+        current_value: &mut Value,
+        alternative: Value,
+        text: impl Into<WidgetText>,
+    ) -> Response {
+        let mut response = self.radio(*current_value == alternative, text);
+        if response.clicked() && *current_value != alternative {
+            *current_value = alternative;
+            response.mark_changed();
+        }
+        response
+    }
+
+    /// Show a label which can be selected or not.
+    ///
+    /// See also [`SelectableLabel`] and [`Self::toggle_value`].
+    #[must_use = "You should check if the user clicked this with `if ui.selectable_label(…).clicked() { … } "]
+    pub fn selectable_label(&mut self, checked: bool, text: impl Into<WidgetText>) -> Response {
+        SelectableLabel::new(checked, text).ui(self)
+    }
+
+    /// Show selectable text. It is selected if `*current_value == selected_value`.
+    /// If clicked, `selected_value` is assigned to `*current_value`.
+    ///
+    /// Example: `ui.selectable_value(&mut my_enum, Enum::Alternative, "Alternative")`.
+    ///
+    /// See also [`SelectableLabel`] and [`Self::toggle_value`].
+    pub fn selectable_value<Value: PartialEq>(
+        &mut self,
+        current_value: &mut Value,
+        selected_value: Value,
+        text: impl Into<WidgetText>,
+    ) -> Response {
+        let mut response = self.selectable_label(*current_value == selected_value, text);
+        if response.clicked() && *current_value != selected_value {
+            *current_value = selected_value;
+            response.mark_changed();
+        }
+        response
+    }
+
+    /// Shortcut for `add(Separator::default())`
+    ///
+    /// See also [`Separator`].
+    #[inline]
+    pub fn separator(&mut self) -> Response {
+        Separator::default().ui(self)
+    }
+
+    /// Shortcut for `add(Spinner::new())`
+    ///
+    /// See also [`Spinner`].
+    #[inline]
+    pub fn spinner(&mut self) -> Response {
+        Spinner::new().ui(self)
+    }
+
+    /// Modify an angle. The given angle should be in radians, but is shown to the user in degrees.
+    /// The angle is NOT wrapped, so the user may select, for instance 720° = 2𝞃 = 4π
+    pub fn drag_angle(&mut self, radians: &mut f32) -> Response {
+        let mut degrees = radians.to_degrees();
+        let mut response = self.add(DragValue::new(&mut degrees).speed(1.0).suffix("°"));
+
+        // only touch `*radians` if we actually changed the degree value
+        if degrees != radians.to_degrees() {
+            *radians = degrees.to_radians();
+            response.changed = true;
+        }
+
+        response
+    }
+
+    /// Modify an angle. The given angle should be in radians,
+    /// but is shown to the user in fractions of one Tau (i.e. fractions of one turn).
+    /// The angle is NOT wrapped, so the user may select, for instance 2𝞃 (720°)
+    pub fn drag_angle_tau(&mut self, radians: &mut f32) -> Response {
+        use std::f32::consts::TAU;
+
+        let mut taus = *radians / TAU;
+        let mut response = self.add(DragValue::new(&mut taus).speed(0.01).suffix("τ"));
+
+        if self.style().explanation_tooltips {
+            response =
+                response.on_hover_text("1τ = one turn, 0.5τ = half a turn, etc. 0.25τ = 90°");
+        }
+
+        // only touch `*radians` if we actually changed the value
+        if taus != *radians / TAU {
+            *radians = taus * TAU;
+            response.changed = true;
+        }
+
+        response
+    }
+
+    /// Show an image here with the given size.
+    ///
+    /// In order to display an image you must first acquire a [`TextureHandle`].
+    /// This is best done with [`egui_extras::RetainedImage`](https://docs.rs/egui_extras/latest/egui_extras/image/struct.RetainedImage.html) or [`Context::load_texture`].
+    ///
+    /// ```
+    /// struct MyImage {
+    ///     texture: Option<egui::TextureHandle>,
+    /// }
+    ///
+    /// impl MyImage {
+    ///     fn ui(&mut self, ui: &mut egui::Ui) {
+    ///         let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+    ///             // Load the texture only once.
+    ///             ui.ctx().load_texture(
+    ///                 "my-image",
+    ///                 egui::ColorImage::example(),
+    ///                 Default::default()
+    ///             )
+    ///         });
+    ///
+    ///         // Show the image:
+    ///         ui.image(texture, texture.size_vec2());
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// See also [`crate::Image`] and [`crate::ImageButton`].
+    #[inline]
+    pub fn image(&mut self, texture_id: impl Into<TextureId>, size: impl Into<Vec2>) -> Response {
+        Image::new(texture_id, size).ui(self)
+    }
+}
+
+/// # Colors
+impl Ui {
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    pub fn color_edit_button_srgba(&mut self, srgba: &mut Color32) -> Response {
+        color_picker::color_edit_button_srgba(self, srgba, color_picker::Alpha::BlendOrAdditive)
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    pub fn color_edit_button_hsva(&mut self, hsva: &mut Hsva) -> Response {
+        color_picker::color_edit_button_hsva(self, hsva, color_picker::Alpha::BlendOrAdditive)
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    /// The given color is in `sRGB` space.
+    pub fn color_edit_button_srgb(&mut self, srgb: &mut [u8; 3]) -> Response {
+        color_picker::color_edit_button_srgb(self, srgb)
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    /// The given color is in linear RGB space.
+    pub fn color_edit_button_rgb(&mut self, rgb: &mut [f32; 3]) -> Response {
+        color_picker::color_edit_button_rgb(self, rgb)
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    /// The given color is in `sRGBA` space with premultiplied alpha
+    pub fn color_edit_button_srgba_premultiplied(&mut self, srgba: &mut [u8; 4]) -> Response {
+        let mut color = Color32::from_rgba_premultiplied(srgba[0], srgba[1], srgba[2], srgba[3]);
+        let response = self.color_edit_button_srgba(&mut color);
+        *srgba = color.to_array();
+        response
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    /// The given color is in `sRGBA` space without premultiplied alpha.
+    /// If unsure, what "premultiplied alpha" is, then this is probably the function you want to use.
+    pub fn color_edit_button_srgba_unmultiplied(&mut self, srgba: &mut [u8; 4]) -> Response {
+        let mut rgba = Rgba::from_srgba_unmultiplied(srgba[0], srgba[1], srgba[2], srgba[3]);
+        let response =
+            color_picker::color_edit_button_rgba(self, &mut rgba, color_picker::Alpha::OnlyBlend);
+        *srgba = rgba.to_srgba_unmultiplied();
+        response
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    /// The given color is in linear RGBA space with premultiplied alpha
+    pub fn color_edit_button_rgba_premultiplied(&mut self, rgba_premul: &mut [f32; 4]) -> Response {
+        let mut rgba = Rgba::from_rgba_premultiplied(
+            rgba_premul[0],
+            rgba_premul[1],
+            rgba_premul[2],
+            rgba_premul[3],
+        );
+        let response = color_picker::color_edit_button_rgba(
+            self,
+            &mut rgba,
+            color_picker::Alpha::BlendOrAdditive,
+        );
+        *rgba_premul = rgba.to_array();
+        response
+    }
+
+    /// Shows a button with the given color.
+    /// If the user clicks the button, a full color picker is shown.
+    /// The given color is in linear RGBA space without premultiplied alpha.
+    /// If unsure, what "premultiplied alpha" is, then this is probably the function you want to use.
+    pub fn color_edit_button_rgba_unmultiplied(&mut self, rgba_unmul: &mut [f32; 4]) -> Response {
+        let mut rgba = Rgba::from_rgba_unmultiplied(
+            rgba_unmul[0],
+            rgba_unmul[1],
+            rgba_unmul[2],
+            rgba_unmul[3],
+        );
+        let response =
+            color_picker::color_edit_button_rgba(self, &mut rgba, color_picker::Alpha::OnlyBlend);
+        *rgba_unmul = rgba.to_rgba_unmultiplied();
+        response
+    }
+}
+
+/// # Adding Containers / Sub-uis:
+impl Ui {
+    /// Put into a [`Frame::group`], visually grouping the contents together
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.group(|ui| {
+    ///     ui.label("Within a frame");
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// Se also [`Self::scope`].
+    pub fn group<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        crate::Frame::group(self.style()).show(self, add_contents)
+    }
+
+    /// Create a child Ui with an explicit [`Id`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// for i in 0..10 {
+    ///     // ui.collapsing("Same header", |ui| { }); // this will cause an ID clash because of the same title!
+    ///
+    ///     ui.push_id(i, |ui| {
+    ///         ui.collapsing("Same header", |ui| { }); // this is fine!
+    ///     });
+    /// }
+    /// # });
+    /// ```
+    pub fn push_id<R>(
+        &mut self,
+        id_source: impl Hash,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.scope_dyn(Box::new(add_contents), Id::new(id_source))
+    }
+
+    /// Create a scoped child ui.
+    ///
+    /// You can use this to temporarily change the [`Style`] of a sub-region, for instance:
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.scope(|ui| {
+    ///     ui.spacing_mut().slider_width = 200.0; // Temporary change
+    ///     // …
+    /// });
+    /// # });
+    /// ```
+    pub fn scope<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        self.scope_dyn(Box::new(add_contents), Id::new("child"))
+    }
+
+    fn scope_dyn<'c, R>(
+        &mut self,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+        id_source: Id,
+    ) -> InnerResponse<R> {
+        let child_rect = self.available_rect_before_wrap();
+        let next_auto_id_source = self.next_auto_id_source;
+        let mut child_ui = self.child_ui_with_id_source(child_rect, *self.layout(), id_source);
+        self.next_auto_id_source = next_auto_id_source; // HACK: we want `scope` to only increment this once, so that `ui.scope` is equivalent to `ui.allocate_space`.
+        let ret = add_contents(&mut child_ui);
+        let response = self.allocate_rect(child_ui.min_rect(), Sense::hover());
+        InnerResponse::new(ret, response)
+    }
+
+    /// Redirect shapes to another paint layer.
+    pub fn with_layer_id<R>(
+        &mut self,
+        layer_id: LayerId,
+        add_contents: impl FnOnce(&mut Self) -> R,
+    ) -> InnerResponse<R> {
+        self.scope(|ui| {
+            ui.painter.set_layer_id(layer_id);
+            add_contents(ui)
+        })
+    }
+
+    /// A [`CollapsingHeader`] that starts out collapsed.
+    pub fn collapsing<R>(
+        &mut self,
+        heading: impl Into<WidgetText>,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> CollapsingResponse<R> {
+        CollapsingHeader::new(heading).show(self, add_contents)
+    }
+
+    /// Create a child ui which is indented to the right.
+    ///
+    /// The `id_source` here be anything at all.
+    // TODO(emilk): remove `id_source` argument?
+    #[inline]
+    pub fn indent<R>(
+        &mut self,
+        id_source: impl Hash,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.indent_dyn(id_source, Box::new(add_contents))
+    }
+
+    fn indent_dyn<'c, R>(
+        &mut self,
+        id_source: impl Hash,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        assert!(
+            self.layout().is_vertical(),
+            "You can only indent vertical layouts, found {:?}",
+            self.layout()
+        );
+
+        let indent = self.spacing().indent;
+        let mut child_rect = self.placer.available_rect_before_wrap();
+        child_rect.min.x += indent;
+
+        let mut child_ui = Self {
+            id: self.id.with(id_source),
+            ..self.child_ui(child_rect, *self.layout())
+        };
+        let ret = add_contents(&mut child_ui);
+
+        let left_vline = self.visuals().indent_has_left_vline;
+        let end_with_horizontal_line = self.spacing().indent_ends_with_horizontal_line;
+
+        if left_vline || end_with_horizontal_line {
+            if end_with_horizontal_line {
+                child_ui.add_space(4.0);
+            }
+
+            let stroke = self.visuals().widgets.noninteractive.bg_stroke;
+            let left_top = child_rect.min - 0.5 * indent * Vec2::X;
+            let left_top = self.painter().round_pos_to_pixels(left_top);
+            let left_bottom = pos2(left_top.x, child_ui.min_rect().bottom() - 2.0);
+            let left_bottom = self.painter().round_pos_to_pixels(left_bottom);
+
+            if left_vline {
+                // draw a faint line on the left to mark the indented section
+                self.painter.line_segment([left_top, left_bottom], stroke);
+            }
+
+            if end_with_horizontal_line {
+                let fudge = 2.0; // looks nicer with button rounding in collapsing headers
+                let right_bottom = pos2(child_ui.min_rect().right() - fudge, left_bottom.y);
+                self.painter
+                    .line_segment([left_bottom, right_bottom], stroke);
+            }
+        }
+
+        let response = self.allocate_rect(child_ui.min_rect(), Sense::hover());
+        InnerResponse::new(ret, response)
+    }
+
+    /// Start a ui with horizontal layout.
+    /// After you have called this, the function registers the contents as any other widget.
+    ///
+    /// Elements will be centered on the Y axis, i.e.
+    /// adjusted up and down to lie in the center of the horizontal layout.
+    /// The initial height is `style.spacing.interact_size.y`.
+    /// Centering is almost always what you want if you are
+    /// planning to to mix widgets or use different types of text.
+    ///
+    /// If you don't want the contents to be centered, use [`Self::horizontal_top`] instead.
+    ///
+    /// The returned [`Response`] will only have checked for mouse hover
+    /// but can be used for tooltips (`on_hover_text`).
+    /// It also contains the [`Rect`] used by the horizontal layout.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.horizontal(|ui| {
+    ///     ui.label("Same");
+    ///     ui.label("row");
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// See also [`Self::with_layout`] for more options.
+    #[inline]
+    pub fn horizontal<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        self.horizontal_with_main_wrap_dyn(false, Box::new(add_contents))
+    }
+
+    /// Like [`Self::horizontal`], but allocates the full vertical height and then centers elements vertically.
+    pub fn horizontal_centered<R>(
+        &mut self,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        let initial_size = self.available_size_before_wrap();
+        let layout = if self.placer.prefer_right_to_left() {
+            Layout::right_to_left(Align::Center)
+        } else {
+            Layout::left_to_right(Align::Center)
+        }
+        .with_cross_align(Align::Center);
+        self.allocate_ui_with_layout_dyn(initial_size, layout, Box::new(add_contents))
+    }
+
+    /// Like [`Self::horizontal`], but aligns content with top.
+    pub fn horizontal_top<R>(
+        &mut self,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        let initial_size = self.available_size_before_wrap();
+        let layout = if self.placer.prefer_right_to_left() {
+            Layout::right_to_left(Align::Center)
+        } else {
+            Layout::left_to_right(Align::Center)
+        }
+        .with_cross_align(Align::Min);
+        self.allocate_ui_with_layout_dyn(initial_size, layout, Box::new(add_contents))
+    }
+
+    /// Start a ui with horizontal layout that wraps to a new row
+    /// when it reaches the right edge of the `max_size`.
+    /// After you have called this, the function registers the contents as any other widget.
+    ///
+    /// Elements will be centered on the Y axis, i.e.
+    /// adjusted up and down to lie in the center of the horizontal layout.
+    /// The initial height is `style.spacing.interact_size.y`.
+    /// Centering is almost always what you want if you are
+    /// planning to to mix widgets or use different types of text.
+    ///
+    /// The returned [`Response`] will only have checked for mouse hover
+    /// but can be used for tooltips (`on_hover_text`).
+    /// It also contains the [`Rect`] used by the horizontal layout.
+    ///
+    /// See also [`Self::with_layout`] for more options.
+    pub fn horizontal_wrapped<R>(
+        &mut self,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.horizontal_with_main_wrap_dyn(true, Box::new(add_contents))
+    }
+
+    fn horizontal_with_main_wrap_dyn<'c, R>(
+        &mut self,
+        main_wrap: bool,
+        add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let initial_size = vec2(
+            self.available_size_before_wrap().x,
+            self.spacing().interact_size.y, // Assume there will be something interactive on the horizontal layout
+        );
+
+        let layout = if self.placer.prefer_right_to_left() {
+            Layout::right_to_left(Align::Center)
+        } else {
+            Layout::left_to_right(Align::Center)
+        }
+        .with_main_wrap(main_wrap);
+
+        self.allocate_ui_with_layout_dyn(initial_size, layout, add_contents)
+    }
+
+    /// Start a ui with vertical layout.
+    /// Widgets will be left-justified.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.vertical(|ui| {
+    ///     ui.label("over");
+    ///     ui.label("under");
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// See also [`Self::with_layout`] for more options.
+    #[inline]
+    pub fn vertical<R>(&mut self, add_contents: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        self.with_layout_dyn(Layout::top_down(Align::Min), Box::new(add_contents))
+    }
+
+    /// Start a ui with vertical layout.
+    /// Widgets will be horizontally centered.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.vertical_centered(|ui| {
+    ///     ui.label("over");
+    ///     ui.label("under");
+    /// });
+    /// # });
+    /// ```
+    #[inline]
+    pub fn vertical_centered<R>(
+        &mut self,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.with_layout_dyn(Layout::top_down(Align::Center), Box::new(add_contents))
+    }
+
+    /// Start a ui with vertical layout.
+    /// Widgets will be horizontally centered and justified (fill full width).
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.vertical_centered_justified(|ui| {
+    ///     ui.label("over");
+    ///     ui.label("under");
+    /// });
+    /// # });
+    /// ```
+    pub fn vertical_centered_justified<R>(
+        &mut self,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<R> {
+        self.with_layout_dyn(
+            Layout::top_down(Align::Center).with_cross_justify(true),
+            Box::new(add_contents),
+        )
+    }
+
+    /// The new layout will take up all available space.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+    ///     ui.label("world!");
+    ///     ui.label("Hello");
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// If you don't want to use up all available space, use [`Self::allocate_ui_with_layout`].
+    ///
+    /// See also the helpers [`Self::horizontal`], [`Self::vertical`], etc.
+    #[inline]
+    pub fn with_layout<R>(
+        &mut self,
+        layout: Layout,
+        add_contents: impl FnOnce(&mut Self) -> R,
+    ) -> InnerResponse<R> {
+        self.with_layout_dyn(layout, Box::new(add_contents))
+    }
+
+    fn with_layout_dyn<'c, R>(
+        &mut self,
+        layout: Layout,
+        add_contents: Box<dyn FnOnce(&mut Self) -> R + 'c>,
+    ) -> InnerResponse<R> {
+        let mut child_ui = self.child_ui(self.available_rect_before_wrap(), layout);
+        let inner = add_contents(&mut child_ui);
+        let rect = child_ui.min_rect();
+        let item_spacing = self.spacing().item_spacing;
+        self.placer.advance_after_rects(rect, rect, item_spacing);
+
+        if self.style().debug.debug_on_hover && self.rect_contains_pointer(rect) {
+            let painter = self.ctx().debug_painter();
+            painter.rect_stroke(rect, 4.0, (1.0, Color32::LIGHT_BLUE));
+            self.placer.debug_paint_cursor(&painter, "next");
+        }
+
+        InnerResponse::new(inner, self.interact(rect, child_ui.id, Sense::hover()))
+    }
+
+    #[deprecated = "Use ui.vertical_centered or ui.centered_and_justified"]
+    pub fn centered<R>(&mut self, add_contents: impl FnOnce(&mut Self) -> R) -> InnerResponse<R> {
+        self.vertical_centered(add_contents)
+    }
+
+    /// This will make the next added widget centered and justified in the available space.
+    ///
+    /// Only one widget may be added to the inner `Ui`!
+    pub fn centered_and_justified<R>(
+        &mut self,
+        add_contents: impl FnOnce(&mut Self) -> R,
+    ) -> InnerResponse<R> {
+        self.with_layout_dyn(
+            Layout::centered_and_justified(Direction::TopDown),
+            Box::new(add_contents),
+        )
+    }
+
+    pub(crate) fn set_grid(&mut self, grid: grid::GridLayout) {
+        self.placer.set_grid(grid);
+    }
+
+    pub(crate) fn save_grid(&mut self) {
+        self.placer.save_grid();
+    }
+
+    pub(crate) fn is_grid(&self) -> bool {
+        self.placer.is_grid()
+    }
+
+    /// Move to the next row in a grid layout or wrapping layout.
+    /// Otherwise does nothing.
+    pub fn end_row(&mut self) {
+        self.placer
+            .end_row(self.spacing().item_spacing, &self.painter().clone());
+    }
+
+    /// Set row height in horizontal wrapping layout.
+    pub fn set_row_height(&mut self, height: f32) {
+        self.placer.set_row_height(height);
+    }
+
+    /// Temporarily split a [`Ui`] into several columns.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.columns(2, |columns| {
+    ///     columns[0].label("First column");
+    ///     columns[1].label("Second column");
+    /// });
+    /// # });
+    /// ```
+    #[inline]
+    pub fn columns<R>(
+        &mut self,
+        num_columns: usize,
+        add_contents: impl FnOnce(&mut [Self]) -> R,
+    ) -> R {
+        self.columns_dyn(num_columns, Box::new(add_contents))
+    }
+
+    fn columns_dyn<'c, R>(
+        &mut self,
+        num_columns: usize,
+        add_contents: Box<dyn FnOnce(&mut [Self]) -> R + 'c>,
+    ) -> R {
+        // TODO(emilk): ensure there is space
+        let spacing = self.spacing().item_spacing.x;
+        let total_spacing = spacing * (num_columns as f32 - 1.0);
+        let column_width = (self.available_width() - total_spacing) / (num_columns as f32);
+        let top_left = self.cursor().min;
+
+        let mut columns: Vec<Self> = (0..num_columns)
+            .map(|col_idx| {
+                let pos = top_left + vec2((col_idx as f32) * (column_width + spacing), 0.0);
+                let child_rect = Rect::from_min_max(
+                    pos,
+                    pos2(pos.x + column_width, self.max_rect().right_bottom().y),
+                );
+                let mut column_ui =
+                    self.child_ui(child_rect, Layout::top_down_justified(Align::LEFT));
+                column_ui.set_width(column_width);
+                column_ui
+            })
+            .collect();
+
+        let result = add_contents(&mut columns[..]);
+
+        let mut max_column_width = column_width;
+        let mut max_height = 0.0;
+        for column in &columns {
+            max_column_width = max_column_width.max(column.min_rect().width());
+            max_height = column.min_size().y.max(max_height);
+        }
+
+        // Make sure we fit everything next frame:
+        let total_required_width = total_spacing + max_column_width * (num_columns as f32);
+
+        let size = vec2(self.available_width().max(total_required_width), max_height);
+        self.advance_cursor_after_rect(Rect::from_min_size(top_left, size));
+        result
+    }
+
+    /// Close the menu we are in (including submenus), if any.
+    ///
+    /// See also: [`Self::menu_button`] and [`Response::context_menu`].
+    pub fn close_menu(&mut self) {
+        if let Some(menu_state) = &mut self.menu_state {
+            menu_state.write().close();
+        }
+        self.menu_state = None;
+    }
+
+    pub(crate) fn menu_state(&self) -> Option<Arc<RwLock<MenuState>>> {
+        self.menu_state.clone()
+    }
+
+    pub(crate) fn set_menu_state(&mut self, menu_state: Option<Arc<RwLock<MenuState>>>) {
+        self.menu_state = menu_state;
+    }
+
+    #[inline]
+    /// Create a menu button that when clicked will show the given menu.
+    ///
+    /// If called from within a menu this will instead create a button for a sub-menu.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.menu_button("My menu", |ui| {
+    ///     ui.menu_button("My sub-menu", |ui| {
+    ///         if ui.button("Close the menu").clicked() {
+    ///             ui.close_menu();
+    ///         }
+    ///     });
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// See also: [`Self::close_menu`] and [`Response::context_menu`].
+    pub fn menu_button<R>(
+        &mut self,
+        title: impl Into<WidgetText>,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<Option<R>> {
+        if let Some(menu_state) = self.menu_state.clone() {
+            menu::submenu_button(self, menu_state, title, add_contents)
+        } else {
+            menu::menu_button(self, title, add_contents)
+        }
+    }
+
+    /// Create a menu button with an image that when clicked will show the given menu.
+    ///
+    /// If called from within a menu this will instead create a button for a sub-menu.
+    ///
+    /// ```ignore
+    /// use egui_extras;
+    ///
+    /// let img = egui_extras::RetainedImage::from_svg_bytes_with_size(
+    ///     "rss",
+    ///     include_bytes!("rss.svg"),
+    ///     egui_extras::image::FitTo::Size(24, 24),
+    /// );
+    ///
+    /// ui.menu_image_button(img.texture_id(ctx), img.size_vec2(), |ui| {
+    ///     ui.menu_button("My sub-menu", |ui| {
+    ///         if ui.button("Close the menu").clicked() {
+    ///             ui.close_menu();
+    ///         }
+    ///     });
+    /// });
+    /// ```
+    ///
+    /// See also: [`Self::close_menu`] and [`Response::context_menu`].
+    #[inline]
+    pub fn menu_image_button<R>(
+        &mut self,
+        texture_id: TextureId,
+        image_size: impl Into<Vec2>,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> InnerResponse<Option<R>> {
+        if let Some(menu_state) = self.menu_state.clone() {
+            menu::submenu_button(self, menu_state, String::new(), add_contents)
+        } else {
+            menu::menu_image_button(self, texture_id, image_size, add_contents)
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// # Debug stuff
+impl Ui {
+    /// Shows where the next widget is going to be placed
+    pub fn debug_paint_cursor(&self) {
+        self.placer.debug_paint_cursor(&self.painter, "next");
+    }
+
+    /// Shows the given text where the next widget is to be placed
+    /// if when [`Context::set_debug_on_hover`] has been turned on and the mouse is hovering the Ui.
+    pub fn trace_location(&self, text: impl ToString) {
+        let rect = self.max_rect();
+        if self.style().debug.debug_on_hover && self.rect_contains_pointer(rect) {
+            self.placer
+                .debug_paint_cursor(&self.ctx().debug_painter(), text);
+        }
+    }
+}
diff --git a/egui/crates/egui/src/util/cache.rs b/egui/crates/egui/src/util/cache.rs
new file mode 100644
index 0000000..b1c6556
--- /dev/null
+++ b/egui/crates/egui/src/util/cache.rs
@@ -0,0 +1,164 @@
+//! Computing the same thing each frame can be expensive,
+//! so often you want to save the result from the previous frame and reuse it.
+//!
+//! Enter [`FrameCache`]: it caches the results of a computation for one frame.
+//! If it is still used next frame, it is not recomputed.
+//! If it is not used next frame, it is evicted from the cache to save memory.
+
+/// Something that does an expensive computation that we want to cache
+/// to save us from recomputing it each frame.
+pub trait ComputerMut<Key, Value>: 'static + Send + Sync {
+    fn compute(&mut self, key: Key) -> Value;
+}
+
+/// Caches the results of a computation for one frame.
+/// If it is still used next frame, it is not recomputed.
+/// If it is not used next frame, it is evicted from the cache to save memory.
+pub struct FrameCache<Value, Computer> {
+    generation: u32,
+    computer: Computer,
+    cache: nohash_hasher::IntMap<u64, (u32, Value)>,
+}
+
+impl<Value, Computer> Default for FrameCache<Value, Computer>
+where
+    Computer: Default,
+{
+    fn default() -> Self {
+        Self::new(Computer::default())
+    }
+}
+
+impl<Value, Computer> FrameCache<Value, Computer> {
+    pub fn new(computer: Computer) -> Self {
+        Self {
+            generation: 0,
+            computer,
+            cache: Default::default(),
+        }
+    }
+
+    /// Must be called once per frame to clear the cache.
+    pub fn evice_cache(&mut self) {
+        let current_generation = self.generation;
+        self.cache.retain(|_key, cached| {
+            cached.0 == current_generation // only keep those that were used this frame
+        });
+        self.generation = self.generation.wrapping_add(1);
+    }
+}
+
+impl<Value, Computer> FrameCache<Value, Computer> {
+    /// Get from cache (if the same key was used last frame)
+    /// or recompute and store in the cache.
+    pub fn get<Key>(&mut self, key: Key) -> Value
+    where
+        Key: Copy + std::hash::Hash,
+        Value: Clone,
+        Computer: ComputerMut<Key, Value>,
+    {
+        let hash = crate::util::hash(key);
+
+        match self.cache.entry(hash) {
+            std::collections::hash_map::Entry::Occupied(entry) => {
+                let cached = entry.into_mut();
+                cached.0 = self.generation;
+                cached.1.clone()
+            }
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                let value = self.computer.compute(key);
+                entry.insert((self.generation, value.clone()));
+                value
+            }
+        }
+    }
+}
+
+#[allow(clippy::len_without_is_empty)]
+pub trait CacheTrait: 'static + Send + Sync {
+    /// Call once per frame to evict cache.
+    fn update(&mut self);
+
+    /// Number of values currently in the cache.
+    fn len(&self) -> usize;
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
+}
+
+impl<Value: 'static + Send + Sync, Computer: 'static + Send + Sync> CacheTrait
+    for FrameCache<Value, Computer>
+{
+    fn update(&mut self) {
+        self.evice_cache();
+    }
+
+    fn len(&self) -> usize {
+        self.cache.len()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+}
+
+/// ```
+/// use egui::util::cache::{CacheStorage, ComputerMut, FrameCache};
+///
+/// #[derive(Default)]
+/// struct CharCounter {}
+/// impl ComputerMut<&str, usize> for CharCounter {
+///     fn compute(&mut self, s: &str) -> usize {
+///         s.chars().count()
+///     }
+/// }
+/// type CharCountCache<'a> = FrameCache<usize, CharCounter>;
+///
+/// # let mut cache_storage = CacheStorage::default();
+/// let mut cache = cache_storage.cache::<CharCountCache<'_>>();
+/// assert_eq!(cache.get("hello"), 5);
+/// ```
+#[derive(Default)]
+pub struct CacheStorage {
+    caches: ahash::HashMap<std::any::TypeId, Box<dyn CacheTrait>>,
+}
+
+impl CacheStorage {
+    pub fn cache<FrameCache: CacheTrait + Default>(&mut self) -> &mut FrameCache {
+        self.caches
+            .entry(std::any::TypeId::of::<FrameCache>())
+            .or_insert_with(|| Box::new(FrameCache::default()))
+            .as_any_mut()
+            .downcast_mut::<FrameCache>()
+            .unwrap()
+    }
+
+    /// Total number of cached values
+    fn num_values(&self) -> usize {
+        self.caches.values().map(|cache| cache.len()).sum()
+    }
+
+    /// Call once per frame to evict cache.
+    pub fn update(&mut self) {
+        for cache in self.caches.values_mut() {
+            cache.update();
+        }
+    }
+}
+
+impl Clone for CacheStorage {
+    fn clone(&self) -> Self {
+        // We return an empty cache that can be filled in again.
+        Self::default()
+    }
+}
+
+impl std::fmt::Debug for CacheStorage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "FrameCacheStorage[{} caches with {} elements]",
+            self.caches.len(),
+            self.num_values()
+        )
+    }
+}
diff --git a/egui/crates/egui/src/util/fixed_cache.rs b/egui/crates/egui/src/util/fixed_cache.rs
new file mode 100644
index 0000000..c0f8662
--- /dev/null
+++ b/egui/crates/egui/src/util/fixed_cache.rs
@@ -0,0 +1,41 @@
+use epaint::util::hash;
+
+const FIXED_CACHE_SIZE: usize = 1024; // must be small for web/WASM build (for unknown reason)
+
+/// Very stupid/simple key-value cache. TODO(emilk): improve
+#[derive(Clone)]
+pub(crate) struct FixedCache<K, V>([Option<(K, V)>; FIXED_CACHE_SIZE]);
+
+impl<K, V> Default for FixedCache<K, V>
+where
+    K: Copy,
+    V: Copy,
+{
+    fn default() -> Self {
+        Self([None; FIXED_CACHE_SIZE])
+    }
+}
+
+impl<K, V> std::fmt::Debug for FixedCache<K, V> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Cache")
+    }
+}
+
+impl<K, V> FixedCache<K, V>
+where
+    K: std::hash::Hash + PartialEq,
+{
+    pub fn get(&self, key: &K) -> Option<&V> {
+        let bucket = (hash(key) % (FIXED_CACHE_SIZE as u64)) as usize;
+        match &self.0[bucket] {
+            Some((k, v)) if k == key => Some(v),
+            _ => None,
+        }
+    }
+
+    pub fn set(&mut self, key: K, value: V) {
+        let bucket = (hash(&key) % (FIXED_CACHE_SIZE as u64)) as usize;
+        self.0[bucket] = Some((key, value));
+    }
+}
diff --git a/egui/crates/egui/src/util/id_type_map.rs b/egui/crates/egui/src/util/id_type_map.rs
new file mode 100644
index 0000000..77e70a2
--- /dev/null
+++ b/egui/crates/egui/src/util/id_type_map.rs
@@ -0,0 +1,729 @@
+// TODO(emilk): it is possible we can simplify `Element` further by
+// assuming everything is possibly serializable, and by supplying serialize/deserialize functions for them.
+// For non-serializable types, these simply return `None`.
+// This will also allow users to pick their own serialization format per type.
+
+use std::any::Any;
+use std::sync::Arc;
+
+// -----------------------------------------------------------------------------------------------
+
+/// Like [`std::any::TypeId`], but can be serialized and deserialized.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+pub struct TypeId(u64);
+
+impl TypeId {
+    #[inline]
+    pub fn of<T: Any + 'static>() -> Self {
+        std::any::TypeId::of::<T>().into()
+    }
+
+    #[inline(always)]
+    pub(crate) fn value(&self) -> u64 {
+        self.0
+    }
+}
+
+impl From<std::any::TypeId> for TypeId {
+    #[inline]
+    fn from(id: std::any::TypeId) -> Self {
+        Self(epaint::util::hash(id))
+    }
+}
+
+// -----------------------------------------------------------------------------------------------
+
+#[cfg(feature = "persistence")]
+pub trait SerializableAny:
+    'static + Any + Clone + serde::Serialize + for<'a> serde::Deserialize<'a> + Send + Sync
+{
+}
+
+#[cfg(feature = "persistence")]
+impl<T> SerializableAny for T where
+    T: 'static + Any + Clone + serde::Serialize + for<'a> serde::Deserialize<'a> + Send + Sync
+{
+}
+
+#[cfg(not(feature = "persistence"))]
+pub trait SerializableAny: 'static + Any + Clone + for<'a> Send + Sync {}
+
+#[cfg(not(feature = "persistence"))]
+impl<T> SerializableAny for T where T: 'static + Any + Clone + for<'a> Send + Sync {}
+
+// -----------------------------------------------------------------------------------------------
+
+#[cfg(feature = "persistence")]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+struct SerializedElement {
+    type_id: TypeId,
+    ron: Arc<str>,
+}
+
+#[cfg(feature = "persistence")]
+type Serializer = fn(&Box<dyn Any + 'static + Send + Sync>) -> Option<String>;
+
+enum Element {
+    /// A value, maybe serializable.
+    Value {
+        /// The actual value.
+        value: Box<dyn Any + 'static + Send + Sync>,
+
+        /// How to clone the value.
+        clone_fn: fn(&Box<dyn Any + 'static + Send + Sync>) -> Box<dyn Any + 'static + Send + Sync>,
+
+        /// How to serialize the value.
+        /// None if non-serializable type.
+        #[cfg(feature = "persistence")]
+        serialize_fn: Option<Serializer>,
+    },
+
+    /// A serialized value
+    Serialized {
+        /// The type of value we are storing.
+        type_id: TypeId,
+
+        /// The ron data we can deserialize.
+        ron: Arc<str>,
+    },
+}
+
+impl Clone for Element {
+    fn clone(&self) -> Self {
+        match &self {
+            Self::Value {
+                value,
+                clone_fn,
+                #[cfg(feature = "persistence")]
+                serialize_fn,
+            } => Self::Value {
+                value: clone_fn(value),
+                clone_fn: *clone_fn,
+                #[cfg(feature = "persistence")]
+                serialize_fn: *serialize_fn,
+            },
+
+            Self::Serialized { type_id, ron } => Self::Serialized {
+                type_id: *type_id,
+                ron: ron.clone(),
+            },
+        }
+    }
+}
+
+impl std::fmt::Debug for Element {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Self::Value { value, .. } => f
+                .debug_struct("MaybeSerializable::Value")
+                .field("type_id", &value.type_id())
+                .finish_non_exhaustive(),
+            Self::Serialized { type_id, ron } => f
+                .debug_struct("MaybeSerializable::Serialized")
+                .field("type_id", &type_id)
+                .field("ron", &ron)
+                .finish(),
+        }
+    }
+}
+
+impl Element {
+    /// Create a value that won't be persisted.
+    #[inline]
+    pub(crate) fn new_temp<T: 'static + Any + Clone + Send + Sync>(t: T) -> Self {
+        Self::Value {
+            value: Box::new(t),
+            clone_fn: |x| {
+                let x = x.downcast_ref::<T>().unwrap(); // This unwrap will never panic, because we always construct this type using this `new` function and because we return &mut reference only with this type `T`, so type cannot change.
+                Box::new(x.clone())
+            },
+            #[cfg(feature = "persistence")]
+            serialize_fn: None,
+        }
+    }
+
+    /// Create a value that will be persisted.
+    #[inline]
+    pub(crate) fn new_persisted<T: SerializableAny>(t: T) -> Self {
+        Self::Value {
+            value: Box::new(t),
+            clone_fn: |x| {
+                let x = x.downcast_ref::<T>().unwrap(); // This unwrap will never panic, because we always construct this type using this `new` function and because we return &mut reference only with this type `T`, so type cannot change.
+                Box::new(x.clone())
+            },
+            #[cfg(feature = "persistence")]
+            serialize_fn: Some(|x| {
+                let x = x.downcast_ref::<T>().unwrap(); // This will never panic too, for same reason.
+                ron::to_string(x).ok()
+            }),
+        }
+    }
+
+    /// The type of the stored value.
+    #[inline]
+    pub(crate) fn type_id(&self) -> TypeId {
+        match self {
+            Self::Value { value, .. } => (**value).type_id().into(),
+            Self::Serialized { type_id, .. } => *type_id,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_temp<T: 'static>(&self) -> Option<&T> {
+        match self {
+            Self::Value { value, .. } => value.downcast_ref(),
+            Self::Serialized { .. } => None,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_mut_temp<T: 'static>(&mut self) -> Option<&mut T> {
+        match self {
+            Self::Value { value, .. } => value.downcast_mut(),
+            Self::Serialized { .. } => None,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_temp_mut_or_insert_with<T: 'static + Any + Clone + Send + Sync>(
+        &mut self,
+        insert_with: impl FnOnce() -> T,
+    ) -> &mut T {
+        match self {
+            Self::Value { value, .. } => {
+                if !value.is::<T>() {
+                    *self = Self::new_temp(insert_with());
+                }
+            }
+            Self::Serialized { .. } => {
+                *self = Self::new_temp(insert_with());
+            }
+        }
+
+        match self {
+            Self::Value { value, .. } => value.downcast_mut().unwrap(), // This unwrap will never panic because we already converted object to required type
+            Self::Serialized { .. } => unreachable!(),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_persisted_mut_or_insert_with<T: SerializableAny>(
+        &mut self,
+        insert_with: impl FnOnce() -> T,
+    ) -> &mut T {
+        match self {
+            Self::Value { value, .. } => {
+                if !value.is::<T>() {
+                    *self = Self::new_persisted(insert_with());
+                }
+            }
+
+            #[cfg(feature = "persistence")]
+            Self::Serialized { ron, .. } => {
+                *self = Self::new_persisted(from_ron_str::<T>(ron).unwrap_or_else(insert_with));
+            }
+
+            #[cfg(not(feature = "persistence"))]
+            Self::Serialized { .. } => {
+                *self = Self::new_persisted(insert_with());
+            }
+        }
+
+        match self {
+            Self::Value { value, .. } => value.downcast_mut().unwrap(), // This unwrap will never panic because we already converted object to required type
+            Self::Serialized { .. } => unreachable!(),
+        }
+    }
+
+    pub(crate) fn get_mut_persisted<T: SerializableAny>(&mut self) -> Option<&mut T> {
+        match self {
+            Self::Value { value, .. } => value.downcast_mut(),
+
+            #[cfg(feature = "persistence")]
+            Self::Serialized { ron, .. } => {
+                *self = Self::new_persisted(from_ron_str::<T>(ron)?);
+
+                match self {
+                    Self::Value { value, .. } => value.downcast_mut(),
+                    Self::Serialized { .. } => unreachable!(),
+                }
+            }
+
+            #[cfg(not(feature = "persistence"))]
+            Self::Serialized { .. } => None,
+        }
+    }
+
+    #[cfg(feature = "persistence")]
+    fn to_serialize(&self) -> Option<SerializedElement> {
+        match self {
+            Self::Value {
+                value,
+                serialize_fn,
+                ..
+            } => {
+                if let Some(serialize_fn) = serialize_fn {
+                    let ron = serialize_fn(value)?;
+                    Some(SerializedElement {
+                        type_id: (**value).type_id().into(),
+                        ron: ron.into(),
+                    })
+                } else {
+                    None
+                }
+            }
+            Self::Serialized { type_id, ron } => Some(SerializedElement {
+                type_id: *type_id,
+                ron: ron.clone(),
+            }),
+        }
+    }
+}
+
+#[cfg(feature = "persistence")]
+fn from_ron_str<T: serde::de::DeserializeOwned>(ron: &str) -> Option<T> {
+    match ron::from_str::<T>(ron) {
+        Ok(value) => Some(value),
+        Err(_err) => {
+            #[cfg(feature = "tracing")]
+            tracing::warn!(
+                "egui: Failed to deserialize {} from memory: {}, ron error: {:?}",
+                std::any::type_name::<T>(),
+                _err,
+                ron
+            );
+            None
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------------------------
+
+use crate::Id;
+
+// TODO(emilk): make IdTypeMap generic over the key (`Id`), and make a library of IdTypeMap.
+/// Stores values identified by an [`Id`] AND a the [`std::any::TypeId`] of the value.
+///
+/// In other words, it maps `(Id, TypeId)` to any value you want.
+///
+/// Values are cloned when read, so keep them small and light.
+/// If you want to store something bigger, wrap them in `Arc<Mutex<…>>`.
+/// Also try `Arc<ArcSwap<…>>`.
+///
+/// Values can either be "persisted" (serializable) or "temporary" (cleared when egui is shut down).
+///
+/// You can store state using the key [`Id::null`]. The state will then only be identified by its type.
+///
+/// ```
+/// # use egui::{Id, util::IdTypeMap};
+/// let a = Id::new("a");
+/// let b = Id::new("b");
+/// let mut map: IdTypeMap = Default::default();
+///
+/// // `a` associated with an f64 and an i32
+/// map.insert_persisted(a, 3.14);
+/// map.insert_temp(a, 42);
+///
+/// // `b` associated with an f64 and a `&'static str`
+/// map.insert_persisted(b, 13.37);
+/// map.insert_temp(b, "Hello World".to_owned());
+///
+/// // we can retrieve all four values:
+/// assert_eq!(map.get_temp::<f64>(a), Some(3.14));
+/// assert_eq!(map.get_temp::<i32>(a), Some(42));
+/// assert_eq!(map.get_temp::<f64>(b), Some(13.37));
+/// assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_owned()));
+///
+/// // we can retrieve them like so also:
+/// assert_eq!(map.get_persisted::<f64>(a), Some(3.14));
+/// assert_eq!(map.get_persisted::<i32>(a), Some(42));
+/// assert_eq!(map.get_persisted::<f64>(b), Some(13.37));
+/// assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_owned()));
+/// ```
+#[derive(Clone, Debug, Default)]
+// We store use `id XOR typeid` as a key, so we don't need to hash again!
+pub struct IdTypeMap(nohash_hasher::IntMap<u64, Element>);
+
+impl IdTypeMap {
+    /// Insert a value that will not be persisted.
+    #[inline]
+    pub fn insert_temp<T: 'static + Any + Clone + Send + Sync>(&mut self, id: Id, value: T) {
+        let hash = hash(TypeId::of::<T>(), id);
+        self.0.insert(hash, Element::new_temp(value));
+    }
+
+    /// Insert a value that will be persisted next time you start the app.
+    #[inline]
+    pub fn insert_persisted<T: SerializableAny>(&mut self, id: Id, value: T) {
+        let hash = hash(TypeId::of::<T>(), id);
+        self.0.insert(hash, Element::new_persisted(value));
+    }
+
+    /// Read a value without trying to deserialize a persisted value.
+    ///
+    /// The call clones the value (if found), so make sure it is cheap to clone!
+    #[inline]
+    pub fn get_temp<T: 'static + Clone>(&self, id: Id) -> Option<T> {
+        let hash = hash(TypeId::of::<T>(), id);
+        self.0.get(&hash).and_then(|x| x.get_temp()).cloned()
+    }
+
+    /// Read a value, optionally deserializing it if available.
+    ///
+    /// NOTE: A mutable `self` is needed because internally this deserializes on first call
+    /// and caches the result (caching requires self-mutability).
+    ///
+    /// The call clones the value (if found), so make sure it is cheap to clone!
+    #[inline]
+    pub fn get_persisted<T: SerializableAny>(&mut self, id: Id) -> Option<T> {
+        let hash = hash(TypeId::of::<T>(), id);
+        self.0
+            .get_mut(&hash)
+            .and_then(|x| x.get_mut_persisted())
+            .cloned()
+    }
+
+    #[inline]
+    pub fn get_temp_mut_or<T: 'static + Any + Clone + Send + Sync>(
+        &mut self,
+        id: Id,
+        or_insert: T,
+    ) -> &mut T {
+        self.get_temp_mut_or_insert_with(id, || or_insert)
+    }
+
+    #[inline]
+    pub fn get_persisted_mut_or<T: SerializableAny>(&mut self, id: Id, or_insert: T) -> &mut T {
+        self.get_persisted_mut_or_insert_with(id, || or_insert)
+    }
+
+    #[inline]
+    pub fn get_temp_mut_or_default<T: 'static + Any + Clone + Send + Sync + Default>(
+        &mut self,
+        id: Id,
+    ) -> &mut T {
+        self.get_temp_mut_or_insert_with(id, Default::default)
+    }
+
+    #[inline]
+    pub fn get_persisted_mut_or_default<T: SerializableAny + Default>(&mut self, id: Id) -> &mut T {
+        self.get_persisted_mut_or_insert_with(id, Default::default)
+    }
+
+    pub fn get_temp_mut_or_insert_with<T: 'static + Any + Clone + Send + Sync>(
+        &mut self,
+        id: Id,
+        insert_with: impl FnOnce() -> T,
+    ) -> &mut T {
+        let hash = hash(TypeId::of::<T>(), id);
+        use std::collections::hash_map::Entry;
+        match self.0.entry(hash) {
+            Entry::Vacant(vacant) => vacant
+                .insert(Element::new_temp(insert_with()))
+                .get_mut_temp()
+                .unwrap(), // this unwrap will never panic, because we insert correct type right now
+            Entry::Occupied(occupied) => {
+                occupied.into_mut().get_temp_mut_or_insert_with(insert_with)
+            }
+        }
+    }
+
+    pub fn get_persisted_mut_or_insert_with<T: SerializableAny>(
+        &mut self,
+        id: Id,
+        insert_with: impl FnOnce() -> T,
+    ) -> &mut T {
+        let hash = hash(TypeId::of::<T>(), id);
+        use std::collections::hash_map::Entry;
+        match self.0.entry(hash) {
+            Entry::Vacant(vacant) => vacant
+                .insert(Element::new_persisted(insert_with()))
+                .get_mut_persisted()
+                .unwrap(), // this unwrap will never panic, because we insert correct type right now
+            Entry::Occupied(occupied) => occupied
+                .into_mut()
+                .get_persisted_mut_or_insert_with(insert_with),
+        }
+    }
+
+    /// Remove the state of this type an id.
+    #[inline]
+    pub fn remove<T: 'static>(&mut self, id: Id) {
+        let hash = hash(TypeId::of::<T>(), id);
+        self.0.remove(&hash);
+    }
+
+    /// Note all state of the given type.
+    pub fn remove_by_type<T: 'static>(&mut self) {
+        let key = TypeId::of::<T>();
+        self.0.retain(|_, e| {
+            let e: &Element = e;
+            e.type_id() != key
+        });
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Count how many values are stored but not yet deserialized.
+    #[inline]
+    pub fn count_serialized(&self) -> usize {
+        self.0
+            .values()
+            .filter(|e| matches!(e, Element::Serialized { .. }))
+            .count()
+    }
+
+    /// Count the number of values are stored with the given type.
+    pub fn count<T: 'static>(&self) -> usize {
+        let key = TypeId::of::<T>();
+        self.0
+            .iter()
+            .filter(|(_, e)| {
+                let e: &Element = e;
+                e.type_id() == key
+            })
+            .count()
+    }
+}
+
+#[inline(always)]
+fn hash(type_id: TypeId, id: Id) -> u64 {
+    type_id.value() ^ id.value()
+}
+
+// ----------------------------------------------------------------------------
+
+/// How [`IdTypeMap`] is persisted.
+#[cfg(feature = "persistence")]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+struct PersistedMap(Vec<(u64, SerializedElement)>);
+
+#[cfg(feature = "persistence")]
+impl PersistedMap {
+    fn from_map(map: &IdTypeMap) -> Self {
+        // filter out the elements which cannot be serialized:
+        Self(
+            map.0
+                .iter()
+                .filter_map(|(&hash, element)| Some((hash, element.to_serialize()?)))
+                .collect(),
+        )
+    }
+
+    fn into_map(self) -> IdTypeMap {
+        IdTypeMap(
+            self.0
+                .into_iter()
+                .map(|(hash, SerializedElement { type_id, ron })| {
+                    (hash, Element::Serialized { type_id, ron })
+                })
+                .collect(),
+        )
+    }
+}
+
+#[cfg(feature = "persistence")]
+impl serde::Serialize for IdTypeMap {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        PersistedMap::from_map(self).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "persistence")]
+impl<'de> serde::Deserialize<'de> for IdTypeMap {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <PersistedMap>::deserialize(deserializer).map(PersistedMap::into_map)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[test]
+fn test_two_id_two_type() {
+    let a = Id::new("a");
+    let b = Id::new("b");
+
+    let mut map: IdTypeMap = Default::default();
+    map.insert_persisted(a, 13.37);
+    map.insert_temp(b, 42);
+    assert_eq!(map.get_persisted::<f64>(a), Some(13.37));
+    assert_eq!(map.get_persisted::<i32>(b), Some(42));
+    assert_eq!(map.get_temp::<f64>(a), Some(13.37));
+    assert_eq!(map.get_temp::<i32>(b), Some(42));
+}
+
+#[test]
+fn test_two_id_x_two_types() {
+    #![allow(clippy::approx_constant)]
+
+    let a = Id::new("a");
+    let b = Id::new("b");
+    let mut map: IdTypeMap = Default::default();
+
+    // `a` associated with an f64 and an i32
+    map.insert_persisted(a, 3.14);
+    map.insert_temp(a, 42);
+
+    // `b` associated with an f64 and a `&'static str`
+    map.insert_persisted(b, 13.37);
+    map.insert_temp(b, "Hello World".to_owned());
+
+    // we can retrieve all four values:
+    assert_eq!(map.get_temp::<f64>(a), Some(3.14));
+    assert_eq!(map.get_temp::<i32>(a), Some(42));
+    assert_eq!(map.get_temp::<f64>(b), Some(13.37));
+    assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_owned()));
+
+    // we can retrieve them like so also:
+    assert_eq!(map.get_persisted::<f64>(a), Some(3.14));
+    assert_eq!(map.get_persisted::<i32>(a), Some(42));
+    assert_eq!(map.get_persisted::<f64>(b), Some(13.37));
+    assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_owned()));
+}
+
+#[test]
+fn test_one_id_two_types() {
+    let id = Id::new("a");
+
+    let mut map: IdTypeMap = Default::default();
+    map.insert_persisted(id, 13.37);
+    map.insert_temp(id, 42);
+
+    assert_eq!(map.get_temp::<f64>(id), Some(13.37));
+    assert_eq!(map.get_persisted::<f64>(id), Some(13.37));
+    assert_eq!(map.get_temp::<i32>(id), Some(42));
+
+    // ------------
+    // Test removal:
+
+    // We can remove:
+    map.remove::<i32>(id);
+    assert_eq!(map.get_temp::<i32>(id), None);
+
+    // Other type is still there, even though it is the same if:
+    assert_eq!(map.get_temp::<f64>(id), Some(13.37));
+    assert_eq!(map.get_persisted::<f64>(id), Some(13.37));
+
+    // But we can still remove the last:
+    map.remove::<f64>(id);
+    assert_eq!(map.get_temp::<f64>(id), None);
+    assert_eq!(map.get_persisted::<f64>(id), None);
+}
+
+#[test]
+fn test_mix() {
+    #[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+    #[derive(Clone, Debug, PartialEq)]
+    struct Foo(i32);
+
+    #[derive(Clone, Debug, PartialEq)]
+    struct Bar(f32);
+
+    let id = Id::new("a");
+
+    let mut map: IdTypeMap = Default::default();
+    map.insert_persisted(id, Foo(555));
+    map.insert_temp(id, Bar(1.0));
+
+    assert_eq!(map.get_temp::<Foo>(id), Some(Foo(555)));
+    assert_eq!(map.get_persisted::<Foo>(id), Some(Foo(555)));
+    assert_eq!(map.get_temp::<Bar>(id), Some(Bar(1.0)));
+
+    // ------------
+    // Test removal:
+
+    // We can remove:
+    map.remove::<Bar>(id);
+    assert_eq!(map.get_temp::<Bar>(id), None);
+
+    // Other type is still there, even though it is the same if:
+    assert_eq!(map.get_temp::<Foo>(id), Some(Foo(555)));
+    assert_eq!(map.get_persisted::<Foo>(id), Some(Foo(555)));
+
+    // But we can still remove the last:
+    map.remove::<Foo>(id);
+    assert_eq!(map.get_temp::<Foo>(id), None);
+    assert_eq!(map.get_persisted::<Foo>(id), None);
+}
+
+#[cfg(feature = "persistence")]
+#[test]
+fn test_mix_serialize() {
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    struct Serializable(i32);
+
+    #[derive(Clone, Debug, PartialEq)]
+    struct NonSerializable(f32);
+
+    let id = Id::new("a");
+
+    let mut map: IdTypeMap = Default::default();
+    map.insert_persisted(id, Serializable(555));
+    map.insert_temp(id, NonSerializable(1.0));
+
+    assert_eq!(map.get_temp::<Serializable>(id), Some(Serializable(555)));
+    assert_eq!(
+        map.get_persisted::<Serializable>(id),
+        Some(Serializable(555))
+    );
+    assert_eq!(
+        map.get_temp::<NonSerializable>(id),
+        Some(NonSerializable(1.0))
+    );
+
+    // -----------
+
+    let serialized = ron::to_string(&map).unwrap();
+
+    // ------------
+    // Test removal:
+
+    // We can remove:
+    map.remove::<NonSerializable>(id);
+    assert_eq!(map.get_temp::<NonSerializable>(id), None);
+
+    // Other type is still there, even though it is the same if:
+    assert_eq!(map.get_temp::<Serializable>(id), Some(Serializable(555)));
+    assert_eq!(
+        map.get_persisted::<Serializable>(id),
+        Some(Serializable(555))
+    );
+
+    // But we can still remove the last:
+    map.remove::<Serializable>(id);
+    assert_eq!(map.get_temp::<Serializable>(id), None);
+    assert_eq!(map.get_persisted::<Serializable>(id), None);
+
+    // --------------------
+    // Test deserialization:
+
+    let mut map: IdTypeMap = ron::from_str(&serialized).unwrap();
+    assert_eq!(map.get_temp::<Serializable>(id), None);
+    assert_eq!(
+        map.get_persisted::<Serializable>(id),
+        Some(Serializable(555))
+    );
+    assert_eq!(map.get_temp::<Serializable>(id), Some(Serializable(555)));
+}
diff --git a/egui/crates/egui/src/util/mod.rs b/egui/crates/egui/src/util/mod.rs
new file mode 100644
index 0000000..55e93eb
--- /dev/null
+++ b/egui/crates/egui/src/util/mod.rs
@@ -0,0 +1,11 @@
+//! Miscellaneous tools used by the rest of egui.
+
+pub mod cache;
+pub(crate) mod fixed_cache;
+pub mod id_type_map;
+pub mod undoer;
+
+pub use id_type_map::IdTypeMap;
+
+pub use epaint::emath::History;
+pub use epaint::util::{hash, hash_with};
diff --git a/egui/crates/egui/src/util/undoer.rs b/egui/crates/egui/src/util/undoer.rs
new file mode 100644
index 0000000..b5e272a
--- /dev/null
+++ b/egui/crates/egui/src/util/undoer.rs
@@ -0,0 +1,172 @@
+use std::collections::VecDeque;
+
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Settings {
+    /// Maximum number of undos.
+    /// If your state is resource intensive, you should keep this low.
+    ///
+    /// Default: `100`
+    pub max_undos: usize,
+
+    /// When that state hasn't changed for this many seconds,
+    /// create a new undo point (if one is needed).
+    ///
+    /// Default value: `1.0` seconds.
+    pub stable_time: f32,
+
+    /// If the state is changing so often that we never get to `stable_time`,
+    /// then still create a save point every `auto_save_interval` seconds,
+    /// so we have something to undo to.
+    ///
+    /// Default value: `30` seconds.
+    pub auto_save_interval: f32,
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            max_undos: 100,
+            stable_time: 1.0,
+            auto_save_interval: 30.0,
+        }
+    }
+}
+
+/// Automatic undo system.
+///
+/// Every frame you feed it the most recent state.
+/// The [`Undoer`] compares it with the latest undo point
+/// and if there is a change it may create a new undo point.
+///
+/// [`Undoer`] follows two simple rules:
+///
+/// 1) If the state has changed since the latest undo point, but has
+///    remained stable for `stable_time` seconds, an new undo point is created.
+/// 2) If the state does not stabilize within `auto_save_interval` seconds, an undo point is created.
+///
+/// Rule 1) will make sure an undo point is not created until you _stop_ dragging that slider.
+/// Rule 2) will make sure that you will get some undo points even if you are constantly changing the state.
+#[derive(Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Undoer<State> {
+    settings: Settings,
+
+    /// New undoes are added to the back.
+    /// Two adjacent undo points are never equal.
+    /// The latest undo point may (often) be the current state.
+    undos: VecDeque<State>,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    flux: Option<Flux<State>>,
+}
+
+impl<State> std::fmt::Debug for Undoer<State> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self { undos, .. } = self;
+        f.debug_struct("Undoer")
+            .field("undo count", &undos.len())
+            .finish()
+    }
+}
+
+/// Represents how the current state is changing
+#[derive(Clone)]
+struct Flux<State> {
+    start_time: f64,
+    latest_change_time: f64,
+    latest_state: State,
+}
+
+impl<State> Undoer<State>
+where
+    State: Clone + PartialEq,
+{
+    /// Do we have an undo point different from the given state?
+    pub fn has_undo(&self, current_state: &State) -> bool {
+        match self.undos.len() {
+            0 => false,
+            1 => self.undos.back() != Some(current_state),
+            _ => true,
+        }
+    }
+
+    /// Return true if the state is currently changing
+    pub fn is_in_flux(&self) -> bool {
+        self.flux.is_some()
+    }
+
+    pub fn undo(&mut self, current_state: &State) -> Option<&State> {
+        if self.has_undo(current_state) {
+            self.flux = None;
+
+            if self.undos.back() == Some(current_state) {
+                self.undos.pop_back();
+            }
+
+            // Note: we keep the undo point intact.
+            self.undos.back()
+        } else {
+            None
+        }
+    }
+
+    /// Add an undo point if, and only if, there has been a change since the latest undo point.
+    ///
+    /// * `time`: current time in seconds.
+    pub fn add_undo(&mut self, current_state: &State) {
+        if self.undos.back() != Some(current_state) {
+            self.undos.push_back(current_state.clone());
+        }
+        while self.undos.len() > self.settings.max_undos {
+            self.undos.pop_front();
+        }
+        self.flux = None;
+    }
+
+    /// Call this as often as you want (e.g. every frame)
+    /// and [`Undoer`] will determine if a new undo point should be created.
+    ///
+    /// * `current_time`: current time in seconds.
+    pub fn feed_state(&mut self, current_time: f64, current_state: &State) {
+        match self.undos.back() {
+            None => {
+                // First time feed_state is called.
+                // always create an undo point:
+                self.add_undo(current_state);
+            }
+            Some(latest_undo) => {
+                if latest_undo == current_state {
+                    self.flux = None;
+                } else {
+                    match self.flux.as_mut() {
+                        None => {
+                            self.flux = Some(Flux {
+                                start_time: current_time,
+                                latest_change_time: current_time,
+                                latest_state: current_state.clone(),
+                            });
+                        }
+                        Some(flux) => {
+                            if &flux.latest_state == current_state {
+                                let time_since_latest_change =
+                                    (current_time - flux.latest_change_time) as f32;
+                                if time_since_latest_change >= self.settings.stable_time {
+                                    self.add_undo(current_state);
+                                }
+                            } else {
+                                let time_since_flux_start = (current_time - flux.start_time) as f32;
+                                if time_since_flux_start >= self.settings.auto_save_interval {
+                                    self.add_undo(current_state);
+                                } else {
+                                    flux.latest_change_time = current_time;
+                                    flux.latest_state = current_state.clone();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/egui/crates/egui/src/widget_text.rs b/egui/crates/egui/src/widget_text.rs
new file mode 100644
index 0000000..bc71c2b
--- /dev/null
+++ b/egui/crates/egui/src/widget_text.rs
@@ -0,0 +1,725 @@
+use std::borrow::Cow;
+use std::sync::Arc;
+
+use crate::{
+    style::WidgetVisuals, text::LayoutJob, Align, Color32, FontFamily, FontSelection, Galley, Pos2,
+    Style, TextStyle, Ui, Visuals,
+};
+
+/// Text and optional style choices for it.
+///
+/// The style choices (font, color) are applied to the entire text.
+/// For more detailed control, use [`crate::text::LayoutJob`] instead.
+///
+/// A [`RichText`] can be used in most widgets and helper functions, e.g. [`Ui::label`] and [`Ui::button`].
+///
+/// ### Example
+/// ```
+/// use egui::{RichText, Color32};
+///
+/// RichText::new("Plain");
+/// RichText::new("colored").color(Color32::RED);
+/// RichText::new("Large and underlined").size(20.0).underline();
+/// ```
+#[derive(Clone, Default, PartialEq)]
+pub struct RichText {
+    text: String,
+    size: Option<f32>,
+    family: Option<FontFamily>,
+    text_style: Option<TextStyle>,
+    background_color: Color32,
+    text_color: Option<Color32>,
+    code: bool,
+    strong: bool,
+    weak: bool,
+    strikethrough: bool,
+    underline: bool,
+    italics: bool,
+    raised: bool,
+}
+
+impl From<&str> for RichText {
+    #[inline]
+    fn from(text: &str) -> Self {
+        RichText::new(text)
+    }
+}
+
+impl From<&String> for RichText {
+    #[inline]
+    fn from(text: &String) -> Self {
+        RichText::new(text)
+    }
+}
+
+impl From<&mut String> for RichText {
+    #[inline]
+    fn from(text: &mut String) -> Self {
+        RichText::new(text.clone())
+    }
+}
+
+impl From<String> for RichText {
+    #[inline]
+    fn from(text: String) -> Self {
+        RichText::new(text)
+    }
+}
+
+impl From<Cow<'_, str>> for RichText {
+    #[inline]
+    fn from(text: Cow<'_, str>) -> Self {
+        Self::new(text)
+    }
+}
+
+impl RichText {
+    #[inline]
+    pub fn new(text: impl Into<String>) -> Self {
+        Self {
+            text: text.into(),
+            ..Default::default()
+        }
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.text.is_empty()
+    }
+
+    #[inline]
+    pub fn text(&self) -> &str {
+        &self.text
+    }
+
+    /// Select the font size (in points).
+    /// This overrides the value from [`Self::text_style`].
+    #[inline]
+    pub fn size(mut self, size: f32) -> Self {
+        self.size = Some(size);
+        self
+    }
+
+    /// Select the font family.
+    ///
+    /// This overrides the value from [`Self::text_style`].
+    ///
+    /// Only the families available in [`crate::FontDefinitions::families`] may be used.
+    #[inline]
+    pub fn family(mut self, family: FontFamily) -> Self {
+        self.family = Some(family);
+        self
+    }
+
+    /// Select the font and size.
+    /// This overrides the value from [`Self::text_style`].
+    #[inline]
+    pub fn font(mut self, font_id: crate::FontId) -> Self {
+        let crate::FontId { size, family } = font_id;
+        self.size = Some(size);
+        self.family = Some(family);
+        self
+    }
+
+    /// Override the [`TextStyle`].
+    #[inline]
+    pub fn text_style(mut self, text_style: TextStyle) -> Self {
+        self.text_style = Some(text_style);
+        self
+    }
+
+    /// Set the [`TextStyle`] unless it has already been set
+    #[inline]
+    pub fn fallback_text_style(mut self, text_style: TextStyle) -> Self {
+        self.text_style.get_or_insert(text_style);
+        self
+    }
+
+    /// Use [`TextStyle::Heading`].
+    #[inline]
+    pub fn heading(self) -> Self {
+        self.text_style(TextStyle::Heading)
+    }
+
+    /// Use [`TextStyle::Monospace`].
+    #[inline]
+    pub fn monospace(self) -> Self {
+        self.text_style(TextStyle::Monospace)
+    }
+
+    /// Monospace label with different background color.
+    #[inline]
+    pub fn code(mut self) -> Self {
+        self.code = true;
+        self.text_style(TextStyle::Monospace)
+    }
+
+    /// Extra strong text (stronger color).
+    #[inline]
+    pub fn strong(mut self) -> Self {
+        self.strong = true;
+        self
+    }
+
+    /// Extra weak text (fainter color).
+    #[inline]
+    pub fn weak(mut self) -> Self {
+        self.weak = true;
+        self
+    }
+
+    /// Draw a line under the text.
+    ///
+    /// If you want to control the line color, use [`LayoutJob`] instead.
+    #[inline]
+    pub fn underline(mut self) -> Self {
+        self.underline = true;
+        self
+    }
+
+    /// Draw a line through the text, crossing it out.
+    ///
+    /// If you want to control the strikethrough line color, use [`LayoutJob`] instead.
+    #[inline]
+    pub fn strikethrough(mut self) -> Self {
+        self.strikethrough = true;
+        self
+    }
+
+    /// Tilt the characters to the right.
+    #[inline]
+    pub fn italics(mut self) -> Self {
+        self.italics = true;
+        self
+    }
+
+    /// Smaller text.
+    #[inline]
+    pub fn small(self) -> Self {
+        self.text_style(TextStyle::Small)
+    }
+
+    /// For e.g. exponents.
+    #[inline]
+    pub fn small_raised(self) -> Self {
+        self.text_style(TextStyle::Small).raised()
+    }
+
+    /// Align text to top. Only applicable together with [`Self::small()`].
+    #[inline]
+    pub fn raised(mut self) -> Self {
+        self.raised = true;
+        self
+    }
+
+    /// Fill-color behind the text.
+    #[inline]
+    pub fn background_color(mut self, background_color: impl Into<Color32>) -> Self {
+        self.background_color = background_color.into();
+        self
+    }
+
+    /// Override text color.
+    #[inline]
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.text_color = Some(color.into());
+        self
+    }
+
+    /// Read the font height of the selected text style.
+    pub fn font_height(&self, fonts: &epaint::Fonts, style: &Style) -> f32 {
+        let mut font_id = self.text_style.as_ref().map_or_else(
+            || FontSelection::Default.resolve(style),
+            |text_style| text_style.resolve(style),
+        );
+
+        if let Some(size) = self.size {
+            font_id.size = size;
+        }
+        if let Some(family) = &self.family {
+            font_id.family = family.clone();
+        }
+        fonts.row_height(&font_id)
+    }
+
+    fn into_text_job(
+        self,
+        style: &Style,
+        fallback_font: FontSelection,
+        default_valign: Align,
+    ) -> WidgetTextJob {
+        let text_color = self.get_text_color(&style.visuals);
+
+        let Self {
+            text,
+            size,
+            family,
+            text_style,
+            background_color,
+            text_color: _, // already used by `get_text_color`
+            code,
+            strong: _, // already used by `get_text_color`
+            weak: _,   // already used by `get_text_color`
+            strikethrough,
+            underline,
+            italics,
+            raised,
+        } = self;
+
+        let job_has_color = text_color.is_some();
+        let line_color = text_color.unwrap_or_else(|| style.visuals.text_color());
+        let text_color = text_color.unwrap_or(crate::Color32::TEMPORARY_COLOR);
+
+        let font_id = {
+            let mut font_id = text_style
+                .or_else(|| style.override_text_style.clone())
+                .map_or_else(
+                    || fallback_font.resolve(style),
+                    |text_style| text_style.resolve(style),
+                );
+            if let Some(size) = size {
+                font_id.size = size;
+            }
+            if let Some(family) = family {
+                font_id.family = family;
+            }
+            font_id
+        };
+
+        let mut background_color = background_color;
+        if code {
+            background_color = style.visuals.code_bg_color;
+        }
+        let underline = if underline {
+            crate::Stroke::new(1.0, line_color)
+        } else {
+            crate::Stroke::NONE
+        };
+        let strikethrough = if strikethrough {
+            crate::Stroke::new(1.0, line_color)
+        } else {
+            crate::Stroke::NONE
+        };
+
+        let valign = if raised {
+            crate::Align::TOP
+        } else {
+            default_valign
+        };
+
+        let text_format = crate::text::TextFormat {
+            font_id,
+            color: text_color,
+            background: background_color,
+            italics,
+            underline,
+            strikethrough,
+            valign,
+        };
+
+        let job = LayoutJob::single_section(text, text_format);
+        WidgetTextJob { job, job_has_color }
+    }
+
+    fn get_text_color(&self, visuals: &Visuals) -> Option<Color32> {
+        if let Some(text_color) = self.text_color {
+            Some(text_color)
+        } else if self.strong {
+            Some(visuals.strong_text_color())
+        } else if self.weak {
+            Some(visuals.weak_text_color())
+        } else {
+            visuals.override_text_color
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// This is how you specify text for a widget.
+///
+/// A lot of widgets use `impl Into<WidgetText>` as an argument,
+/// allowing you to pass in [`String`], [`RichText`], [`LayoutJob`], and more.
+///
+/// Often a [`WidgetText`] is just a simple [`String`],
+/// but it can be a [`RichText`] (text with color, style, etc),
+/// a [`LayoutJob`] (for when you want full control of how the text looks)
+/// or text that has already been laid out in a [`Galley`].
+#[derive(Clone)]
+pub enum WidgetText {
+    RichText(RichText),
+
+    /// Use this [`LayoutJob`] when laying out the text.
+    ///
+    /// Only [`LayoutJob::text`] and [`LayoutJob::sections`] are guaranteed to be respected.
+    ///
+    /// [`TextWrapping::max_width`](epaint::text::TextWrapping::max_width), [`LayoutJob::halign`], [`LayoutJob::justify`]
+    /// and [`LayoutJob::first_row_min_height`] will likely be determined by the [`crate::Layout`]
+    /// of the [`Ui`] the widget is placed in.
+    /// If you want all parts of the [`LayoutJob`] respected, then convert it to a
+    /// [`Galley`] and use [`Self::Galley`] instead.
+    LayoutJob(LayoutJob),
+
+    /// Use exactly this galley when painting the text.
+    Galley(Arc<Galley>),
+}
+
+impl Default for WidgetText {
+    fn default() -> Self {
+        Self::RichText(RichText::default())
+    }
+}
+
+impl WidgetText {
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Self::RichText(text) => text.is_empty(),
+            Self::LayoutJob(job) => job.is_empty(),
+            Self::Galley(galley) => galley.is_empty(),
+        }
+    }
+
+    #[inline]
+    pub fn text(&self) -> &str {
+        match self {
+            Self::RichText(text) => text.text(),
+            Self::LayoutJob(job) => &job.text,
+            Self::Galley(galley) => galley.text(),
+        }
+    }
+
+    /// Override the [`TextStyle`] if, and only if, this is a [`RichText`].
+    ///
+    /// Prefer using [`RichText`] directly!
+    #[inline]
+    pub fn text_style(self, text_style: TextStyle) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.text_style(text_style)),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Set the [`TextStyle`] unless it has already been set
+    ///
+    /// Prefer using [`RichText`] directly!
+    #[inline]
+    pub fn fallback_text_style(self, text_style: TextStyle) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.fallback_text_style(text_style)),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Override text color if, and only if, this is a [`RichText`].
+    ///
+    /// Prefer using [`RichText`] directly!
+    #[inline]
+    pub fn color(self, color: impl Into<Color32>) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.color(color)),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn heading(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.heading()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn monospace(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.monospace()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn code(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.code()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn strong(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.strong()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn weak(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.weak()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn underline(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.underline()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn strikethrough(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.strikethrough()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn italics(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.italics()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn small(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.small()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn small_raised(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.small_raised()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn raised(self) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.raised()),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    /// Prefer using [`RichText`] directly!
+    pub fn background_color(self, background_color: impl Into<Color32>) -> Self {
+        match self {
+            Self::RichText(text) => Self::RichText(text.background_color(background_color)),
+            Self::LayoutJob(_) | Self::Galley(_) => self,
+        }
+    }
+
+    pub(crate) fn font_height(&self, fonts: &epaint::Fonts, style: &Style) -> f32 {
+        match self {
+            Self::RichText(text) => text.font_height(fonts, style),
+            Self::LayoutJob(job) => job.font_height(fonts),
+            Self::Galley(galley) => {
+                if let Some(row) = galley.rows.first() {
+                    row.height()
+                } else {
+                    galley.size().y
+                }
+            }
+        }
+    }
+
+    pub fn into_text_job(
+        self,
+        style: &Style,
+        fallback_font: FontSelection,
+        default_valign: Align,
+    ) -> WidgetTextJob {
+        match self {
+            Self::RichText(text) => text.into_text_job(style, fallback_font, default_valign),
+            Self::LayoutJob(job) => WidgetTextJob {
+                job,
+                job_has_color: true,
+            },
+            Self::Galley(galley) => {
+                let job: LayoutJob = (*galley.job).clone();
+                WidgetTextJob {
+                    job,
+                    job_has_color: true,
+                }
+            }
+        }
+    }
+
+    /// Layout with wrap mode based on the containing [`Ui`].
+    ///
+    /// wrap: override for [`Ui::wrap_text`].
+    pub fn into_galley(
+        self,
+        ui: &Ui,
+        wrap: Option<bool>,
+        available_width: f32,
+        fallback_font: impl Into<FontSelection>,
+    ) -> WidgetTextGalley {
+        let wrap = wrap.unwrap_or_else(|| ui.wrap_text());
+        let wrap_width = if wrap { available_width } else { f32::INFINITY };
+
+        match self {
+            Self::RichText(text) => {
+                let valign = ui.layout().vertical_align();
+                let mut text_job = text.into_text_job(ui.style(), fallback_font.into(), valign);
+                text_job.job.wrap.max_width = wrap_width;
+                WidgetTextGalley {
+                    galley: ui.fonts(|f| f.layout_job(text_job.job)),
+                    galley_has_color: text_job.job_has_color,
+                }
+            }
+            Self::LayoutJob(mut job) => {
+                job.wrap.max_width = wrap_width;
+                WidgetTextGalley {
+                    galley: ui.fonts(|f| f.layout_job(job)),
+                    galley_has_color: true,
+                }
+            }
+            Self::Galley(galley) => WidgetTextGalley {
+                galley,
+                galley_has_color: true,
+            },
+        }
+    }
+}
+
+impl From<&str> for WidgetText {
+    #[inline]
+    fn from(text: &str) -> Self {
+        Self::RichText(RichText::new(text))
+    }
+}
+
+impl From<&String> for WidgetText {
+    #[inline]
+    fn from(text: &String) -> Self {
+        Self::RichText(RichText::new(text))
+    }
+}
+
+impl From<String> for WidgetText {
+    #[inline]
+    fn from(text: String) -> Self {
+        Self::RichText(RichText::new(text))
+    }
+}
+
+impl From<Cow<'_, str>> for WidgetText {
+    #[inline]
+    fn from(text: Cow<'_, str>) -> Self {
+        Self::RichText(RichText::new(text))
+    }
+}
+
+impl From<RichText> for WidgetText {
+    #[inline]
+    fn from(rich_text: RichText) -> Self {
+        Self::RichText(rich_text)
+    }
+}
+
+impl From<LayoutJob> for WidgetText {
+    #[inline]
+    fn from(layout_job: LayoutJob) -> Self {
+        Self::LayoutJob(layout_job)
+    }
+}
+
+impl From<Arc<Galley>> for WidgetText {
+    #[inline]
+    fn from(galley: Arc<Galley>) -> Self {
+        Self::Galley(galley)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, PartialEq)]
+pub struct WidgetTextJob {
+    pub job: LayoutJob,
+    pub job_has_color: bool,
+}
+
+impl WidgetTextJob {
+    pub fn into_galley(self, fonts: &crate::text::Fonts) -> WidgetTextGalley {
+        let Self { job, job_has_color } = self;
+        let galley = fonts.layout_job(job);
+        WidgetTextGalley {
+            galley,
+            galley_has_color: job_has_color,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Text that has been laid out and ready to be painted.
+#[derive(Clone, PartialEq)]
+pub struct WidgetTextGalley {
+    pub galley: Arc<Galley>,
+    pub galley_has_color: bool,
+}
+
+impl WidgetTextGalley {
+    /// Size of the laid out text.
+    #[inline]
+    pub fn size(&self) -> crate::Vec2 {
+        self.galley.size()
+    }
+
+    /// Size of the laid out text.
+    #[inline]
+    pub fn text(&self) -> &str {
+        self.galley.text()
+    }
+
+    #[inline]
+    pub fn galley(&self) -> &Arc<Galley> {
+        &self.galley
+    }
+
+    /// Use the colors in the original [`WidgetText`] if any,
+    /// else fall back to the one specified by the [`WidgetVisuals`].
+    pub fn paint_with_visuals(
+        self,
+        painter: &crate::Painter,
+        text_pos: Pos2,
+        visuals: &WidgetVisuals,
+    ) {
+        self.paint_with_fallback_color(painter, text_pos, visuals.text_color());
+    }
+
+    /// Use the colors in the original [`WidgetText`] if any,
+    /// else fall back to the given color.
+    pub fn paint_with_fallback_color(
+        self,
+        painter: &crate::Painter,
+        text_pos: Pos2,
+        text_color: Color32,
+    ) {
+        if self.galley_has_color {
+            painter.galley(text_pos, self.galley);
+        } else {
+            painter.galley_with_color(text_pos, self.galley, text_color);
+        }
+    }
+
+    /// Paint with this specific color.
+    pub fn paint_with_color_override(
+        self,
+        painter: &crate::Painter,
+        text_pos: Pos2,
+        text_color: Color32,
+    ) {
+        painter.galley_with_color(text_pos, self.galley, text_color);
+    }
+}
diff --git a/egui/crates/egui/src/widgets/button.rs b/egui/crates/egui/src/widgets/button.rs
new file mode 100644
index 0000000..a7fa678
--- /dev/null
+++ b/egui/crates/egui/src/widgets/button.rs
@@ -0,0 +1,571 @@
+use crate::*;
+
+/// Clickable button with text.
+///
+/// See also [`Ui::button`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # fn do_stuff() {}
+///
+/// if ui.add(egui::Button::new("Click me")).clicked() {
+///     do_stuff();
+/// }
+///
+/// // A greyed-out and non-interactive button:
+/// if ui.add_enabled(false, egui::Button::new("Can't click this")).clicked() {
+///     unreachable!();
+/// }
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Button {
+    text: WidgetText,
+    shortcut_text: WidgetText,
+    wrap: Option<bool>,
+    /// None means default for interact
+    fill: Option<Color32>,
+    stroke: Option<Stroke>,
+    sense: Sense,
+    small: bool,
+    frame: Option<bool>,
+    min_size: Vec2,
+    rounding: Option<Rounding>,
+    image: Option<widgets::Image>,
+}
+
+impl Button {
+    pub fn new(text: impl Into<WidgetText>) -> Self {
+        Self {
+            text: text.into(),
+            shortcut_text: Default::default(),
+            wrap: None,
+            fill: None,
+            stroke: None,
+            sense: Sense::click(),
+            small: false,
+            frame: None,
+            min_size: Vec2::ZERO,
+            rounding: None,
+            image: None,
+        }
+    }
+
+    /// Creates a button with an image to the left of the text. The size of the image as displayed is defined by the provided size.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn image_and_text(
+        texture_id: TextureId,
+        image_size: impl Into<Vec2>,
+        text: impl Into<WidgetText>,
+    ) -> Self {
+        Self {
+            image: Some(widgets::Image::new(texture_id, image_size)),
+            ..Self::new(text)
+        }
+    }
+
+    /// If `true`, the text will wrap to stay within the max width of the [`Ui`].
+    ///
+    /// By default [`Self::wrap`] will be true in vertical layouts
+    /// and horizontal layouts with wrapping,
+    /// and false on non-wrapping horizontal layouts.
+    ///
+    /// Note that any `\n` in the text will always produce a new line.
+    #[inline]
+    pub fn wrap(mut self, wrap: bool) -> Self {
+        self.wrap = Some(wrap);
+        self
+    }
+
+    /// Override background fill color. Note that this will override any on-hover effects.
+    /// Calling this will also turn on the frame.
+    pub fn fill(mut self, fill: impl Into<Color32>) -> Self {
+        self.fill = Some(fill.into());
+        self.frame = Some(true);
+        self
+    }
+
+    /// Override button stroke. Note that this will override any on-hover effects.
+    /// Calling this will also turn on the frame.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = Some(stroke.into());
+        self.frame = Some(true);
+        self
+    }
+
+    /// Make this a small button, suitable for embedding into text.
+    pub fn small(mut self) -> Self {
+        self.text = self.text.text_style(TextStyle::Body);
+        self.small = true;
+        self
+    }
+
+    /// Turn off the frame
+    pub fn frame(mut self, frame: bool) -> Self {
+        self.frame = Some(frame);
+        self
+    }
+
+    /// By default, buttons senses clicks.
+    /// Change this to a drag-button with `Sense::drag()`.
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = sense;
+        self
+    }
+
+    /// Set the minimum size of the button.
+    pub fn min_size(mut self, min_size: Vec2) -> Self {
+        self.min_size = min_size;
+        self
+    }
+
+    /// Set the rounding of the button.
+    pub fn rounding(mut self, rounding: impl Into<Rounding>) -> Self {
+        self.rounding = Some(rounding.into());
+        self
+    }
+
+    /// Show some text on the right side of the button, in weak color.
+    ///
+    /// Designed for menu buttons, for setting a keyboard shortcut text (e.g. `Ctrl+S`).
+    ///
+    /// The text can be created with [`Context::format_shortcut`].
+    pub fn shortcut_text(mut self, shortcut_text: impl Into<WidgetText>) -> Self {
+        self.shortcut_text = shortcut_text.into();
+        self
+    }
+}
+
+impl Widget for Button {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Button {
+            text,
+            shortcut_text,
+            wrap,
+            fill,
+            stroke,
+            sense,
+            small,
+            frame,
+            min_size,
+            rounding,
+            image,
+        } = self;
+
+        let frame = frame.unwrap_or_else(|| ui.visuals().button_frame);
+
+        let mut button_padding = ui.spacing().button_padding;
+        if small {
+            button_padding.y = 0.0;
+        }
+
+        let mut text_wrap_width = ui.available_width() - 2.0 * button_padding.x;
+        if let Some(image) = image {
+            text_wrap_width -= image.size().x + ui.spacing().icon_spacing;
+        }
+        if !shortcut_text.is_empty() {
+            text_wrap_width -= 60.0; // Some space for the shortcut text (which we never wrap).
+        }
+
+        let text = text.into_galley(ui, wrap, text_wrap_width, TextStyle::Button);
+        let shortcut_text = (!shortcut_text.is_empty())
+            .then(|| shortcut_text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button));
+
+        let mut desired_size = text.size();
+        if let Some(image) = image {
+            desired_size.x += image.size().x + ui.spacing().icon_spacing;
+            desired_size.y = desired_size.y.max(image.size().y);
+        }
+        if let Some(shortcut_text) = &shortcut_text {
+            desired_size.x += ui.spacing().item_spacing.x + shortcut_text.size().x;
+            desired_size.y = desired_size.y.max(shortcut_text.size().y);
+        }
+        desired_size += 2.0 * button_padding;
+        if !small {
+            desired_size.y = desired_size.y.at_least(ui.spacing().interact_size.y);
+        }
+        desired_size = desired_size.at_least(min_size);
+
+        let (rect, response) = ui.allocate_at_least(desired_size, sense);
+        response.widget_info(|| WidgetInfo::labeled(WidgetType::Button, text.text()));
+
+        if ui.is_rect_visible(rect) {
+            let visuals = ui.style().interact(&response);
+
+            if frame {
+                let fill = fill.unwrap_or(visuals.weak_bg_fill);
+                let stroke = stroke.unwrap_or(visuals.bg_stroke);
+                let rounding = rounding.unwrap_or(visuals.rounding);
+                ui.painter()
+                    .rect(rect.expand(visuals.expansion), rounding, fill, stroke);
+            }
+
+            let text_pos = if let Some(image) = image {
+                let icon_spacing = ui.spacing().icon_spacing;
+                pos2(
+                    rect.min.x + button_padding.x + image.size().x + icon_spacing,
+                    rect.center().y - 0.5 * text.size().y,
+                )
+            } else {
+                ui.layout()
+                    .align_size_within_rect(text.size(), rect.shrink2(button_padding))
+                    .min
+            };
+            text.paint_with_visuals(ui.painter(), text_pos, visuals);
+
+            if let Some(shortcut_text) = shortcut_text {
+                let shortcut_text_pos = pos2(
+                    rect.max.x - button_padding.x - shortcut_text.size().x,
+                    rect.center().y - 0.5 * shortcut_text.size().y,
+                );
+                shortcut_text.paint_with_fallback_color(
+                    ui.painter(),
+                    shortcut_text_pos,
+                    ui.visuals().weak_text_color(),
+                );
+            }
+
+            if let Some(image) = image {
+                let image_rect = Rect::from_min_size(
+                    pos2(
+                        rect.min.x + button_padding.x,
+                        rect.center().y - 0.5 - (image.size().y / 2.0),
+                    ),
+                    image.size(),
+                );
+                image.paint_at(ui, image_rect);
+            }
+        }
+
+        response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+// TODO(emilk): allow checkbox without a text label
+/// Boolean on/off control with text label.
+///
+/// Usually you'd use [`Ui::checkbox`] instead.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # let mut my_bool = true;
+/// // These are equivalent:
+/// ui.checkbox(&mut my_bool, "Checked");
+/// ui.add(egui::Checkbox::new(&mut my_bool, "Checked"));
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Checkbox<'a> {
+    checked: &'a mut bool,
+    text: WidgetText,
+}
+
+impl<'a> Checkbox<'a> {
+    pub fn new(checked: &'a mut bool, text: impl Into<WidgetText>) -> Self {
+        Checkbox {
+            checked,
+            text: text.into(),
+        }
+    }
+
+    pub fn without_text(checked: &'a mut bool) -> Self {
+        Self::new(checked, WidgetText::default())
+    }
+}
+
+impl<'a> Widget for Checkbox<'a> {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Checkbox { checked, text } = self;
+
+        let spacing = &ui.spacing();
+        let icon_width = spacing.icon_width;
+        let icon_spacing = spacing.icon_spacing;
+
+        let (text, mut desired_size) = if text.is_empty() {
+            (None, vec2(icon_width, 0.0))
+        } else {
+            let total_extra = vec2(icon_width + icon_spacing, 0.0);
+
+            let wrap_width = ui.available_width() - total_extra.x;
+            let text = text.into_galley(ui, None, wrap_width, TextStyle::Button);
+
+            let mut desired_size = total_extra + text.size();
+            desired_size = desired_size.at_least(spacing.interact_size);
+
+            (Some(text), desired_size)
+        };
+
+        desired_size = desired_size.at_least(Vec2::splat(spacing.interact_size.y));
+        desired_size.y = desired_size.y.max(icon_width);
+        let (rect, mut response) = ui.allocate_exact_size(desired_size, Sense::click());
+
+        if response.clicked() {
+            *checked = !*checked;
+            response.mark_changed();
+        }
+        response.widget_info(|| {
+            WidgetInfo::selected(
+                WidgetType::Checkbox,
+                *checked,
+                text.as_ref().map_or("", |x| x.text()),
+            )
+        });
+
+        if ui.is_rect_visible(rect) {
+            // let visuals = ui.style().interact_selectable(&response, *checked); // too colorful
+            let visuals = ui.style().interact(&response);
+            let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
+            ui.painter().add(epaint::RectShape {
+                rect: big_icon_rect.expand(visuals.expansion),
+                rounding: visuals.rounding,
+                fill: visuals.bg_fill,
+                stroke: visuals.bg_stroke,
+            });
+
+            if *checked {
+                // Check mark:
+                ui.painter().add(Shape::line(
+                    vec![
+                        pos2(small_icon_rect.left(), small_icon_rect.center().y),
+                        pos2(small_icon_rect.center().x, small_icon_rect.bottom()),
+                        pos2(small_icon_rect.right(), small_icon_rect.top()),
+                    ],
+                    visuals.fg_stroke,
+                ));
+            }
+            if let Some(text) = text {
+                let text_pos = pos2(
+                    rect.min.x + icon_width + icon_spacing,
+                    rect.center().y - 0.5 * text.size().y,
+                );
+                text.paint_with_visuals(ui.painter(), text_pos, visuals);
+            }
+        }
+
+        response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// One out of several alternatives, either selected or not.
+///
+/// Usually you'd use [`Ui::radio_value`] or [`Ui::radio`] instead.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// #[derive(PartialEq)]
+/// enum Enum { First, Second, Third }
+/// let mut my_enum = Enum::First;
+///
+/// ui.radio_value(&mut my_enum, Enum::First, "First");
+///
+/// // is equivalent to:
+///
+/// if ui.add(egui::RadioButton::new(my_enum == Enum::First, "First")).clicked() {
+///     my_enum = Enum::First
+/// }
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct RadioButton {
+    checked: bool,
+    text: WidgetText,
+}
+
+impl RadioButton {
+    pub fn new(checked: bool, text: impl Into<WidgetText>) -> Self {
+        Self {
+            checked,
+            text: text.into(),
+        }
+    }
+}
+
+impl Widget for RadioButton {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let RadioButton { checked, text } = self;
+
+        let spacing = &ui.spacing();
+        let icon_width = spacing.icon_width;
+        let icon_spacing = spacing.icon_spacing;
+
+        let (text, mut desired_size) = if text.is_empty() {
+            (None, vec2(icon_width, 0.0))
+        } else {
+            let total_extra = vec2(icon_width + icon_spacing, 0.0);
+
+            let wrap_width = ui.available_width() - total_extra.x;
+            let text = text.into_galley(ui, None, wrap_width, TextStyle::Button);
+
+            let mut desired_size = total_extra + text.size();
+            desired_size = desired_size.at_least(spacing.interact_size);
+
+            (Some(text), desired_size)
+        };
+
+        desired_size = desired_size.at_least(Vec2::splat(spacing.interact_size.y));
+        desired_size.y = desired_size.y.max(icon_width);
+        let (rect, response) = ui.allocate_exact_size(desired_size, Sense::click());
+
+        response.widget_info(|| {
+            WidgetInfo::selected(
+                WidgetType::RadioButton,
+                checked,
+                text.as_ref().map_or("", |x| x.text()),
+            )
+        });
+
+        if ui.is_rect_visible(rect) {
+            // let visuals = ui.style().interact_selectable(&response, checked); // too colorful
+            let visuals = ui.style().interact(&response);
+
+            let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
+
+            let painter = ui.painter();
+
+            painter.add(epaint::CircleShape {
+                center: big_icon_rect.center(),
+                radius: big_icon_rect.width() / 2.0 + visuals.expansion,
+                fill: visuals.bg_fill,
+                stroke: visuals.bg_stroke,
+            });
+
+            if checked {
+                painter.add(epaint::CircleShape {
+                    center: small_icon_rect.center(),
+                    radius: small_icon_rect.width() / 3.0,
+                    fill: visuals.fg_stroke.color, // Intentional to use stroke and not fill
+                    // fill: ui.visuals().selection.stroke.color, // too much color
+                    stroke: Default::default(),
+                });
+            }
+
+            if let Some(text) = text {
+                let text_pos = pos2(
+                    rect.min.x + icon_width + icon_spacing,
+                    rect.center().y - 0.5 * text.size().y,
+                );
+                text.paint_with_visuals(ui.painter(), text_pos, visuals);
+            }
+        }
+
+        response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A clickable image within a frame.
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+#[derive(Clone, Debug)]
+pub struct ImageButton {
+    image: widgets::Image,
+    sense: Sense,
+    frame: bool,
+    selected: bool,
+}
+
+impl ImageButton {
+    pub fn new(texture_id: impl Into<TextureId>, size: impl Into<Vec2>) -> Self {
+        Self {
+            image: widgets::Image::new(texture_id, size),
+            sense: Sense::click(),
+            frame: true,
+            selected: false,
+        }
+    }
+
+    /// Select UV range. Default is (0,0) in top-left, (1,1) bottom right.
+    pub fn uv(mut self, uv: impl Into<Rect>) -> Self {
+        self.image = self.image.uv(uv);
+        self
+    }
+
+    /// Multiply image color with this. Default is WHITE (no tint).
+    pub fn tint(mut self, tint: impl Into<Color32>) -> Self {
+        self.image = self.image.tint(tint);
+        self
+    }
+
+    /// If `true`, mark this button as "selected".
+    pub fn selected(mut self, selected: bool) -> Self {
+        self.selected = selected;
+        self
+    }
+
+    /// Turn off the frame
+    pub fn frame(mut self, frame: bool) -> Self {
+        self.frame = frame;
+        self
+    }
+
+    /// By default, buttons senses clicks.
+    /// Change this to a drag-button with `Sense::drag()`.
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = sense;
+        self
+    }
+}
+
+impl Widget for ImageButton {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Self {
+            image,
+            sense,
+            frame,
+            selected,
+        } = self;
+
+        let padding = if frame {
+            // so we can see that it is a button:
+            Vec2::splat(ui.spacing().button_padding.x)
+        } else {
+            Vec2::ZERO
+        };
+        let padded_size = image.size() + 2.0 * padding;
+        let (rect, response) = ui.allocate_exact_size(padded_size, sense);
+        response.widget_info(|| WidgetInfo::new(WidgetType::ImageButton));
+
+        if ui.is_rect_visible(rect) {
+            let (expansion, rounding, fill, stroke) = if selected {
+                let selection = ui.visuals().selection;
+                (
+                    Vec2::ZERO,
+                    Rounding::none(),
+                    selection.bg_fill,
+                    selection.stroke,
+                )
+            } else if frame {
+                let visuals = ui.style().interact(&response);
+                let expansion = Vec2::splat(visuals.expansion);
+                (
+                    expansion,
+                    visuals.rounding,
+                    visuals.weak_bg_fill,
+                    visuals.bg_stroke,
+                )
+            } else {
+                Default::default()
+            };
+
+            // Draw frame background (for transparent images):
+            ui.painter()
+                .rect_filled(rect.expand2(expansion), rounding, fill);
+
+            let image_rect = ui
+                .layout()
+                .align_size_within_rect(image.size(), rect.shrink2(padding));
+            // let image_rect = image_rect.expand2(expansion); // can make it blurry, so let's not
+            image.paint_at(ui, image_rect);
+
+            // Draw frame outline:
+            ui.painter()
+                .rect_stroke(rect.expand2(expansion), rounding, stroke);
+        }
+
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/color_picker.rs b/egui/crates/egui/src/widgets/color_picker.rs
new file mode 100644
index 0000000..da5f286
--- /dev/null
+++ b/egui/crates/egui/src/widgets/color_picker.rs
@@ -0,0 +1,446 @@
+//! Color picker widgets.
+
+use crate::util::fixed_cache::FixedCache;
+use crate::*;
+use epaint::{ecolor::*, *};
+
+fn contrast_color(color: impl Into<Rgba>) -> Color32 {
+    if color.into().intensity() < 0.5 {
+        Color32::WHITE
+    } else {
+        Color32::BLACK
+    }
+}
+
+/// Number of vertices per dimension in the color sliders.
+/// We need at least 6 for hues, and more for smooth 2D areas.
+/// Should always be a multiple of 6 to hit the peak hues in HSV/HSL (every 60°).
+const N: u32 = 6 * 6;
+
+fn background_checkers(painter: &Painter, rect: Rect) {
+    let rect = rect.shrink(0.5); // Small hack to avoid the checkers from peeking through the sides
+    if !rect.is_positive() {
+        return;
+    }
+
+    let dark_color = Color32::from_gray(32);
+    let bright_color = Color32::from_gray(128);
+
+    let checker_size = Vec2::splat(rect.height() / 2.0);
+    let n = (rect.width() / checker_size.x).round() as u32;
+
+    let mut mesh = Mesh::default();
+    mesh.add_colored_rect(rect, dark_color);
+
+    let mut top = true;
+    for i in 0..n {
+        let x = lerp(rect.left()..=rect.right(), i as f32 / (n as f32));
+        let small_rect = if top {
+            Rect::from_min_size(pos2(x, rect.top()), checker_size)
+        } else {
+            Rect::from_min_size(pos2(x, rect.center().y), checker_size)
+        };
+        mesh.add_colored_rect(small_rect, bright_color);
+        top = !top;
+    }
+    painter.add(Shape::mesh(mesh));
+}
+
+/// Show a color with background checkers to demonstrate transparency (if any).
+pub fn show_color(ui: &mut Ui, color: impl Into<Color32>, desired_size: Vec2) -> Response {
+    show_color32(ui, color.into(), desired_size)
+}
+
+fn show_color32(ui: &mut Ui, color: Color32, desired_size: Vec2) -> Response {
+    let (rect, response) = ui.allocate_at_least(desired_size, Sense::hover());
+    if ui.is_rect_visible(rect) {
+        show_color_at(ui.painter(), color, rect);
+    }
+    response
+}
+
+/// Show a color with background checkers to demonstrate transparency (if any).
+pub fn show_color_at(painter: &Painter, color: Color32, rect: Rect) {
+    if color.is_opaque() {
+        painter.rect_filled(rect, 0.0, color);
+    } else {
+        // Transparent: how both the transparent and opaque versions of the color
+        background_checkers(painter, rect);
+
+        if color == Color32::TRANSPARENT {
+            // There is no opaque version, so just show the background checkers
+        } else {
+            let left = Rect::from_min_max(rect.left_top(), rect.center_bottom());
+            let right = Rect::from_min_max(rect.center_top(), rect.right_bottom());
+            painter.rect_filled(left, 0.0, color);
+            painter.rect_filled(right, 0.0, color.to_opaque());
+        }
+    }
+}
+
+fn color_button(ui: &mut Ui, color: Color32, open: bool) -> Response {
+    let size = ui.spacing().interact_size;
+    let (rect, response) = ui.allocate_exact_size(size, Sense::click());
+    response.widget_info(|| WidgetInfo::new(WidgetType::ColorButton));
+
+    if ui.is_rect_visible(rect) {
+        let visuals = if open {
+            &ui.visuals().widgets.open
+        } else {
+            ui.style().interact(&response)
+        };
+        let rect = rect.expand(visuals.expansion);
+
+        show_color_at(ui.painter(), color, rect);
+
+        let rounding = visuals.rounding.at_most(2.0);
+        ui.painter()
+            .rect_stroke(rect, rounding, (2.0, visuals.bg_fill)); // fill is intentional, because default style has no border
+    }
+
+    response
+}
+
+fn color_slider_1d(ui: &mut Ui, value: &mut f32, color_at: impl Fn(f32) -> Color32) -> Response {
+    #![allow(clippy::identity_op)]
+
+    let desired_size = vec2(ui.spacing().slider_width, ui.spacing().interact_size.y);
+    let (rect, response) = ui.allocate_at_least(desired_size, Sense::click_and_drag());
+
+    if let Some(mpos) = response.interact_pointer_pos() {
+        *value = remap_clamp(mpos.x, rect.left()..=rect.right(), 0.0..=1.0);
+    }
+
+    if ui.is_rect_visible(rect) {
+        let visuals = ui.style().interact(&response);
+
+        background_checkers(ui.painter(), rect); // for alpha:
+
+        {
+            // fill color:
+            let mut mesh = Mesh::default();
+            for i in 0..=N {
+                let t = i as f32 / (N as f32);
+                let color = color_at(t);
+                let x = lerp(rect.left()..=rect.right(), t);
+                mesh.colored_vertex(pos2(x, rect.top()), color);
+                mesh.colored_vertex(pos2(x, rect.bottom()), color);
+                if i < N {
+                    mesh.add_triangle(2 * i + 0, 2 * i + 1, 2 * i + 2);
+                    mesh.add_triangle(2 * i + 1, 2 * i + 2, 2 * i + 3);
+                }
+            }
+            ui.painter().add(Shape::mesh(mesh));
+        }
+
+        ui.painter().rect_stroke(rect, 0.0, visuals.bg_stroke); // outline
+
+        {
+            // Show where the slider is at:
+            let x = lerp(rect.left()..=rect.right(), *value);
+            let r = rect.height() / 4.0;
+            let picked_color = color_at(*value);
+            ui.painter().add(Shape::convex_polygon(
+                vec![
+                    pos2(x, rect.center().y),   // tip
+                    pos2(x + r, rect.bottom()), // right bottom
+                    pos2(x - r, rect.bottom()), // left bottom
+                ],
+                picked_color,
+                Stroke::new(visuals.fg_stroke.width, contrast_color(picked_color)),
+            ));
+        }
+    }
+
+    response
+}
+
+/// # Arguments
+/// * `x_value` - X axis, either saturation or value (0.0-1.0).
+/// * `y_value` - Y axis, either saturation or value (0.0-1.0).
+/// * `color_at` - A function that dictates how the mix of saturation and value will be displayed in the 2d slider.
+/// E.g.: `|x_value, y_value| HsvaGamma { h: 1.0, s: x_value, v: y_value, a: 1.0 }.into()` displays the colors as follows: top-left: white \[s: 0.0, v: 1.0], top-right: fully saturated color \[s: 1.0, v: 1.0], bottom-right: black \[s: 0.0, v: 1.0].
+///
+fn color_slider_2d(
+    ui: &mut Ui,
+    x_value: &mut f32,
+    y_value: &mut f32,
+    color_at: impl Fn(f32, f32) -> Color32,
+) -> Response {
+    let desired_size = Vec2::splat(ui.spacing().slider_width);
+    let (rect, response) = ui.allocate_at_least(desired_size, Sense::click_and_drag());
+
+    if let Some(mpos) = response.interact_pointer_pos() {
+        *x_value = remap_clamp(mpos.x, rect.left()..=rect.right(), 0.0..=1.0);
+        *y_value = remap_clamp(mpos.y, rect.bottom()..=rect.top(), 0.0..=1.0);
+    }
+
+    if ui.is_rect_visible(rect) {
+        let visuals = ui.style().interact(&response);
+        let mut mesh = Mesh::default();
+
+        for xi in 0..=N {
+            for yi in 0..=N {
+                let xt = xi as f32 / (N as f32);
+                let yt = yi as f32 / (N as f32);
+                let color = color_at(xt, yt);
+                let x = lerp(rect.left()..=rect.right(), xt);
+                let y = lerp(rect.bottom()..=rect.top(), yt);
+                mesh.colored_vertex(pos2(x, y), color);
+
+                if xi < N && yi < N {
+                    let x_offset = 1;
+                    let y_offset = N + 1;
+                    let tl = yi * y_offset + xi;
+                    mesh.add_triangle(tl, tl + x_offset, tl + y_offset);
+                    mesh.add_triangle(tl + x_offset, tl + y_offset, tl + y_offset + x_offset);
+                }
+            }
+        }
+        ui.painter().add(Shape::mesh(mesh)); // fill
+
+        ui.painter().rect_stroke(rect, 0.0, visuals.bg_stroke); // outline
+
+        // Show where the slider is at:
+        let x = lerp(rect.left()..=rect.right(), *x_value);
+        let y = lerp(rect.bottom()..=rect.top(), *y_value);
+        let picked_color = color_at(*x_value, *y_value);
+        ui.painter().add(epaint::CircleShape {
+            center: pos2(x, y),
+            radius: rect.width() / 12.0,
+            fill: picked_color,
+            stroke: Stroke::new(visuals.fg_stroke.width, contrast_color(picked_color)),
+        });
+    }
+
+    response
+}
+
+/// What options to show for alpha
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Alpha {
+    // Set alpha to 1.0, and show no option for it.
+    Opaque,
+    // Only show normal blend options for it.
+    OnlyBlend,
+    // Show both blend and additive options.
+    BlendOrAdditive,
+}
+
+fn color_text_ui(ui: &mut Ui, color: impl Into<Color32>, alpha: Alpha) {
+    let color = color.into();
+    ui.horizontal(|ui| {
+        let [r, g, b, a] = color.to_array();
+
+        if ui.button("📋").on_hover_text("Click to copy").clicked() {
+            if alpha == Alpha::Opaque {
+                ui.output_mut(|o| o.copied_text = format!("{}, {}, {}", r, g, b));
+            } else {
+                ui.output_mut(|o| o.copied_text = format!("{}, {}, {}, {}", r, g, b, a));
+            }
+        }
+
+        if alpha == Alpha::Opaque {
+            ui.label(format!("rgb({}, {}, {})", r, g, b))
+                .on_hover_text("Red Green Blue");
+        } else {
+            ui.label(format!("rgba({}, {}, {}, {})", r, g, b, a))
+                .on_hover_text("Red Green Blue with premultiplied Alpha");
+        }
+    });
+}
+
+fn color_picker_hsvag_2d(ui: &mut Ui, hsva: &mut HsvaGamma, alpha: Alpha) {
+    let current_color_size = vec2(ui.spacing().slider_width, ui.spacing().interact_size.y);
+    show_color(ui, *hsva, current_color_size).on_hover_text("Selected color");
+
+    color_text_ui(ui, *hsva, alpha);
+
+    if alpha == Alpha::BlendOrAdditive {
+        // We signal additive blending by storing a negative alpha (a bit ironic).
+        let a = &mut hsva.a;
+        let mut additive = *a < 0.0;
+        ui.horizontal(|ui| {
+            ui.label("Blending:");
+            ui.radio_value(&mut additive, false, "Normal");
+            ui.radio_value(&mut additive, true, "Additive");
+
+            if additive {
+                *a = -a.abs();
+            }
+
+            if !additive {
+                *a = a.abs();
+            }
+        });
+    }
+    let additive = hsva.a < 0.0;
+
+    let opaque = HsvaGamma { a: 1.0, ..*hsva };
+
+    if alpha == Alpha::Opaque {
+        hsva.a = 1.0;
+    } else {
+        let a = &mut hsva.a;
+
+        if alpha == Alpha::OnlyBlend {
+            if *a < 0.0 {
+                *a = 0.5; // was additive, but isn't allowed to be
+            }
+            color_slider_1d(ui, a, |a| HsvaGamma { a, ..opaque }.into()).on_hover_text("Alpha");
+        } else if !additive {
+            color_slider_1d(ui, a, |a| HsvaGamma { a, ..opaque }.into()).on_hover_text("Alpha");
+        }
+    }
+
+    let HsvaGamma { h, s, v, a: _ } = hsva;
+
+    color_slider_1d(ui, h, |h| {
+        HsvaGamma {
+            h,
+            s: 1.0,
+            v: 1.0,
+            a: 1.0,
+        }
+        .into()
+    })
+    .on_hover_text("Hue");
+
+    if false {
+        color_slider_1d(ui, s, |s| HsvaGamma { s, ..opaque }.into()).on_hover_text("Saturation");
+    }
+
+    if false {
+        color_slider_1d(ui, v, |v| HsvaGamma { v, ..opaque }.into()).on_hover_text("Value");
+    }
+
+    color_slider_2d(ui, s, v, |s, v| HsvaGamma { s, v, ..opaque }.into());
+}
+
+//// Shows a color picker where the user can change the given [`Hsva`] color.
+///
+/// Returns `true` on change.
+pub fn color_picker_hsva_2d(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> bool {
+    let mut hsvag = HsvaGamma::from(*hsva);
+    ui.vertical(|ui| {
+        color_picker_hsvag_2d(ui, &mut hsvag, alpha);
+    });
+    let new_hasva = Hsva::from(hsvag);
+    if *hsva == new_hasva {
+        false
+    } else {
+        *hsva = new_hasva;
+        true
+    }
+}
+
+/// Shows a color picker where the user can change the given [`Color32`] color.
+///
+/// Returns `true` on change.
+pub fn color_picker_color32(ui: &mut Ui, srgba: &mut Color32, alpha: Alpha) -> bool {
+    let mut hsva = color_cache_get(ui.ctx(), *srgba);
+    let changed = color_picker_hsva_2d(ui, &mut hsva, alpha);
+    *srgba = Color32::from(hsva);
+    color_cache_set(ui.ctx(), *srgba, hsva);
+    changed
+}
+
+pub fn color_edit_button_hsva(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> Response {
+    let popup_id = ui.auto_id_with("popup");
+    let open = ui.memory(|mem| mem.is_popup_open(popup_id));
+    let mut button_response = color_button(ui, (*hsva).into(), open);
+    if ui.style().explanation_tooltips {
+        button_response = button_response.on_hover_text("Click to edit color");
+    }
+
+    if button_response.clicked() {
+        ui.memory_mut(|mem| mem.toggle_popup(popup_id));
+    }
+
+    const COLOR_SLIDER_WIDTH: f32 = 210.0;
+
+    // TODO(emilk): make it easier to show a temporary popup that closes when you click outside it
+    if ui.memory(|mem| mem.is_popup_open(popup_id)) {
+        let area_response = Area::new(popup_id)
+            .order(Order::Foreground)
+            .fixed_pos(button_response.rect.max)
+            .constrain(true)
+            .show(ui.ctx(), |ui| {
+                ui.spacing_mut().slider_width = COLOR_SLIDER_WIDTH;
+                Frame::popup(ui.style()).show(ui, |ui| {
+                    if color_picker_hsva_2d(ui, hsva, alpha) {
+                        button_response.mark_changed();
+                    }
+                });
+            })
+            .response;
+
+        if !button_response.clicked()
+            && (ui.input(|i| i.key_pressed(Key::Escape)) || area_response.clicked_elsewhere())
+        {
+            ui.memory_mut(|mem| mem.close_popup());
+        }
+    }
+
+    button_response
+}
+
+/// Shows a button with the given color.
+/// If the user clicks the button, a full color picker is shown.
+pub fn color_edit_button_srgba(ui: &mut Ui, srgba: &mut Color32, alpha: Alpha) -> Response {
+    let mut hsva = color_cache_get(ui.ctx(), *srgba);
+    let response = color_edit_button_hsva(ui, &mut hsva, alpha);
+    *srgba = Color32::from(hsva);
+    color_cache_set(ui.ctx(), *srgba, hsva);
+    response
+}
+
+/// Shows a button with the given color.
+/// If the user clicks the button, a full color picker is shown.
+/// The given color is in `sRGB` space.
+pub fn color_edit_button_srgb(ui: &mut Ui, srgb: &mut [u8; 3]) -> Response {
+    let mut srgba = Color32::from_rgb(srgb[0], srgb[1], srgb[2]);
+    let response = color_edit_button_srgba(ui, &mut srgba, Alpha::Opaque);
+    srgb[0] = srgba[0];
+    srgb[1] = srgba[1];
+    srgb[2] = srgba[2];
+    response
+}
+
+/// Shows a button with the given color.
+/// If the user clicks the button, a full color picker is shown.
+pub fn color_edit_button_rgba(ui: &mut Ui, rgba: &mut Rgba, alpha: Alpha) -> Response {
+    let mut hsva = color_cache_get(ui.ctx(), *rgba);
+    let response = color_edit_button_hsva(ui, &mut hsva, alpha);
+    *rgba = Rgba::from(hsva);
+    color_cache_set(ui.ctx(), *rgba, hsva);
+    response
+}
+
+/// Shows a button with the given color.
+/// If the user clicks the button, a full color picker is shown.
+pub fn color_edit_button_rgb(ui: &mut Ui, rgb: &mut [f32; 3]) -> Response {
+    let mut rgba = Rgba::from_rgb(rgb[0], rgb[1], rgb[2]);
+    let response = color_edit_button_rgba(ui, &mut rgba, Alpha::Opaque);
+    rgb[0] = rgba[0];
+    rgb[1] = rgba[1];
+    rgb[2] = rgba[2];
+    response
+}
+
+// To ensure we keep hue slider when `srgba` is gray we store the full [`Hsva`] in a cache:
+fn color_cache_get(ctx: &Context, rgba: impl Into<Rgba>) -> Hsva {
+    let rgba = rgba.into();
+    use_color_cache(ctx, |cc| cc.get(&rgba).copied()).unwrap_or_else(|| Hsva::from(rgba))
+}
+
+// To ensure we keep hue slider when `srgba` is gray we store the full [`Hsva`] in a cache:
+fn color_cache_set(ctx: &Context, rgba: impl Into<Rgba>, hsva: Hsva) {
+    let rgba = rgba.into();
+    use_color_cache(ctx, |cc| cc.set(rgba, hsva));
+}
+
+// To ensure we keep hue slider when `srgba` is gray we store the full [`Hsva`] in a cache:
+fn use_color_cache<R>(ctx: &Context, f: impl FnOnce(&mut FixedCache<Rgba, Hsva>) -> R) -> R {
+    ctx.data_mut(|d| f(d.get_temp_mut_or_default(Id::null())))
+}
diff --git a/egui/crates/egui/src/widgets/drag_value.rs b/egui/crates/egui/src/widgets/drag_value.rs
new file mode 100644
index 0000000..0d33978
--- /dev/null
+++ b/egui/crates/egui/src/widgets/drag_value.rs
@@ -0,0 +1,662 @@
+#![allow(clippy::needless_pass_by_value)] // False positives with `impl ToString`
+
+use std::{cmp::Ordering, ops::RangeInclusive};
+
+use crate::*;
+
+// ----------------------------------------------------------------------------
+
+/// Same state for all [`DragValue`]s.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct MonoState {
+    last_dragged_id: Option<Id>,
+    last_dragged_value: Option<f64>,
+    /// For temporary edit of a [`DragValue`] value.
+    /// Couples with the current focus id.
+    edit_string: Option<String>,
+}
+
+impl MonoState {
+    pub(crate) fn end_frame(&mut self, input: &InputState) {
+        if input.pointer.any_pressed() || input.pointer.any_released() {
+            self.last_dragged_id = None;
+            self.last_dragged_value = None;
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+type NumFormatter<'a> = Box<dyn 'a + Fn(f64, RangeInclusive<usize>) -> String>;
+type NumParser<'a> = Box<dyn 'a + Fn(&str) -> Option<f64>>;
+
+// ----------------------------------------------------------------------------
+
+/// Combined into one function (rather than two) to make it easier
+/// for the borrow checker.
+type GetSetValue<'a> = Box<dyn 'a + FnMut(Option<f64>) -> f64>;
+
+fn get(get_set_value: &mut GetSetValue<'_>) -> f64 {
+    (get_set_value)(None)
+}
+
+fn set(get_set_value: &mut GetSetValue<'_>, value: f64) {
+    (get_set_value)(Some(value));
+}
+
+/// A numeric value that you can change by dragging the number. More compact than a [`Slider`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # let mut my_f32: f32 = 0.0;
+/// ui.add(egui::DragValue::new(&mut my_f32).speed(0.1));
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct DragValue<'a> {
+    get_set_value: GetSetValue<'a>,
+    speed: f64,
+    prefix: String,
+    suffix: String,
+    clamp_range: RangeInclusive<f64>,
+    min_decimals: usize,
+    max_decimals: Option<usize>,
+    custom_formatter: Option<NumFormatter<'a>>,
+    custom_parser: Option<NumParser<'a>>,
+}
+
+impl<'a> DragValue<'a> {
+    pub fn new<Num: emath::Numeric>(value: &'a mut Num) -> Self {
+        let slf = Self::from_get_set(move |v: Option<f64>| {
+            if let Some(v) = v {
+                *value = Num::from_f64(v);
+            }
+            value.to_f64()
+        });
+
+        if Num::INTEGRAL {
+            slf.max_decimals(0)
+                .clamp_range(Num::MIN..=Num::MAX)
+                .speed(0.25)
+        } else {
+            slf
+        }
+    }
+
+    pub fn from_get_set(get_set_value: impl 'a + FnMut(Option<f64>) -> f64) -> Self {
+        Self {
+            get_set_value: Box::new(get_set_value),
+            speed: 1.0,
+            prefix: Default::default(),
+            suffix: Default::default(),
+            clamp_range: f64::NEG_INFINITY..=f64::INFINITY,
+            min_decimals: 0,
+            max_decimals: None,
+            custom_formatter: None,
+            custom_parser: None,
+        }
+    }
+
+    /// How much the value changes when dragged one point (logical pixel).
+    pub fn speed(mut self, speed: impl Into<f64>) -> Self {
+        self.speed = speed.into();
+        self
+    }
+
+    /// Clamp incoming and outgoing values to this range.
+    pub fn clamp_range<Num: emath::Numeric>(mut self, clamp_range: RangeInclusive<Num>) -> Self {
+        self.clamp_range = clamp_range.start().to_f64()..=clamp_range.end().to_f64();
+        self
+    }
+
+    /// Show a prefix before the number, e.g. "x: "
+    pub fn prefix(mut self, prefix: impl ToString) -> Self {
+        self.prefix = prefix.to_string();
+        self
+    }
+
+    /// Add a suffix to the number, this can be e.g. a unit ("°" or " m")
+    pub fn suffix(mut self, suffix: impl ToString) -> Self {
+        self.suffix = suffix.to_string();
+        self
+    }
+
+    // TODO(emilk): we should also have a "min precision".
+    /// Set a minimum number of decimals to display.
+    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
+    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
+    pub fn min_decimals(mut self, min_decimals: usize) -> Self {
+        self.min_decimals = min_decimals;
+        self
+    }
+
+    // TODO(emilk): we should also have a "max precision".
+    /// Set a maximum number of decimals to display.
+    /// Values will also be rounded to this number of decimals.
+    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
+    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
+    pub fn max_decimals(mut self, max_decimals: usize) -> Self {
+        self.max_decimals = Some(max_decimals);
+        self
+    }
+
+    pub fn max_decimals_opt(mut self, max_decimals: Option<usize>) -> Self {
+        self.max_decimals = max_decimals;
+        self
+    }
+
+    /// Set an exact number of decimals to display.
+    /// Values will also be rounded to this number of decimals.
+    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
+    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
+    pub fn fixed_decimals(mut self, num_decimals: usize) -> Self {
+        self.min_decimals = num_decimals;
+        self.max_decimals = Some(num_decimals);
+        self
+    }
+
+    /// Set custom formatter defining how numbers are converted into text.
+    ///
+    /// A custom formatter takes a `f64` for the numeric value and a `RangeInclusive<usize>` representing
+    /// the decimal range i.e. minimum and maximum number of decimal places shown.
+    ///
+    /// See also: [`DragValue::custom_parser`]
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::DragValue::new(&mut my_i32)
+    ///     .clamp_range(0..=((60 * 60 * 24) - 1))
+    ///     .custom_formatter(|n, _| {
+    ///         let n = n as i32;
+    ///         let hours = n / (60 * 60);
+    ///         let mins = (n / 60) % 60;
+    ///         let secs = n % 60;
+    ///         format!("{hours:02}:{mins:02}:{secs:02}")
+    ///     })
+    ///     .custom_parser(|s| {
+    ///         let parts: Vec<&str> = s.split(':').collect();
+    ///         if parts.len() == 3 {
+    ///             parts[0].parse::<i32>().and_then(|h| {
+    ///                 parts[1].parse::<i32>().and_then(|m| {
+    ///                     parts[2].parse::<i32>().map(|s| {
+    ///                         ((h * 60 * 60) + (m * 60) + s) as f64
+    ///                     })
+    ///                 })
+    ///             })
+    ///             .ok()
+    ///         } else {
+    ///             None
+    ///         }
+    ///     }));
+    /// # });
+    /// ```
+    pub fn custom_formatter(
+        mut self,
+        formatter: impl 'a + Fn(f64, RangeInclusive<usize>) -> String,
+    ) -> Self {
+        self.custom_formatter = Some(Box::new(formatter));
+        self
+    }
+
+    /// Set custom parser defining how the text input is parsed into a number.
+    ///
+    /// A custom parser takes an `&str` to parse into a number and returns a `f64` if it was successfully parsed
+    /// or `None` otherwise.
+    ///
+    /// See also: [`DragValue::custom_formatter`]
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::DragValue::new(&mut my_i32)
+    ///     .clamp_range(0..=((60 * 60 * 24) - 1))
+    ///     .custom_formatter(|n, _| {
+    ///         let n = n as i32;
+    ///         let hours = n / (60 * 60);
+    ///         let mins = (n / 60) % 60;
+    ///         let secs = n % 60;
+    ///         format!("{hours:02}:{mins:02}:{secs:02}")
+    ///     })
+    ///     .custom_parser(|s| {
+    ///         let parts: Vec<&str> = s.split(':').collect();
+    ///         if parts.len() == 3 {
+    ///             parts[0].parse::<i32>().and_then(|h| {
+    ///                 parts[1].parse::<i32>().and_then(|m| {
+    ///                     parts[2].parse::<i32>().map(|s| {
+    ///                         ((h * 60 * 60) + (m * 60) + s) as f64
+    ///                     })
+    ///                 })
+    ///             })
+    ///             .ok()
+    ///         } else {
+    ///             None
+    ///         }
+    ///     }));
+    /// # });
+    /// ```
+    pub fn custom_parser(mut self, parser: impl 'a + Fn(&str) -> Option<f64>) -> Self {
+        self.custom_parser = Some(Box::new(parser));
+        self
+    }
+
+    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as binary integers. Floating point
+    /// numbers are *not* supported.
+    ///
+    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
+    /// prefixed with additional 0s to match `min_width`.
+    ///
+    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
+    /// they will be prefixed with a '-' sign.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min_width` is 0.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::DragValue::new(&mut my_i32).binary(64, false));
+    /// # });
+    /// ```
+    pub fn binary(self, min_width: usize, twos_complement: bool) -> Self {
+        assert!(
+            min_width > 0,
+            "DragValue::binary: `min_width` must be greater than 0"
+        );
+        if twos_complement {
+            self.custom_formatter(move |n, _| format!("{:0>min_width$b}", n as i64))
+        } else {
+            self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$b}", n.abs() as i64)
+            })
+        }
+        .custom_parser(|s| i64::from_str_radix(s, 2).map(|n| n as f64).ok())
+    }
+
+    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as octal integers. Floating point
+    /// numbers are *not* supported.
+    ///
+    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
+    /// prefixed with additional 0s to match `min_width`.
+    ///
+    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
+    /// they will be prefixed with a '-' sign.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min_width` is 0.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::DragValue::new(&mut my_i32).octal(22, false));
+    /// # });
+    /// ```
+    pub fn octal(self, min_width: usize, twos_complement: bool) -> Self {
+        assert!(
+            min_width > 0,
+            "DragValue::octal: `min_width` must be greater than 0"
+        );
+        if twos_complement {
+            self.custom_formatter(move |n, _| format!("{:0>min_width$o}", n as i64))
+        } else {
+            self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$o}", n.abs() as i64)
+            })
+        }
+        .custom_parser(|s| i64::from_str_radix(s, 8).map(|n| n as f64).ok())
+    }
+
+    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as hexadecimal integers. Floating point
+    /// numbers are *not* supported.
+    ///
+    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
+    /// prefixed with additional 0s to match `min_width`.
+    ///
+    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
+    /// they will be prefixed with a '-' sign.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min_width` is 0.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::DragValue::new(&mut my_i32).hexadecimal(16, false, true));
+    /// # });
+    /// ```
+    pub fn hexadecimal(self, min_width: usize, twos_complement: bool, upper: bool) -> Self {
+        assert!(
+            min_width > 0,
+            "DragValue::hexadecimal: `min_width` must be greater than 0"
+        );
+        match (twos_complement, upper) {
+            (true, true) => {
+                self.custom_formatter(move |n, _| format!("{:0>min_width$X}", n as i64))
+            }
+            (true, false) => {
+                self.custom_formatter(move |n, _| format!("{:0>min_width$x}", n as i64))
+            }
+            (false, true) => self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$X}", n.abs() as i64)
+            }),
+            (false, false) => self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$x}", n.abs() as i64)
+            }),
+        }
+        .custom_parser(|s| i64::from_str_radix(s, 16).map(|n| n as f64).ok())
+    }
+}
+
+impl<'a> Widget for DragValue<'a> {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Self {
+            mut get_set_value,
+            speed,
+            clamp_range,
+            prefix,
+            suffix,
+            min_decimals,
+            max_decimals,
+            custom_formatter,
+            custom_parser,
+        } = self;
+
+        let shift = ui.input(|i| i.modifiers.shift_only());
+        // The widget has the same ID whether it's in edit or button mode.
+        let id = ui.next_auto_id();
+        let is_slow_speed = shift && ui.memory(|mem| mem.is_being_dragged(id));
+
+        // The following ensures that when a `DragValue` receives focus,
+        // it is immediately rendered in edit mode, rather than being rendered
+        // in button mode for just one frame. This is important for
+        // screen readers.
+        let is_kb_editing = ui.memory_mut(|mem| {
+            mem.interested_in_focus(id);
+            let is_kb_editing = mem.has_focus(id);
+            if mem.gained_focus(id) {
+                mem.drag_value.edit_string = None;
+            }
+            is_kb_editing
+        });
+
+        let old_value = get(&mut get_set_value);
+        let mut value = old_value;
+        let aim_rad = ui.input(|i| i.aim_radius() as f64);
+
+        let auto_decimals = (aim_rad / speed.abs()).log10().ceil().clamp(0.0, 15.0) as usize;
+        let auto_decimals = auto_decimals + is_slow_speed as usize;
+        let max_decimals = max_decimals.unwrap_or(auto_decimals + 2);
+        let auto_decimals = auto_decimals.clamp(min_decimals, max_decimals);
+
+        let change = ui.input_mut(|input| {
+            let mut change = 0.0;
+
+            if is_kb_editing {
+                // This deliberately doesn't listen for left and right arrow keys,
+                // because when editing, these are used to move the caret.
+                // This behavior is consistent with other editable spinner/stepper
+                // implementations, such as Chromium's (for HTML5 number input).
+                // It is also normal for such controls to go directly into edit mode
+                // when they receive keyboard focus, and some screen readers
+                // assume this behavior, so having a separate mode for incrementing
+                // and decrementing, that supports all arrow keys, would be
+                // problematic.
+                change += input.count_and_consume_key(Modifiers::NONE, Key::ArrowUp) as f64
+                    - input.count_and_consume_key(Modifiers::NONE, Key::ArrowDown) as f64;
+            }
+
+            #[cfg(feature = "accesskit")]
+            {
+                use accesskit::Action;
+                change += input.num_accesskit_action_requests(id, Action::Increment) as f64
+                    - input.num_accesskit_action_requests(id, Action::Decrement) as f64;
+            }
+
+            change
+        });
+
+        #[cfg(feature = "accesskit")]
+        {
+            use accesskit::{Action, ActionData};
+            ui.input(|input| {
+                for request in input.accesskit_action_requests(id, Action::SetValue) {
+                    if let Some(ActionData::NumericValue(new_value)) = request.data {
+                        value = new_value;
+                    }
+                }
+            });
+        }
+
+        if change != 0.0 {
+            value += speed * change;
+            value = emath::round_to_decimals(value, auto_decimals);
+        }
+
+        value = clamp_to_range(value, clamp_range.clone());
+        if old_value != value {
+            set(&mut get_set_value, value);
+            ui.memory_mut(|mem| mem.drag_value.edit_string = None);
+        }
+
+        let value_text = match custom_formatter {
+            Some(custom_formatter) => custom_formatter(value, auto_decimals..=max_decimals),
+            None => {
+                if value == 0.0 {
+                    "0".to_owned()
+                } else {
+                    emath::format_with_decimals_in_range(value, auto_decimals..=max_decimals)
+                }
+            }
+        };
+
+        let text_style = ui.style().drag_value_text_style.clone();
+
+        // some clones below are redundant if AccessKit is disabled
+        #[allow(clippy::redundant_clone)]
+        let mut response = if is_kb_editing {
+            let mut value_text = ui
+                .memory_mut(|mem| mem.drag_value.edit_string.take())
+                .unwrap_or_else(|| value_text.clone());
+            let response = ui.add(
+                TextEdit::singleline(&mut value_text)
+                    .clip_text(false)
+                    .horizontal_align(ui.layout().horizontal_align())
+                    .vertical_align(ui.layout().vertical_align())
+                    .margin(ui.spacing().button_padding)
+                    .min_size(ui.spacing().interact_size)
+                    .id(id)
+                    .desired_width(ui.spacing().interact_size.x)
+                    .font(text_style),
+            );
+            // Only update the value when the user presses enter, or clicks elsewhere. NOT every frame.
+            // See https://github.com/emilk/egui/issues/2687
+            if response.lost_focus() {
+                let parsed_value = match custom_parser {
+                    Some(parser) => parser(&value_text),
+                    None => value_text.parse().ok(),
+                };
+                if let Some(parsed_value) = parsed_value {
+                    let parsed_value = clamp_to_range(parsed_value, clamp_range.clone());
+                    set(&mut get_set_value, parsed_value);
+                }
+            }
+            ui.memory_mut(|mem| mem.drag_value.edit_string = Some(value_text));
+            response
+        } else {
+            let button = Button::new(
+                RichText::new(format!("{}{}{}", prefix, value_text.clone(), suffix))
+                    .text_style(text_style),
+            )
+            .wrap(false)
+            .sense(Sense::click_and_drag())
+            .min_size(ui.spacing().interact_size); // TODO(emilk): find some more generic solution to `min_size`
+
+            let response = ui.add(button);
+            let mut response = response.on_hover_cursor(CursorIcon::ResizeHorizontal);
+
+            if ui.style().explanation_tooltips {
+                response = response .on_hover_text(format!(
+                    "{}{}{}\nDrag to edit or click to enter a value.\nPress 'Shift' while dragging for better control.",
+                    prefix,
+                    value as f32, // Show full precision value on-hover. TODO(emilk): figure out f64 vs f32
+                    suffix
+                ));
+            }
+
+            if response.clicked() {
+                ui.memory_mut(|mem| {
+                    mem.drag_value.edit_string = None;
+                    mem.request_focus(id);
+                });
+                let mut state = TextEdit::load_state(ui.ctx(), id).unwrap_or_default();
+                state.set_ccursor_range(Some(text::CCursorRange::two(
+                    epaint::text::cursor::CCursor::default(),
+                    epaint::text::cursor::CCursor::new(value_text.chars().count()),
+                )));
+                state.store(ui.ctx(), response.id);
+            } else if response.dragged() {
+                ui.ctx().set_cursor_icon(CursorIcon::ResizeHorizontal);
+
+                let mdelta = response.drag_delta();
+                let delta_points = mdelta.x - mdelta.y; // Increase to the right and up
+
+                let speed = if is_slow_speed { speed / 10.0 } else { speed };
+
+                let delta_value = delta_points as f64 * speed;
+
+                if delta_value != 0.0 {
+                    let mut drag_state = ui.memory_mut(|mem| std::mem::take(&mut mem.drag_value));
+
+                    // Since we round the value being dragged, we need to store the full precision value in memory:
+                    let stored_value = (drag_state.last_dragged_id == Some(response.id))
+                        .then_some(drag_state.last_dragged_value)
+                        .flatten();
+                    let stored_value = stored_value.unwrap_or(value);
+                    let stored_value = stored_value + delta_value;
+
+                    let aim_delta = aim_rad * speed;
+                    let rounded_new_value = emath::smart_aim::best_in_range_f64(
+                        stored_value - aim_delta,
+                        stored_value + aim_delta,
+                    );
+                    let rounded_new_value =
+                        emath::round_to_decimals(rounded_new_value, auto_decimals);
+                    let rounded_new_value = clamp_to_range(rounded_new_value, clamp_range.clone());
+                    set(&mut get_set_value, rounded_new_value);
+
+                    drag_state.last_dragged_id = Some(response.id);
+                    drag_state.last_dragged_value = Some(stored_value);
+                    ui.memory_mut(|mem| mem.drag_value = drag_state);
+                }
+            }
+
+            response
+        };
+
+        response.changed = get(&mut get_set_value) != old_value;
+
+        response.widget_info(|| WidgetInfo::drag_value(value));
+
+        #[cfg(feature = "accesskit")]
+        ui.ctx().accesskit_node_builder(response.id, |builder| {
+            use accesskit::Action;
+            // If either end of the range is unbounded, it's better
+            // to leave the corresponding AccessKit field set to None,
+            // to allow for platform-specific default behavior.
+            if clamp_range.start().is_finite() {
+                builder.set_min_numeric_value(*clamp_range.start());
+            }
+            if clamp_range.end().is_finite() {
+                builder.set_max_numeric_value(*clamp_range.end());
+            }
+            builder.set_numeric_value_step(speed);
+            builder.add_action(Action::SetValue);
+            if value < *clamp_range.end() {
+                builder.add_action(Action::Increment);
+            }
+            if value > *clamp_range.start() {
+                builder.add_action(Action::Decrement);
+            }
+            // The name field is set to the current value by the button,
+            // but we don't want it set that way on this widget type.
+            builder.clear_name();
+            // Always expose the value as a string. This makes the widget
+            // more stable to accessibility users as it switches
+            // between edit and button modes. This is particularly important
+            // for VoiceOver on macOS; if the value is not exposed as a string
+            // when the widget is in button mode, then VoiceOver speaks
+            // the value (or a percentage if the widget has a clamp range)
+            // when the widget loses focus, overriding the announcement
+            // of the newly focused widget. This is certainly a VoiceOver bug,
+            // but it's good to make our software work as well as possible
+            // with existing assistive technology. However, if the widget
+            // has a prefix and/or suffix, expose those when in button mode,
+            // just as they're exposed on the screen. This triggers the
+            // VoiceOver bug just described, but exposing all information
+            // is more important, and at least we can avoid the bug
+            // for instances of the widget with no prefix or suffix.
+            //
+            // The value is exposed as a string by the text edit widget
+            // when in edit mode.
+            if !is_kb_editing {
+                let value_text = format!("{}{}{}", prefix, value_text, suffix);
+                builder.set_value(value_text);
+            }
+        });
+
+        response
+    }
+}
+
+fn clamp_to_range(x: f64, range: RangeInclusive<f64>) -> f64 {
+    let (mut min, mut max) = (*range.start(), *range.end());
+
+    if min.total_cmp(&max) == Ordering::Greater {
+        (min, max) = (max, min);
+    }
+
+    match x.total_cmp(&min) {
+        Ordering::Less | Ordering::Equal => min,
+        Ordering::Greater => match x.total_cmp(&max) {
+            Ordering::Greater | Ordering::Equal => max,
+            Ordering::Less => x,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::clamp_to_range;
+
+    macro_rules! total_assert_eq {
+        ($a:expr, $b:expr) => {
+            assert!(
+                matches!($a.total_cmp(&$b), std::cmp::Ordering::Equal),
+                "{} != {}",
+                $a,
+                $b
+            );
+        };
+    }
+
+    #[test]
+    fn test_total_cmp_clamp_to_range() {
+        total_assert_eq!(0.0_f64, clamp_to_range(-0.0, 0.0..=f64::MAX));
+        total_assert_eq!(-0.0_f64, clamp_to_range(0.0, -1.0..=-0.0));
+        total_assert_eq!(-1.0_f64, clamp_to_range(-25.0, -1.0..=1.0));
+        total_assert_eq!(5.0_f64, clamp_to_range(5.0, -1.0..=10.0));
+        total_assert_eq!(15.0_f64, clamp_to_range(25.0, -1.0..=15.0));
+        total_assert_eq!(1.0_f64, clamp_to_range(1.0, 1.0..=10.0));
+        total_assert_eq!(10.0_f64, clamp_to_range(10.0, 1.0..=10.0));
+        total_assert_eq!(5.0_f64, clamp_to_range(5.0, 10.0..=1.0));
+        total_assert_eq!(5.0_f64, clamp_to_range(15.0, 5.0..=1.0));
+        total_assert_eq!(1.0_f64, clamp_to_range(-5.0, 5.0..=1.0));
+    }
+}
diff --git a/egui/crates/egui/src/widgets/hyperlink.rs b/egui/crates/egui/src/widgets/hyperlink.rs
new file mode 100644
index 0000000..361b21b
--- /dev/null
+++ b/egui/crates/egui/src/widgets/hyperlink.rs
@@ -0,0 +1,131 @@
+use crate::*;
+
+/// Clickable text, that looks like a hyperlink.
+///
+/// To link to a web page, use [`Hyperlink`], [`Ui::hyperlink`] or [`Ui::hyperlink_to`].
+///
+/// See also [`Ui::link`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// // These are equivalent:
+/// if ui.link("Documentation").clicked() {
+///     // …
+/// }
+///
+/// if ui.add(egui::Link::new("Documentation")).clicked() {
+///     // …
+/// }
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Link {
+    text: WidgetText,
+}
+
+impl Link {
+    pub fn new(text: impl Into<WidgetText>) -> Self {
+        Self { text: text.into() }
+    }
+}
+
+impl Widget for Link {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Link { text } = self;
+        let label = Label::new(text).sense(Sense::click());
+
+        let (pos, text_galley, response) = label.layout_in_ui(ui);
+        response.widget_info(|| WidgetInfo::labeled(WidgetType::Link, text_galley.text()));
+
+        if response.hovered() {
+            ui.ctx().set_cursor_icon(CursorIcon::PointingHand);
+        }
+
+        if ui.is_rect_visible(response.rect) {
+            let color = ui.visuals().hyperlink_color;
+            let visuals = ui.style().interact(&response);
+
+            let underline = if response.hovered() || response.has_focus() {
+                Stroke::new(visuals.fg_stroke.width, color)
+            } else {
+                Stroke::NONE
+            };
+
+            ui.painter().add(epaint::TextShape {
+                pos,
+                galley: text_galley.galley,
+                override_text_color: Some(color),
+                underline,
+                angle: 0.0,
+            });
+        }
+
+        response
+    }
+}
+
+/// A clickable hyperlink, e.g. to `"https://github.com/emilk/egui"`.
+///
+/// See also [`Ui::hyperlink`] and [`Ui::hyperlink_to`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// // These are equivalent:
+/// ui.hyperlink("https://github.com/emilk/egui");
+/// ui.add(egui::Hyperlink::new("https://github.com/emilk/egui"));
+///
+/// // These are equivalent:
+/// ui.hyperlink_to("My favorite repo", "https://github.com/emilk/egui");
+/// ui.add(egui::Hyperlink::from_label_and_url("My favorite repo", "https://github.com/emilk/egui"));
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Hyperlink {
+    url: String,
+    text: WidgetText,
+}
+
+impl Hyperlink {
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn new(url: impl ToString) -> Self {
+        let url = url.to_string();
+        Self {
+            url: url.clone(),
+            text: url.into(),
+        }
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn from_label_and_url(text: impl Into<WidgetText>, url: impl ToString) -> Self {
+        Self {
+            url: url.to_string(),
+            text: text.into(),
+        }
+    }
+}
+
+impl Widget for Hyperlink {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Self { url, text } = self;
+
+        let response = ui.add(Link::new(text));
+        if response.clicked() {
+            let modifiers = ui.ctx().input(|i| i.modifiers);
+            ui.ctx().output_mut(|o| {
+                o.open_url = Some(crate::output::OpenUrl {
+                    url: url.clone(),
+                    new_tab: modifiers.any(),
+                });
+            });
+        }
+        if response.middle_clicked() {
+            ui.ctx().output_mut(|o| {
+                o.open_url = Some(crate::output::OpenUrl {
+                    url: url.clone(),
+                    new_tab: true,
+                });
+            });
+        }
+        response.on_hover_text(url)
+    }
+}
diff --git a/egui/crates/egui/src/widgets/image.rs b/egui/crates/egui/src/widgets/image.rs
new file mode 100644
index 0000000..eaf4584
--- /dev/null
+++ b/egui/crates/egui/src/widgets/image.rs
@@ -0,0 +1,141 @@
+use crate::*;
+use emath::Rot2;
+
+/// An widget to show an image of a given size.
+///
+/// In order to display an image you must first acquire a [`TextureHandle`].
+/// This is best done with [`egui_extras::RetainedImage`](https://docs.rs/egui_extras/latest/egui_extras/image/struct.RetainedImage.html) or [`Context::load_texture`].
+///
+/// ```
+/// struct MyImage {
+///     texture: Option<egui::TextureHandle>,
+/// }
+///
+/// impl MyImage {
+///     fn ui(&mut self, ui: &mut egui::Ui) {
+///         let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+///             // Load the texture only once.
+///             ui.ctx().load_texture(
+///                 "my-image",
+///                 egui::ColorImage::example(),
+///                 Default::default()
+///             )
+///         });
+///
+///         // Show the image:
+///         ui.add(egui::Image::new(texture, texture.size_vec2()));
+///
+///         // Shorter version:
+///         ui.image(texture, texture.size_vec2());
+///     }
+/// }
+/// ```
+///
+/// Se also [`crate::Ui::image`] and [`crate::ImageButton`].
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+#[derive(Clone, Copy, Debug)]
+pub struct Image {
+    texture_id: TextureId,
+    uv: Rect,
+    size: Vec2,
+    bg_fill: Color32,
+    tint: Color32,
+    sense: Sense,
+    rotation: Option<(Rot2, Vec2)>,
+}
+
+impl Image {
+    pub fn new(texture_id: impl Into<TextureId>, size: impl Into<Vec2>) -> Self {
+        Self {
+            texture_id: texture_id.into(),
+            uv: Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
+            size: size.into(),
+            bg_fill: Default::default(),
+            tint: Color32::WHITE,
+            sense: Sense::hover(),
+            rotation: None,
+        }
+    }
+
+    /// Select UV range. Default is (0,0) in top-left, (1,1) bottom right.
+    pub fn uv(mut self, uv: impl Into<Rect>) -> Self {
+        self.uv = uv.into();
+        self
+    }
+
+    /// A solid color to put behind the image. Useful for transparent images.
+    pub fn bg_fill(mut self, bg_fill: impl Into<Color32>) -> Self {
+        self.bg_fill = bg_fill.into();
+        self
+    }
+
+    /// Multiply image color with this. Default is WHITE (no tint).
+    pub fn tint(mut self, tint: impl Into<Color32>) -> Self {
+        self.tint = tint.into();
+        self
+    }
+
+    /// Make the image respond to clicks and/or drags.
+    ///
+    /// Consider using [`ImageButton`] instead, for an on-hover effect.
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = sense;
+        self
+    }
+
+    /// Rotate the image about an origin by some angle
+    ///
+    /// Positive angle is clockwise.
+    /// Origin is a vector in normalized UV space ((0,0) in top-left, (1,1) bottom right).
+    ///
+    /// To rotate about the center you can pass `Vec2::splat(0.5)` as the origin.
+    pub fn rotate(mut self, angle: f32, origin: Vec2) -> Self {
+        self.rotation = Some((Rot2::from_angle(angle), origin));
+        self
+    }
+}
+
+impl Image {
+    pub fn size(&self) -> Vec2 {
+        self.size
+    }
+
+    pub fn paint_at(&self, ui: &mut Ui, rect: Rect) {
+        if ui.is_rect_visible(rect) {
+            use epaint::*;
+            let Self {
+                texture_id,
+                uv,
+                size,
+                bg_fill,
+                tint,
+                sense: _,
+                rotation,
+            } = self;
+
+            if *bg_fill != Default::default() {
+                let mut mesh = Mesh::default();
+                mesh.add_colored_rect(rect, *bg_fill);
+                ui.painter().add(Shape::mesh(mesh));
+            }
+
+            {
+                // TODO(emilk): builder pattern for Mesh
+                let mut mesh = Mesh::with_texture(*texture_id);
+                mesh.add_rect_with_uv(rect, *uv, *tint);
+                if let Some((rot, origin)) = rotation {
+                    mesh.rotate(*rot, rect.min + *origin * *size);
+                }
+                ui.painter().add(Shape::mesh(mesh));
+            }
+        }
+    }
+}
+
+impl Widget for Image {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let (rect, response) = ui.allocate_exact_size(self.size, self.sense);
+        self.paint_at(ui, rect);
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/label.rs b/egui/crates/egui/src/widgets/label.rs
new file mode 100644
index 0000000..3e387fc
--- /dev/null
+++ b/egui/crates/egui/src/widgets/label.rs
@@ -0,0 +1,199 @@
+use crate::{widget_text::WidgetTextGalley, *};
+
+/// Static text.
+///
+/// Usually it is more convenient to use [`Ui::label`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// ui.label("Equivalent");
+/// ui.add(egui::Label::new("Equivalent"));
+/// ui.add(egui::Label::new("With Options").wrap(false));
+/// ui.label(egui::RichText::new("With formatting").underline());
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Label {
+    text: WidgetText,
+    wrap: Option<bool>,
+    sense: Option<Sense>,
+}
+
+impl Label {
+    pub fn new(text: impl Into<WidgetText>) -> Self {
+        Self {
+            text: text.into(),
+            wrap: None,
+            sense: None,
+        }
+    }
+
+    pub fn text(&self) -> &str {
+        self.text.text()
+    }
+
+    /// If `true`, the text will wrap to stay within the max width of the [`Ui`].
+    ///
+    /// By default [`Self::wrap`] will be `true` in vertical layouts
+    /// and horizontal layouts with wrapping,
+    /// and `false` on non-wrapping horizontal layouts.
+    ///
+    /// Note that any `\n` in the text will always produce a new line.
+    ///
+    /// You can also use [`crate::Style::wrap`].
+    #[inline]
+    pub fn wrap(mut self, wrap: bool) -> Self {
+        self.wrap = Some(wrap);
+        self
+    }
+
+    /// Make the label respond to clicks and/or drags.
+    ///
+    /// By default, a label is inert and does not respond to click or drags.
+    /// By calling this you can turn the label into a button of sorts.
+    /// This will also give the label the hover-effect of a button, but without the frame.
+    ///
+    /// ```
+    /// # use egui::{Label, Sense};
+    /// # egui::__run_test_ui(|ui| {
+    /// if ui.add(Label::new("click me").sense(Sense::click())).clicked() {
+    ///     /* … */
+    /// }
+    /// # });
+    /// ```
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = Some(sense);
+        self
+    }
+}
+
+impl Label {
+    /// Do layout and position the galley in the ui, without painting it or adding widget info.
+    pub fn layout_in_ui(self, ui: &mut Ui) -> (Pos2, WidgetTextGalley, Response) {
+        let sense = self.sense.unwrap_or_else(|| {
+            // We only want to focus labels if the screen reader is on.
+            if ui.memory(|mem| mem.options.screen_reader) {
+                Sense::focusable_noninteractive()
+            } else {
+                Sense::hover()
+            }
+        });
+        if let WidgetText::Galley(galley) = self.text {
+            // If the user said "use this specific galley", then just use it:
+            let (rect, response) = ui.allocate_exact_size(galley.size(), sense);
+            let pos = match galley.job.halign {
+                Align::LEFT => rect.left_top(),
+                Align::Center => rect.center_top(),
+                Align::RIGHT => rect.right_top(),
+            };
+            let text_galley = WidgetTextGalley {
+                galley,
+                galley_has_color: true,
+            };
+            return (pos, text_galley, response);
+        }
+
+        let valign = ui.layout().vertical_align();
+        let mut text_job = self
+            .text
+            .into_text_job(ui.style(), FontSelection::Default, valign);
+
+        let should_wrap = self.wrap.unwrap_or_else(|| ui.wrap_text());
+        let available_width = ui.available_width();
+
+        if should_wrap
+            && ui.layout().main_dir() == Direction::LeftToRight
+            && ui.layout().main_wrap()
+            && available_width.is_finite()
+        {
+            // On a wrapping horizontal layout we want text to start after the previous widget,
+            // then continue on the line below! This will take some extra work:
+
+            let cursor = ui.cursor();
+            let first_row_indentation = available_width - ui.available_size_before_wrap().x;
+            egui_assert!(first_row_indentation.is_finite());
+
+            text_job.job.wrap.max_width = available_width;
+            text_job.job.first_row_min_height = cursor.height();
+            text_job.job.halign = Align::Min;
+            text_job.job.justify = false;
+            if let Some(first_section) = text_job.job.sections.first_mut() {
+                first_section.leading_space = first_row_indentation;
+            }
+            let text_galley = ui.fonts(|f| text_job.into_galley(f));
+
+            let pos = pos2(ui.max_rect().left(), ui.cursor().top());
+            assert!(
+                !text_galley.galley.rows.is_empty(),
+                "Galleys are never empty"
+            );
+            // collect a response from many rows:
+            let rect = text_galley.galley.rows[0]
+                .rect
+                .translate(vec2(pos.x, pos.y));
+            let mut response = ui.allocate_rect(rect, sense);
+            for row in text_galley.galley.rows.iter().skip(1) {
+                let rect = row.rect.translate(vec2(pos.x, pos.y));
+                response |= ui.allocate_rect(rect, sense);
+            }
+            (pos, text_galley, response)
+        } else {
+            if should_wrap {
+                text_job.job.wrap.max_width = available_width;
+            } else {
+                text_job.job.wrap.max_width = f32::INFINITY;
+            };
+
+            if ui.is_grid() {
+                // TODO(emilk): remove special Grid hacks like these
+                text_job.job.halign = Align::LEFT;
+                text_job.job.justify = false;
+            } else {
+                text_job.job.halign = ui.layout().horizontal_placement();
+                text_job.job.justify = ui.layout().horizontal_justify();
+            };
+
+            let text_galley = ui.fonts(|f| text_job.into_galley(f));
+            let (rect, response) = ui.allocate_exact_size(text_galley.size(), sense);
+            let pos = match text_galley.galley.job.halign {
+                Align::LEFT => rect.left_top(),
+                Align::Center => rect.center_top(),
+                Align::RIGHT => rect.right_top(),
+            };
+            (pos, text_galley, response)
+        }
+    }
+}
+
+impl Widget for Label {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let (pos, text_galley, response) = self.layout_in_ui(ui);
+        response.widget_info(|| WidgetInfo::labeled(WidgetType::Label, text_galley.text()));
+
+        if ui.is_rect_visible(response.rect) {
+            let response_color = ui.style().interact(&response).text_color();
+
+            let underline = if response.has_focus() || response.highlighted() {
+                Stroke::new(1.0, response_color)
+            } else {
+                Stroke::NONE
+            };
+
+            let override_text_color = if text_galley.galley_has_color {
+                None
+            } else {
+                Some(response_color)
+            };
+
+            ui.painter().add(epaint::TextShape {
+                pos,
+                galley: text_galley.galley,
+                override_text_color,
+                underline,
+                angle: 0.0,
+            });
+        }
+
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/mod.rs b/egui/crates/egui/src/widgets/mod.rs
new file mode 100644
index 0000000..f782056
--- /dev/null
+++ b/egui/crates/egui/src/widgets/mod.rs
@@ -0,0 +1,155 @@
+//! Widgets are pieces of GUI such as [`Label`], [`Button`], [`Slider`] etc.
+//!
+//! Example widget uses:
+//! * `ui.add(Label::new("Text").text_color(color::red));`
+//! * `if ui.add(Button::new("Click me")).clicked() { … }`
+
+use crate::*;
+
+mod button;
+pub mod color_picker;
+pub(crate) mod drag_value;
+mod hyperlink;
+mod image;
+mod label;
+pub mod plot;
+mod progress_bar;
+mod selected_label;
+mod separator;
+mod slider;
+mod spinner;
+pub mod text_edit;
+
+pub use button::*;
+pub use drag_value::DragValue;
+pub use hyperlink::*;
+pub use image::Image;
+pub use label::*;
+pub use progress_bar::ProgressBar;
+pub use selected_label::SelectableLabel;
+pub use separator::Separator;
+pub use slider::*;
+pub use spinner::*;
+pub use text_edit::{TextBuffer, TextEdit};
+
+// ----------------------------------------------------------------------------
+
+/// Anything implementing Widget can be added to a [`Ui`] with [`Ui::add`].
+///
+/// [`Button`], [`Label`], [`Slider`], etc all implement the [`Widget`] trait.
+///
+/// Note that the widgets ([`Button`], [`TextEdit`] etc) are
+/// [builders](https://doc.rust-lang.org/1.0.0/style/ownership/builders.html),
+/// and not objects that hold state.
+///
+/// Tip: you can `impl Widget for &mut YourThing { }`.
+///
+/// `|ui: &mut Ui| -> Response { … }` also implements [`Widget`].
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub trait Widget {
+    /// Allocate space, interact, paint, and return a [`Response`].
+    ///
+    /// Note that this consumes `self`.
+    /// This is because most widgets ([`Button`], [`TextEdit`] etc) are
+    /// [builders](https://doc.rust-lang.org/1.0.0/style/ownership/builders.html)
+    ///
+    /// Tip: you can `impl Widget for &mut YourObject { }`.
+    fn ui(self, ui: &mut Ui) -> Response;
+}
+
+/// This enables functions that return `impl Widget`, so that you can
+/// create a widget by just returning a lambda from a function.
+///
+/// For instance: `ui.add(slider_vec2(&mut vec2));` with:
+///
+/// ```
+/// pub fn slider_vec2(value: &mut egui::Vec2) -> impl egui::Widget + '_ {
+///    move |ui: &mut egui::Ui| {
+///        ui.horizontal(|ui| {
+///            ui.add(egui::Slider::new(&mut value.x, 0.0..=1.0).text("x"));
+///            ui.add(egui::Slider::new(&mut value.y, 0.0..=1.0).text("y"));
+///        })
+///        .response
+///    }
+/// }
+/// ```
+impl<F> Widget for F
+where
+    F: FnOnce(&mut Ui) -> Response,
+{
+    fn ui(self, ui: &mut Ui) -> Response {
+        self(ui)
+    }
+}
+
+/// Helper so that you can do `TextEdit::State::read…`
+pub trait WidgetWithState {
+    type State;
+}
+
+// ----------------------------------------------------------------------------
+
+/// Show a button to reset a value to its default.
+/// The button is only enabled if the value does not already have its original value.
+pub fn reset_button<T: Default + PartialEq>(ui: &mut Ui, value: &mut T) {
+    reset_button_with(ui, value, T::default());
+}
+
+/// Show a button to reset a value to its default.
+/// The button is only enabled if the value does not already have its original value.
+pub fn reset_button_with<T: PartialEq>(ui: &mut Ui, value: &mut T, reset_value: T) {
+    if ui
+        .add_enabled(*value != reset_value, Button::new("Reset"))
+        .clicked()
+    {
+        *value = reset_value;
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub fn stroke_ui(ui: &mut crate::Ui, stroke: &mut epaint::Stroke, text: &str) {
+    let epaint::Stroke { width, color } = stroke;
+    ui.horizontal(|ui| {
+        ui.add(DragValue::new(width).speed(0.1).clamp_range(0.0..=5.0))
+            .on_hover_text("Width");
+        ui.color_edit_button_srgba(color);
+        ui.label(text);
+
+        // stroke preview:
+        let (_id, stroke_rect) = ui.allocate_space(ui.spacing().interact_size);
+        let left = stroke_rect.left_center();
+        let right = stroke_rect.right_center();
+        ui.painter().line_segment([left, right], (*width, *color));
+    });
+}
+
+pub(crate) fn shadow_ui(ui: &mut Ui, shadow: &mut epaint::Shadow, text: &str) {
+    let epaint::Shadow { extrusion, color } = shadow;
+    ui.horizontal(|ui| {
+        ui.label(text);
+        ui.add(
+            DragValue::new(extrusion)
+                .speed(1.0)
+                .clamp_range(0.0..=100.0),
+        )
+        .on_hover_text("Extrusion");
+        ui.color_edit_button_srgba(color);
+    });
+}
+
+/// Show a small button to switch to/from dark/light mode (globally).
+pub fn global_dark_light_mode_switch(ui: &mut Ui) {
+    let style: crate::Style = (*ui.ctx().style()).clone();
+    let new_visuals = style.visuals.light_dark_small_toggle_button(ui);
+    if let Some(visuals) = new_visuals {
+        ui.ctx().set_visuals(visuals);
+    }
+}
+
+/// Show larger buttons for switching between light and dark mode (globally).
+pub fn global_dark_light_mode_buttons(ui: &mut Ui) {
+    let mut visuals = ui.ctx().style().visuals.clone();
+    visuals.light_dark_radio_buttons(ui);
+    ui.ctx().set_visuals(visuals);
+}
diff --git a/egui/crates/egui/src/widgets/plot/items/bar.rs b/egui/crates/egui/src/widgets/plot/items/bar.rs
new file mode 100644
index 0000000..a94a7d4
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/items/bar.rs
@@ -0,0 +1,195 @@
+use crate::emath::NumExt;
+use crate::epaint::{Color32, RectShape, Rounding, Shape, Stroke};
+
+use super::{add_rulers_and_text, highlighted_color, Orientation, PlotConfig, RectElement};
+use crate::plot::{BarChart, Cursor, PlotPoint, ScreenTransform};
+
+/// One bar in a [`BarChart`]. Potentially floating, allowing stacked bar charts.
+/// Width can be changed to allow variable-width histograms.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Bar {
+    /// Name of plot element in the diagram (annotated by default formatter)
+    pub name: String,
+
+    /// Which direction the bar faces in the diagram
+    pub orientation: Orientation,
+
+    /// Position on the argument (input) axis -- X if vertical, Y if horizontal
+    pub argument: f64,
+
+    /// Position on the value (output) axis -- Y if vertical, X if horizontal
+    pub value: f64,
+
+    /// For stacked bars, this denotes where the bar starts. None if base axis
+    pub base_offset: Option<f64>,
+
+    /// Thickness of the bar
+    pub bar_width: f64,
+
+    /// Line width and color
+    pub stroke: Stroke,
+
+    /// Fill color
+    pub fill: Color32,
+}
+
+impl Bar {
+    /// Create a bar. Its `orientation` is set by its [`BarChart`] parent.
+    ///
+    /// - `argument`: Position on the argument axis (X if vertical, Y if horizontal).
+    /// - `value`: Height of the bar (if vertical).
+    ///
+    /// By default the bar is vertical and its base is at zero.
+    pub fn new(argument: f64, height: f64) -> Bar {
+        Bar {
+            argument,
+            value: height,
+            orientation: Orientation::default(),
+            name: Default::default(),
+            base_offset: None,
+            bar_width: 0.5,
+            stroke: Stroke::new(1.0, Color32::TRANSPARENT),
+            fill: Color32::TRANSPARENT,
+        }
+    }
+
+    /// Name of this bar chart element.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+
+    /// Add a custom stroke.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = stroke.into();
+        self
+    }
+
+    /// Add a custom fill color.
+    pub fn fill(mut self, color: impl Into<Color32>) -> Self {
+        self.fill = color.into();
+        self
+    }
+
+    /// Offset the base of the bar.
+    /// This offset is on the Y axis for a vertical bar
+    /// and on the X axis for a horizontal bar.
+    pub fn base_offset(mut self, offset: f64) -> Self {
+        self.base_offset = Some(offset);
+        self
+    }
+
+    /// Set the bar width.
+    pub fn width(mut self, width: f64) -> Self {
+        self.bar_width = width;
+        self
+    }
+
+    /// Set orientation of the element as vertical. Argument axis is X.
+    pub fn vertical(mut self) -> Self {
+        self.orientation = Orientation::Vertical;
+        self
+    }
+
+    /// Set orientation of the element as horizontal. Argument axis is Y.
+    pub fn horizontal(mut self) -> Self {
+        self.orientation = Orientation::Horizontal;
+        self
+    }
+
+    pub(super) fn lower(&self) -> f64 {
+        if self.value.is_sign_positive() {
+            self.base_offset.unwrap_or(0.0)
+        } else {
+            self.base_offset.map_or(self.value, |o| o + self.value)
+        }
+    }
+
+    pub(super) fn upper(&self) -> f64 {
+        if self.value.is_sign_positive() {
+            self.base_offset.map_or(self.value, |o| o + self.value)
+        } else {
+            self.base_offset.unwrap_or(0.0)
+        }
+    }
+
+    pub(super) fn add_shapes(
+        &self,
+        transform: &ScreenTransform,
+        highlighted: bool,
+        shapes: &mut Vec<Shape>,
+    ) {
+        let (stroke, fill) = if highlighted {
+            highlighted_color(self.stroke, self.fill)
+        } else {
+            (self.stroke, self.fill)
+        };
+
+        let rect = transform.rect_from_values(&self.bounds_min(), &self.bounds_max());
+        let rect = Shape::Rect(RectShape {
+            rect,
+            rounding: Rounding::none(),
+            fill,
+            stroke,
+        });
+
+        shapes.push(rect);
+    }
+
+    pub(super) fn add_rulers_and_text(
+        &self,
+        parent: &BarChart,
+        plot: &PlotConfig<'_>,
+        shapes: &mut Vec<Shape>,
+        cursors: &mut Vec<Cursor>,
+    ) {
+        let text: Option<String> = parent
+            .element_formatter
+            .as_ref()
+            .map(|fmt| fmt(self, parent));
+
+        add_rulers_and_text(self, plot, text, shapes, cursors);
+    }
+}
+
+impl RectElement for Bar {
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn bounds_min(&self) -> PlotPoint {
+        self.point_at(self.argument - self.bar_width / 2.0, self.lower())
+    }
+
+    fn bounds_max(&self) -> PlotPoint {
+        self.point_at(self.argument + self.bar_width / 2.0, self.upper())
+    }
+
+    fn values_with_ruler(&self) -> Vec<PlotPoint> {
+        let base = self.base_offset.unwrap_or(0.0);
+        let value_center = self.point_at(self.argument, base + self.value);
+
+        let mut ruler_positions = vec![value_center];
+
+        if let Some(offset) = self.base_offset {
+            ruler_positions.push(self.point_at(self.argument, offset));
+        }
+
+        ruler_positions
+    }
+
+    fn orientation(&self) -> Orientation {
+        self.orientation
+    }
+
+    fn default_values_format(&self, transform: &ScreenTransform) -> String {
+        let scale = transform.dvalue_dpos();
+        let scale = match self.orientation {
+            Orientation::Horizontal => scale[0],
+            Orientation::Vertical => scale[1],
+        };
+        let decimals = ((-scale.abs().log10()).ceil().at_least(0.0) as usize).at_most(6);
+        crate::plot::format_number(self.value, decimals)
+    }
+}
diff --git a/egui/crates/egui/src/widgets/plot/items/box_elem.rs b/egui/crates/egui/src/widgets/plot/items/box_elem.rs
new file mode 100644
index 0000000..81174af
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/items/box_elem.rs
@@ -0,0 +1,293 @@
+use crate::emath::NumExt;
+use crate::epaint::{Color32, RectShape, Rounding, Shape, Stroke};
+
+use super::{add_rulers_and_text, highlighted_color, Orientation, PlotConfig, RectElement};
+use crate::plot::{BoxPlot, Cursor, PlotPoint, ScreenTransform};
+
+/// Contains the values of a single box in a box plot.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BoxSpread {
+    /// Value of lower whisker (typically minimum).
+    ///
+    /// The whisker is not drawn if `lower_whisker >= quartile1`.
+    pub lower_whisker: f64,
+
+    /// Value of lower box threshold (typically 25% quartile)
+    pub quartile1: f64,
+
+    /// Value of middle line in box (typically median)
+    pub median: f64,
+
+    /// Value of upper box threshold (typically 75% quartile)
+    pub quartile3: f64,
+
+    /// Value of upper whisker (typically maximum)
+    ///
+    /// The whisker is not drawn if `upper_whisker <= quartile3`.
+    pub upper_whisker: f64,
+}
+
+impl BoxSpread {
+    pub fn new(
+        lower_whisker: f64,
+        quartile1: f64,
+        median: f64,
+        quartile3: f64,
+        upper_whisker: f64,
+    ) -> Self {
+        Self {
+            lower_whisker,
+            quartile1,
+            median,
+            quartile3,
+            upper_whisker,
+        }
+    }
+}
+
+/// A box in a [`BoxPlot`] diagram. This is a low level graphical element; it will not compute quartiles and whiskers,
+/// letting one use their preferred formula. Use [`Points`][`super::Points`] to draw the outliers.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BoxElem {
+    /// Name of plot element in the diagram (annotated by default formatter).
+    pub name: String,
+
+    /// Which direction the box faces in the diagram.
+    pub orientation: Orientation,
+
+    /// Position on the argument (input) axis -- X if vertical, Y if horizontal.
+    pub argument: f64,
+
+    /// Values of the box
+    pub spread: BoxSpread,
+
+    /// Thickness of the box
+    pub box_width: f64,
+
+    /// Width of the whisker at minimum/maximum
+    pub whisker_width: f64,
+
+    /// Line width and color
+    pub stroke: Stroke,
+
+    /// Fill color
+    pub fill: Color32,
+}
+
+impl BoxElem {
+    /// Create a box element. Its `orientation` is set by its [`BoxPlot`] parent.
+    ///
+    /// Check [`BoxElem`] fields for detailed description.
+    pub fn new(argument: f64, spread: BoxSpread) -> Self {
+        Self {
+            argument,
+            orientation: Orientation::default(),
+            name: String::default(),
+            spread,
+            box_width: 0.25,
+            whisker_width: 0.15,
+            stroke: Stroke::new(1.0, Color32::TRANSPARENT),
+            fill: Color32::TRANSPARENT,
+        }
+    }
+
+    /// Name of this box element.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+
+    /// Add a custom stroke.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = stroke.into();
+        self
+    }
+
+    /// Add a custom fill color.
+    pub fn fill(mut self, color: impl Into<Color32>) -> Self {
+        self.fill = color.into();
+        self
+    }
+
+    /// Set the box width.
+    pub fn box_width(mut self, width: f64) -> Self {
+        self.box_width = width;
+        self
+    }
+
+    /// Set the whisker width.
+    pub fn whisker_width(mut self, width: f64) -> Self {
+        self.whisker_width = width;
+        self
+    }
+
+    /// Set orientation of the element as vertical. Argument axis is X.
+    pub fn vertical(mut self) -> Self {
+        self.orientation = Orientation::Vertical;
+        self
+    }
+
+    /// Set orientation of the element as horizontal. Argument axis is Y.
+    pub fn horizontal(mut self) -> Self {
+        self.orientation = Orientation::Horizontal;
+        self
+    }
+
+    pub(super) fn add_shapes(
+        &self,
+        transform: &ScreenTransform,
+        highlighted: bool,
+        shapes: &mut Vec<Shape>,
+    ) {
+        let (stroke, fill) = if highlighted {
+            highlighted_color(self.stroke, self.fill)
+        } else {
+            (self.stroke, self.fill)
+        };
+
+        let rect = transform.rect_from_values(
+            &self.point_at(self.argument - self.box_width / 2.0, self.spread.quartile1),
+            &self.point_at(self.argument + self.box_width / 2.0, self.spread.quartile3),
+        );
+        let rect = Shape::Rect(RectShape {
+            rect,
+            rounding: Rounding::none(),
+            fill,
+            stroke,
+        });
+        shapes.push(rect);
+
+        let line_between = |v1, v2| {
+            Shape::line_segment(
+                [
+                    transform.position_from_point(&v1),
+                    transform.position_from_point(&v2),
+                ],
+                stroke,
+            )
+        };
+        let median = line_between(
+            self.point_at(self.argument - self.box_width / 2.0, self.spread.median),
+            self.point_at(self.argument + self.box_width / 2.0, self.spread.median),
+        );
+        shapes.push(median);
+
+        if self.spread.upper_whisker > self.spread.quartile3 {
+            let high_whisker = line_between(
+                self.point_at(self.argument, self.spread.quartile3),
+                self.point_at(self.argument, self.spread.upper_whisker),
+            );
+            shapes.push(high_whisker);
+            if self.box_width > 0.0 {
+                let high_whisker_end = line_between(
+                    self.point_at(
+                        self.argument - self.whisker_width / 2.0,
+                        self.spread.upper_whisker,
+                    ),
+                    self.point_at(
+                        self.argument + self.whisker_width / 2.0,
+                        self.spread.upper_whisker,
+                    ),
+                );
+                shapes.push(high_whisker_end);
+            }
+        }
+
+        if self.spread.lower_whisker < self.spread.quartile1 {
+            let low_whisker = line_between(
+                self.point_at(self.argument, self.spread.quartile1),
+                self.point_at(self.argument, self.spread.lower_whisker),
+            );
+            shapes.push(low_whisker);
+            if self.box_width > 0.0 {
+                let low_whisker_end = line_between(
+                    self.point_at(
+                        self.argument - self.whisker_width / 2.0,
+                        self.spread.lower_whisker,
+                    ),
+                    self.point_at(
+                        self.argument + self.whisker_width / 2.0,
+                        self.spread.lower_whisker,
+                    ),
+                );
+                shapes.push(low_whisker_end);
+            }
+        }
+    }
+
+    pub(super) fn add_rulers_and_text(
+        &self,
+        parent: &BoxPlot,
+        plot: &PlotConfig<'_>,
+        shapes: &mut Vec<Shape>,
+        cursors: &mut Vec<Cursor>,
+    ) {
+        let text: Option<String> = parent
+            .element_formatter
+            .as_ref()
+            .map(|fmt| fmt(self, parent));
+
+        add_rulers_and_text(self, plot, text, shapes, cursors);
+    }
+}
+
+impl RectElement for BoxElem {
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn bounds_min(&self) -> PlotPoint {
+        let argument = self.argument - self.box_width.max(self.whisker_width) / 2.0;
+        let value = self.spread.lower_whisker;
+        self.point_at(argument, value)
+    }
+
+    fn bounds_max(&self) -> PlotPoint {
+        let argument = self.argument + self.box_width.max(self.whisker_width) / 2.0;
+        let value = self.spread.upper_whisker;
+        self.point_at(argument, value)
+    }
+
+    fn values_with_ruler(&self) -> Vec<PlotPoint> {
+        let median = self.point_at(self.argument, self.spread.median);
+        let q1 = self.point_at(self.argument, self.spread.quartile1);
+        let q3 = self.point_at(self.argument, self.spread.quartile3);
+        let upper = self.point_at(self.argument, self.spread.upper_whisker);
+        let lower = self.point_at(self.argument, self.spread.lower_whisker);
+
+        vec![median, q1, q3, upper, lower]
+    }
+
+    fn orientation(&self) -> Orientation {
+        self.orientation
+    }
+
+    fn corner_value(&self) -> PlotPoint {
+        self.point_at(self.argument, self.spread.upper_whisker)
+    }
+
+    fn default_values_format(&self, transform: &ScreenTransform) -> String {
+        let scale = transform.dvalue_dpos();
+        let scale = match self.orientation {
+            Orientation::Horizontal => scale[0],
+            Orientation::Vertical => scale[1],
+        };
+        let y_decimals = ((-scale.abs().log10()).ceil().at_least(0.0) as usize)
+            .at_most(6)
+            .at_least(1);
+        format!(
+            "Max = {max:.decimals$}\
+             \nQuartile 3 = {q3:.decimals$}\
+             \nMedian = {med:.decimals$}\
+             \nQuartile 1 = {q1:.decimals$}\
+             \nMin = {min:.decimals$}",
+            max = self.spread.upper_whisker,
+            q3 = self.spread.quartile3,
+            med = self.spread.median,
+            q1 = self.spread.quartile1,
+            min = self.spread.lower_whisker,
+            decimals = y_decimals
+        )
+    }
+}
diff --git a/egui/crates/egui/src/widgets/plot/items/mod.rs b/egui/crates/egui/src/widgets/plot/items/mod.rs
new file mode 100644
index 0000000..a4d430c
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/items/mod.rs
@@ -0,0 +1,1749 @@
+//! Contains items that can be added to a plot.
+
+use std::ops::RangeInclusive;
+
+use epaint::util::FloatOrd;
+use epaint::Mesh;
+
+use crate::*;
+
+use super::{Cursor, LabelFormatter, PlotBounds, ScreenTransform};
+use rect_elem::*;
+use values::{ClosestElem, PlotGeometry};
+
+pub use bar::Bar;
+pub use box_elem::{BoxElem, BoxSpread};
+pub use values::{LineStyle, MarkerShape, Orientation, PlotPoint, PlotPoints};
+
+mod bar;
+mod box_elem;
+mod rect_elem;
+mod values;
+
+const DEFAULT_FILL_ALPHA: f32 = 0.05;
+
+/// Container to pass-through several parameters related to plot visualization
+pub(super) struct PlotConfig<'a> {
+    pub ui: &'a Ui,
+    pub transform: &'a ScreenTransform,
+    pub show_x: bool,
+    pub show_y: bool,
+}
+
+/// Trait shared by things that can be drawn in the plot.
+pub(super) trait PlotItem {
+    fn shapes(&self, ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>);
+
+    /// For plot-items which are generated based on x values (plotting functions).
+    fn initialize(&mut self, x_range: RangeInclusive<f64>);
+
+    fn name(&self) -> &str;
+
+    fn color(&self) -> Color32;
+
+    fn highlight(&mut self);
+
+    fn highlighted(&self) -> bool;
+
+    fn geometry(&self) -> PlotGeometry<'_>;
+
+    fn bounds(&self) -> PlotBounds;
+
+    fn find_closest(&self, point: Pos2, transform: &ScreenTransform) -> Option<ClosestElem> {
+        match self.geometry() {
+            PlotGeometry::None => None,
+
+            PlotGeometry::Points(points) => points
+                .iter()
+                .enumerate()
+                .map(|(index, value)| {
+                    let pos = transform.position_from_point(value);
+                    let dist_sq = point.distance_sq(pos);
+                    ClosestElem { index, dist_sq }
+                })
+                .min_by_key(|e| e.dist_sq.ord()),
+
+            PlotGeometry::Rects => {
+                panic!("If the PlotItem is made of rects, it should implement find_closest()")
+            }
+        }
+    }
+
+    fn on_hover(
+        &self,
+        elem: ClosestElem,
+        shapes: &mut Vec<Shape>,
+        cursors: &mut Vec<Cursor>,
+        plot: &PlotConfig<'_>,
+        label_formatter: &LabelFormatter,
+    ) {
+        let points = match self.geometry() {
+            PlotGeometry::Points(points) => points,
+            PlotGeometry::None => {
+                panic!("If the PlotItem has no geometry, on_hover() must not be called")
+            }
+            PlotGeometry::Rects => {
+                panic!("If the PlotItem is made of rects, it should implement on_hover()")
+            }
+        };
+
+        let line_color = if plot.ui.visuals().dark_mode {
+            Color32::from_gray(100).additive()
+        } else {
+            Color32::from_black_alpha(180)
+        };
+
+        // this method is only called, if the value is in the result set of find_closest()
+        let value = points[elem.index];
+        let pointer = plot.transform.position_from_point(&value);
+        shapes.push(Shape::circle_filled(pointer, 3.0, line_color));
+
+        rulers_at_value(
+            pointer,
+            value,
+            self.name(),
+            plot,
+            shapes,
+            cursors,
+            label_formatter,
+        );
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A horizontal line in a plot, filling the full width
+#[derive(Clone, Debug, PartialEq)]
+pub struct HLine {
+    pub(super) y: f64,
+    pub(super) stroke: Stroke,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+    pub(super) style: LineStyle,
+}
+
+impl HLine {
+    pub fn new(y: impl Into<f64>) -> Self {
+        Self {
+            y: y.into(),
+            stroke: Stroke::new(1.0, Color32::TRANSPARENT),
+            name: String::default(),
+            highlight: false,
+            style: LineStyle::Solid,
+        }
+    }
+
+    /// Highlight this line in the plot by scaling up the line.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Add a stroke.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = stroke.into();
+        self
+    }
+
+    /// Stroke width. A high value means the plot thickens.
+    pub fn width(mut self, width: impl Into<f32>) -> Self {
+        self.stroke.width = width.into();
+        self
+    }
+
+    /// Stroke color. Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.stroke.color = color.into();
+        self
+    }
+
+    /// Set the line's style. Default is `LineStyle::Solid`.
+    pub fn style(mut self, style: LineStyle) -> Self {
+        self.style = style;
+        self
+    }
+
+    /// Name of this horizontal line.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for HLine {
+    fn shapes(&self, ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let HLine {
+            y,
+            stroke,
+            highlight,
+            style,
+            ..
+        } = self;
+
+        // Round to minimize aliasing:
+        let points = vec![
+            ui.ctx().round_pos_to_pixels(
+                transform.position_from_point(&PlotPoint::new(transform.bounds().min[0], *y)),
+            ),
+            ui.ctx().round_pos_to_pixels(
+                transform.position_from_point(&PlotPoint::new(transform.bounds().max[0], *y)),
+            ),
+        ];
+        style.style_line(points, *stroke, *highlight, shapes);
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {}
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn color(&self) -> Color32 {
+        self.stroke.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::None
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        bounds.min[1] = self.y;
+        bounds.max[1] = self.y;
+        bounds
+    }
+}
+
+/// A vertical line in a plot, filling the full width
+#[derive(Clone, Debug, PartialEq)]
+pub struct VLine {
+    pub(super) x: f64,
+    pub(super) stroke: Stroke,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+    pub(super) style: LineStyle,
+}
+
+impl VLine {
+    pub fn new(x: impl Into<f64>) -> Self {
+        Self {
+            x: x.into(),
+            stroke: Stroke::new(1.0, Color32::TRANSPARENT),
+            name: String::default(),
+            highlight: false,
+            style: LineStyle::Solid,
+        }
+    }
+
+    /// Highlight this line in the plot by scaling up the line.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Add a stroke.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = stroke.into();
+        self
+    }
+
+    /// Stroke width. A high value means the plot thickens.
+    pub fn width(mut self, width: impl Into<f32>) -> Self {
+        self.stroke.width = width.into();
+        self
+    }
+
+    /// Stroke color. Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.stroke.color = color.into();
+        self
+    }
+
+    /// Set the line's style. Default is `LineStyle::Solid`.
+    pub fn style(mut self, style: LineStyle) -> Self {
+        self.style = style;
+        self
+    }
+
+    /// Name of this vertical line.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for VLine {
+    fn shapes(&self, ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let VLine {
+            x,
+            stroke,
+            highlight,
+            style,
+            ..
+        } = self;
+
+        // Round to minimize aliasing:
+        let points = vec![
+            ui.ctx().round_pos_to_pixels(
+                transform.position_from_point(&PlotPoint::new(*x, transform.bounds().min[1])),
+            ),
+            ui.ctx().round_pos_to_pixels(
+                transform.position_from_point(&PlotPoint::new(*x, transform.bounds().max[1])),
+            ),
+        ];
+        style.style_line(points, *stroke, *highlight, shapes);
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {}
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn color(&self) -> Color32 {
+        self.stroke.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::None
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        bounds.min[0] = self.x;
+        bounds.max[0] = self.x;
+        bounds
+    }
+}
+
+/// A series of values forming a path.
+pub struct Line {
+    pub(super) series: PlotPoints,
+    pub(super) stroke: Stroke,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+    pub(super) fill: Option<f32>,
+    pub(super) style: LineStyle,
+}
+
+impl Line {
+    pub fn new(series: impl Into<PlotPoints>) -> Self {
+        Self {
+            series: series.into(),
+            stroke: Stroke::new(1.0, Color32::TRANSPARENT),
+            name: Default::default(),
+            highlight: false,
+            fill: None,
+            style: LineStyle::Solid,
+        }
+    }
+
+    /// Highlight this line in the plot by scaling up the line.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Add a stroke.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = stroke.into();
+        self
+    }
+
+    /// Stroke width. A high value means the plot thickens.
+    pub fn width(mut self, width: impl Into<f32>) -> Self {
+        self.stroke.width = width.into();
+        self
+    }
+
+    /// Stroke color. Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.stroke.color = color.into();
+        self
+    }
+
+    /// Fill the area between this line and a given horizontal reference line.
+    pub fn fill(mut self, y_reference: impl Into<f32>) -> Self {
+        self.fill = Some(y_reference.into());
+        self
+    }
+
+    /// Set the line's style. Default is `LineStyle::Solid`.
+    pub fn style(mut self, style: LineStyle) -> Self {
+        self.style = style;
+        self
+    }
+
+    /// Name of this line.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+/// Returns the x-coordinate of a possible intersection between a line segment from `p1` to `p2` and
+/// a horizontal line at the given y-coordinate.
+fn y_intersection(p1: &Pos2, p2: &Pos2, y: f32) -> Option<f32> {
+    ((p1.y > y && p2.y < y) || (p1.y < y && p2.y > y))
+        .then_some(((y * (p1.x - p2.x)) - (p1.x * p2.y - p1.y * p2.x)) / (p1.y - p2.y))
+}
+
+impl PlotItem for Line {
+    fn shapes(&self, _ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let Self {
+            series,
+            stroke,
+            highlight,
+            mut fill,
+            style,
+            ..
+        } = self;
+
+        let values_tf: Vec<_> = series
+            .points()
+            .iter()
+            .map(|v| transform.position_from_point(v))
+            .collect();
+        let n_values = values_tf.len();
+
+        // Fill the area between the line and a reference line, if required.
+        if n_values < 2 {
+            fill = None;
+        }
+        if let Some(y_reference) = fill {
+            let mut fill_alpha = DEFAULT_FILL_ALPHA;
+            if *highlight {
+                fill_alpha = (2.0 * fill_alpha).at_most(1.0);
+            }
+            let y = transform
+                .position_from_point(&PlotPoint::new(0.0, y_reference))
+                .y;
+            let fill_color = Rgba::from(stroke.color)
+                .to_opaque()
+                .multiply(fill_alpha)
+                .into();
+            let mut mesh = Mesh::default();
+            let expected_intersections = 20;
+            mesh.reserve_triangles((n_values - 1) * 2);
+            mesh.reserve_vertices(n_values * 2 + expected_intersections);
+            values_tf.windows(2).for_each(|w| {
+                let i = mesh.vertices.len() as u32;
+                mesh.colored_vertex(w[0], fill_color);
+                mesh.colored_vertex(pos2(w[0].x, y), fill_color);
+                if let Some(x) = y_intersection(&w[0], &w[1], y) {
+                    let point = pos2(x, y);
+                    mesh.colored_vertex(point, fill_color);
+                    mesh.add_triangle(i, i + 1, i + 2);
+                    mesh.add_triangle(i + 2, i + 3, i + 4);
+                } else {
+                    mesh.add_triangle(i, i + 1, i + 2);
+                    mesh.add_triangle(i + 1, i + 2, i + 3);
+                }
+            });
+            let last = values_tf[n_values - 1];
+            mesh.colored_vertex(last, fill_color);
+            mesh.colored_vertex(pos2(last.x, y), fill_color);
+            shapes.push(Shape::Mesh(mesh));
+        }
+        style.style_line(values_tf, *stroke, *highlight, shapes);
+    }
+
+    fn initialize(&mut self, x_range: RangeInclusive<f64>) {
+        self.series.generate_points(x_range);
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.stroke.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::Points(self.series.points())
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        self.series.bounds()
+    }
+}
+
+/// A convex polygon.
+pub struct Polygon {
+    pub(super) series: PlotPoints,
+    pub(super) stroke: Stroke,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+    pub(super) fill_alpha: f32,
+    pub(super) style: LineStyle,
+}
+
+impl Polygon {
+    pub fn new(series: impl Into<PlotPoints>) -> Self {
+        Self {
+            series: series.into(),
+            stroke: Stroke::new(1.0, Color32::TRANSPARENT),
+            name: Default::default(),
+            highlight: false,
+            fill_alpha: DEFAULT_FILL_ALPHA,
+            style: LineStyle::Solid,
+        }
+    }
+
+    /// Highlight this polygon in the plot by scaling up the stroke and reducing the fill
+    /// transparency.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Add a custom stroke.
+    pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
+        self.stroke = stroke.into();
+        self
+    }
+
+    /// Set the stroke width.
+    pub fn width(mut self, width: impl Into<f32>) -> Self {
+        self.stroke.width = width.into();
+        self
+    }
+
+    /// Stroke color. Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.stroke.color = color.into();
+        self
+    }
+
+    /// Alpha of the filled area.
+    pub fn fill_alpha(mut self, alpha: impl Into<f32>) -> Self {
+        self.fill_alpha = alpha.into();
+        self
+    }
+
+    /// Set the outline's style. Default is `LineStyle::Solid`.
+    pub fn style(mut self, style: LineStyle) -> Self {
+        self.style = style;
+        self
+    }
+
+    /// Name of this polygon.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for Polygon {
+    fn shapes(&self, _ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let Self {
+            series,
+            stroke,
+            highlight,
+            mut fill_alpha,
+            style,
+            ..
+        } = self;
+
+        if *highlight {
+            fill_alpha = (2.0 * fill_alpha).at_most(1.0);
+        }
+
+        let mut values_tf: Vec<_> = series
+            .points()
+            .iter()
+            .map(|v| transform.position_from_point(v))
+            .collect();
+
+        let fill = Rgba::from(stroke.color).to_opaque().multiply(fill_alpha);
+
+        let shape = Shape::convex_polygon(values_tf.clone(), fill, Stroke::NONE);
+        shapes.push(shape);
+        values_tf.push(*values_tf.first().unwrap());
+        style.style_line(values_tf, *stroke, *highlight, shapes);
+    }
+
+    fn initialize(&mut self, x_range: RangeInclusive<f64>) {
+        self.series.generate_points(x_range);
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.stroke.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::Points(self.series.points())
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        self.series.bounds()
+    }
+}
+
+/// Text inside the plot.
+#[derive(Clone)]
+pub struct Text {
+    pub(super) text: WidgetText,
+    pub(super) position: PlotPoint,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+    pub(super) color: Color32,
+    pub(super) anchor: Align2,
+}
+
+impl Text {
+    pub fn new(position: PlotPoint, text: impl Into<WidgetText>) -> Self {
+        Self {
+            text: text.into(),
+            position,
+            name: Default::default(),
+            highlight: false,
+            color: Color32::TRANSPARENT,
+            anchor: Align2::CENTER_CENTER,
+        }
+    }
+
+    /// Highlight this text in the plot by drawing a rectangle around it.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Text color.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.color = color.into();
+        self
+    }
+
+    /// Anchor position of the text. Default is `Align2::CENTER_CENTER`.
+    pub fn anchor(mut self, anchor: Align2) -> Self {
+        self.anchor = anchor;
+        self
+    }
+
+    /// Name of this text.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for Text {
+    fn shapes(&self, ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let color = if self.color == Color32::TRANSPARENT {
+            ui.style().visuals.text_color()
+        } else {
+            self.color
+        };
+
+        let galley =
+            self.text
+                .clone()
+                .into_galley(ui, Some(false), f32::INFINITY, TextStyle::Small);
+
+        let pos = transform.position_from_point(&self.position);
+        let rect = self
+            .anchor
+            .anchor_rect(Rect::from_min_size(pos, galley.size()));
+
+        let mut text_shape = epaint::TextShape::new(rect.min, galley.galley);
+        if !galley.galley_has_color {
+            text_shape.override_text_color = Some(color);
+        }
+        shapes.push(text_shape.into());
+
+        if self.highlight {
+            shapes.push(Shape::rect_stroke(
+                rect.expand(2.0),
+                1.0,
+                Stroke::new(0.5, color),
+            ));
+        }
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {}
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::None
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        bounds.extend_with(&self.position);
+        bounds
+    }
+}
+
+/// A set of points.
+pub struct Points {
+    pub(super) series: PlotPoints,
+    pub(super) shape: MarkerShape,
+    /// Color of the marker. `Color32::TRANSPARENT` means that it will be picked automatically.
+    pub(super) color: Color32,
+    /// Whether to fill the marker. Does not apply to all types.
+    pub(super) filled: bool,
+    /// The maximum extent of the marker from its center.
+    pub(super) radius: f32,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+    pub(super) stems: Option<f32>,
+}
+
+impl Points {
+    pub fn new(series: impl Into<PlotPoints>) -> Self {
+        Self {
+            series: series.into(),
+            shape: MarkerShape::Circle,
+            color: Color32::TRANSPARENT,
+            filled: true,
+            radius: 1.0,
+            name: Default::default(),
+            highlight: false,
+            stems: None,
+        }
+    }
+
+    /// Set the shape of the markers.
+    pub fn shape(mut self, shape: MarkerShape) -> Self {
+        self.shape = shape;
+        self
+    }
+
+    /// Highlight these points in the plot by scaling up their markers.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Set the marker's color.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.color = color.into();
+        self
+    }
+
+    /// Whether to fill the marker.
+    pub fn filled(mut self, filled: bool) -> Self {
+        self.filled = filled;
+        self
+    }
+
+    /// Whether to add stems between the markers and a horizontal reference line.
+    pub fn stems(mut self, y_reference: impl Into<f32>) -> Self {
+        self.stems = Some(y_reference.into());
+        self
+    }
+
+    /// Set the maximum extent of the marker around its position.
+    pub fn radius(mut self, radius: impl Into<f32>) -> Self {
+        self.radius = radius.into();
+        self
+    }
+
+    /// Name of this set of points.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for Points {
+    fn shapes(&self, _ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let sqrt_3 = 3_f32.sqrt();
+        let frac_sqrt_3_2 = 3_f32.sqrt() / 2.0;
+        let frac_1_sqrt_2 = 1.0 / 2_f32.sqrt();
+
+        let Self {
+            series,
+            shape,
+            color,
+            filled,
+            mut radius,
+            highlight,
+            stems,
+            ..
+        } = self;
+
+        let stroke_size = radius / 5.0;
+
+        let default_stroke = Stroke::new(stroke_size, *color);
+        let mut stem_stroke = default_stroke;
+        let (fill, stroke) = if *filled {
+            (*color, Stroke::NONE)
+        } else {
+            (Color32::TRANSPARENT, default_stroke)
+        };
+
+        if *highlight {
+            radius *= 2f32.sqrt();
+            stem_stroke.width *= 2.0;
+        }
+
+        let y_reference = stems.map(|y| transform.position_from_point(&PlotPoint::new(0.0, y)).y);
+
+        series
+            .points()
+            .iter()
+            .map(|value| transform.position_from_point(value))
+            .for_each(|center| {
+                let tf = |dx: f32, dy: f32| -> Pos2 { center + radius * vec2(dx, dy) };
+
+                if let Some(y) = y_reference {
+                    let stem = Shape::line_segment([center, pos2(center.x, y)], stem_stroke);
+                    shapes.push(stem);
+                }
+
+                match shape {
+                    MarkerShape::Circle => {
+                        shapes.push(Shape::Circle(epaint::CircleShape {
+                            center,
+                            radius,
+                            fill,
+                            stroke,
+                        }));
+                    }
+                    MarkerShape::Diamond => {
+                        let points = vec![
+                            tf(0.0, 1.0),  // bottom
+                            tf(-1.0, 0.0), // left
+                            tf(0.0, -1.0), // top
+                            tf(1.0, 0.0),  // right
+                        ];
+                        shapes.push(Shape::convex_polygon(points, fill, stroke));
+                    }
+                    MarkerShape::Square => {
+                        let points = vec![
+                            tf(-frac_1_sqrt_2, frac_1_sqrt_2),
+                            tf(-frac_1_sqrt_2, -frac_1_sqrt_2),
+                            tf(frac_1_sqrt_2, -frac_1_sqrt_2),
+                            tf(frac_1_sqrt_2, frac_1_sqrt_2),
+                        ];
+                        shapes.push(Shape::convex_polygon(points, fill, stroke));
+                    }
+                    MarkerShape::Cross => {
+                        let diagonal1 = [
+                            tf(-frac_1_sqrt_2, -frac_1_sqrt_2),
+                            tf(frac_1_sqrt_2, frac_1_sqrt_2),
+                        ];
+                        let diagonal2 = [
+                            tf(frac_1_sqrt_2, -frac_1_sqrt_2),
+                            tf(-frac_1_sqrt_2, frac_1_sqrt_2),
+                        ];
+                        shapes.push(Shape::line_segment(diagonal1, default_stroke));
+                        shapes.push(Shape::line_segment(diagonal2, default_stroke));
+                    }
+                    MarkerShape::Plus => {
+                        let horizontal = [tf(-1.0, 0.0), tf(1.0, 0.0)];
+                        let vertical = [tf(0.0, -1.0), tf(0.0, 1.0)];
+                        shapes.push(Shape::line_segment(horizontal, default_stroke));
+                        shapes.push(Shape::line_segment(vertical, default_stroke));
+                    }
+                    MarkerShape::Up => {
+                        let points =
+                            vec![tf(0.0, -1.0), tf(0.5 * sqrt_3, 0.5), tf(-0.5 * sqrt_3, 0.5)];
+                        shapes.push(Shape::convex_polygon(points, fill, stroke));
+                    }
+                    MarkerShape::Down => {
+                        let points = vec![
+                            tf(0.0, 1.0),
+                            tf(-0.5 * sqrt_3, -0.5),
+                            tf(0.5 * sqrt_3, -0.5),
+                        ];
+                        shapes.push(Shape::convex_polygon(points, fill, stroke));
+                    }
+                    MarkerShape::Left => {
+                        let points =
+                            vec![tf(-1.0, 0.0), tf(0.5, -0.5 * sqrt_3), tf(0.5, 0.5 * sqrt_3)];
+                        shapes.push(Shape::convex_polygon(points, fill, stroke));
+                    }
+                    MarkerShape::Right => {
+                        let points = vec![
+                            tf(1.0, 0.0),
+                            tf(-0.5, 0.5 * sqrt_3),
+                            tf(-0.5, -0.5 * sqrt_3),
+                        ];
+                        shapes.push(Shape::convex_polygon(points, fill, stroke));
+                    }
+                    MarkerShape::Asterisk => {
+                        let vertical = [tf(0.0, -1.0), tf(0.0, 1.0)];
+                        let diagonal1 = [tf(-frac_sqrt_3_2, 0.5), tf(frac_sqrt_3_2, -0.5)];
+                        let diagonal2 = [tf(-frac_sqrt_3_2, -0.5), tf(frac_sqrt_3_2, 0.5)];
+                        shapes.push(Shape::line_segment(vertical, default_stroke));
+                        shapes.push(Shape::line_segment(diagonal1, default_stroke));
+                        shapes.push(Shape::line_segment(diagonal2, default_stroke));
+                    }
+                }
+            });
+    }
+
+    fn initialize(&mut self, x_range: RangeInclusive<f64>) {
+        self.series.generate_points(x_range);
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::Points(self.series.points())
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        self.series.bounds()
+    }
+}
+
+/// A set of arrows.
+pub struct Arrows {
+    pub(super) origins: PlotPoints,
+    pub(super) tips: PlotPoints,
+    pub(super) color: Color32,
+    pub(super) name: String,
+    pub(super) highlight: bool,
+}
+
+impl Arrows {
+    pub fn new(origins: impl Into<PlotPoints>, tips: impl Into<PlotPoints>) -> Self {
+        Self {
+            origins: origins.into(),
+            tips: tips.into(),
+            color: Color32::TRANSPARENT,
+            name: Default::default(),
+            highlight: false,
+        }
+    }
+
+    /// Highlight these arrows in the plot.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Set the arrows' color.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.color = color.into();
+        self
+    }
+
+    /// Name of this set of arrows.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for Arrows {
+    fn shapes(&self, _ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        use crate::emath::*;
+        let Self {
+            origins,
+            tips,
+            color,
+            highlight,
+            ..
+        } = self;
+        let stroke = Stroke::new(if *highlight { 2.0 } else { 1.0 }, *color);
+        origins
+            .points()
+            .iter()
+            .zip(tips.points().iter())
+            .map(|(origin, tip)| {
+                (
+                    transform.position_from_point(origin),
+                    transform.position_from_point(tip),
+                )
+            })
+            .for_each(|(origin, tip)| {
+                let vector = tip - origin;
+                let rot = Rot2::from_angle(std::f32::consts::TAU / 10.0);
+                let tip_length = vector.length() / 4.0;
+                let tip = origin + vector;
+                let dir = vector.normalized();
+                shapes.push(Shape::line_segment([origin, tip], stroke));
+                shapes.push(Shape::line(
+                    vec![
+                        tip - tip_length * (rot.inverse() * dir),
+                        tip,
+                        tip - tip_length * (rot * dir),
+                    ],
+                    stroke,
+                ));
+            });
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {
+        self.origins
+            .generate_points(f64::NEG_INFINITY..=f64::INFINITY);
+        self.tips.generate_points(f64::NEG_INFINITY..=f64::INFINITY);
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::Points(self.origins.points())
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        self.origins.bounds()
+    }
+}
+
+/// An image in the plot.
+#[derive(Clone)]
+pub struct PlotImage {
+    pub(super) position: PlotPoint,
+    pub(super) texture_id: TextureId,
+    pub(super) uv: Rect,
+    pub(super) size: Vec2,
+    pub(super) bg_fill: Color32,
+    pub(super) tint: Color32,
+    pub(super) highlight: bool,
+    pub(super) name: String,
+}
+
+impl PlotImage {
+    /// Create a new image with position and size in plot coordinates.
+    pub fn new(
+        texture_id: impl Into<TextureId>,
+        center_position: PlotPoint,
+        size: impl Into<Vec2>,
+    ) -> Self {
+        Self {
+            position: center_position,
+            name: Default::default(),
+            highlight: false,
+            texture_id: texture_id.into(),
+            uv: Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
+            size: size.into(),
+            bg_fill: Default::default(),
+            tint: Color32::WHITE,
+        }
+    }
+
+    /// Highlight this image in the plot.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Select UV range. Default is (0,0) in top-left, (1,1) bottom right.
+    pub fn uv(mut self, uv: impl Into<Rect>) -> Self {
+        self.uv = uv.into();
+        self
+    }
+
+    /// A solid color to put behind the image. Useful for transparent images.
+    pub fn bg_fill(mut self, bg_fill: impl Into<Color32>) -> Self {
+        self.bg_fill = bg_fill.into();
+        self
+    }
+
+    /// Multiply image color with this. Default is WHITE (no tint).
+    pub fn tint(mut self, tint: impl Into<Color32>) -> Self {
+        self.tint = tint.into();
+        self
+    }
+
+    /// Name of this image.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on.
+    ///
+    /// Multiple plot items may share the same name, in which case they will also share an entry in
+    /// the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+}
+
+impl PlotItem for PlotImage {
+    fn shapes(&self, ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        let Self {
+            position,
+            texture_id,
+            uv,
+            size,
+            bg_fill,
+            tint,
+            highlight,
+            ..
+        } = self;
+        let rect = {
+            let left_top = PlotPoint::new(
+                position.x as f32 - size.x / 2.0,
+                position.y as f32 - size.y / 2.0,
+            );
+            let right_bottom = PlotPoint::new(
+                position.x as f32 + size.x / 2.0,
+                position.y as f32 + size.y / 2.0,
+            );
+            let left_top_tf = transform.position_from_point(&left_top);
+            let right_bottom_tf = transform.position_from_point(&right_bottom);
+            Rect::from_two_pos(left_top_tf, right_bottom_tf)
+        };
+        Image::new(*texture_id, *size)
+            .bg_fill(*bg_fill)
+            .tint(*tint)
+            .uv(*uv)
+            .paint_at(ui, rect);
+        if *highlight {
+            shapes.push(Shape::rect_stroke(
+                rect,
+                0.0,
+                Stroke::new(1.0, ui.visuals().strong_text_color()),
+            ));
+        }
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {}
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        Color32::TRANSPARENT
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::None
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        let left_top = PlotPoint::new(
+            self.position.x as f32 - self.size.x / 2.0,
+            self.position.y as f32 - self.size.y / 2.0,
+        );
+        let right_bottom = PlotPoint::new(
+            self.position.x as f32 + self.size.x / 2.0,
+            self.position.y as f32 + self.size.y / 2.0,
+        );
+        bounds.extend_with(&left_top);
+        bounds.extend_with(&right_bottom);
+        bounds
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A bar chart.
+pub struct BarChart {
+    pub(super) bars: Vec<Bar>,
+    pub(super) default_color: Color32,
+    pub(super) name: String,
+    /// A custom element formatter
+    pub(super) element_formatter: Option<Box<dyn Fn(&Bar, &BarChart) -> String>>,
+    highlight: bool,
+}
+
+impl BarChart {
+    /// Create a bar chart. It defaults to vertically oriented elements.
+    pub fn new(bars: Vec<Bar>) -> BarChart {
+        BarChart {
+            bars,
+            default_color: Color32::TRANSPARENT,
+            name: String::new(),
+            element_formatter: None,
+            highlight: false,
+        }
+    }
+
+    /// Set the default color. It is set on all elements that do not already have a specific color.
+    /// This is the color that shows up in the legend.
+    /// It can be overridden at the bar level (see [[`Bar`]]).
+    /// Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        let plot_color = color.into();
+        self.default_color = plot_color;
+        for b in &mut self.bars {
+            if b.fill == Color32::TRANSPARENT && b.stroke.color == Color32::TRANSPARENT {
+                b.fill = plot_color.linear_multiply(0.2);
+                b.stroke.color = plot_color;
+            }
+        }
+        self
+    }
+
+    /// Name of this chart.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on. Multiple charts may
+    /// share the same name, in which case they will also share an entry in the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+
+    /// Set all elements to be in a vertical orientation.
+    /// Argument axis will be X and bar values will be on the Y axis.
+    pub fn vertical(mut self) -> Self {
+        for b in &mut self.bars {
+            b.orientation = Orientation::Vertical;
+        }
+        self
+    }
+
+    /// Set all elements to be in a horizontal orientation.
+    /// Argument axis will be Y and bar values will be on the X axis.
+    pub fn horizontal(mut self) -> Self {
+        for b in &mut self.bars {
+            b.orientation = Orientation::Horizontal;
+        }
+        self
+    }
+
+    /// Set the width (thickness) of all its elements.
+    pub fn width(mut self, width: f64) -> Self {
+        for b in &mut self.bars {
+            b.bar_width = width;
+        }
+        self
+    }
+
+    /// Highlight all plot elements.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Add a custom way to format an element.
+    /// Can be used to display a set number of decimals or custom labels.
+    pub fn element_formatter(mut self, formatter: Box<dyn Fn(&Bar, &BarChart) -> String>) -> Self {
+        self.element_formatter = Some(formatter);
+        self
+    }
+
+    /// Stacks the bars on top of another chart.
+    /// Positive values are stacked on top of other positive values.
+    /// Negative values are stacked below other negative values.
+    pub fn stack_on(mut self, others: &[&BarChart]) -> Self {
+        for (index, bar) in self.bars.iter_mut().enumerate() {
+            let new_base_offset = if bar.value.is_sign_positive() {
+                others
+                    .iter()
+                    .filter_map(|other_chart| other_chart.bars.get(index).map(|bar| bar.upper()))
+                    .max_by_key(|value| value.ord())
+            } else {
+                others
+                    .iter()
+                    .filter_map(|other_chart| other_chart.bars.get(index).map(|bar| bar.lower()))
+                    .min_by_key(|value| value.ord())
+            };
+
+            if let Some(value) = new_base_offset {
+                bar.base_offset = Some(value);
+            }
+        }
+        self
+    }
+}
+
+impl PlotItem for BarChart {
+    fn shapes(&self, _ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        for b in &self.bars {
+            b.add_shapes(transform, self.highlight, shapes);
+        }
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {
+        // nothing to do
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.default_color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::Rects
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        for b in &self.bars {
+            bounds.merge(&b.bounds());
+        }
+        bounds
+    }
+
+    fn find_closest(&self, point: Pos2, transform: &ScreenTransform) -> Option<ClosestElem> {
+        find_closest_rect(&self.bars, point, transform)
+    }
+
+    fn on_hover(
+        &self,
+        elem: ClosestElem,
+        shapes: &mut Vec<Shape>,
+        cursors: &mut Vec<Cursor>,
+        plot: &PlotConfig<'_>,
+        _: &LabelFormatter,
+    ) {
+        let bar = &self.bars[elem.index];
+
+        bar.add_shapes(plot.transform, true, shapes);
+        bar.add_rulers_and_text(self, plot, shapes, cursors);
+    }
+}
+
+/// A diagram containing a series of [`BoxElem`] elements.
+pub struct BoxPlot {
+    pub(super) boxes: Vec<BoxElem>,
+    pub(super) default_color: Color32,
+    pub(super) name: String,
+    /// A custom element formatter
+    pub(super) element_formatter: Option<Box<dyn Fn(&BoxElem, &BoxPlot) -> String>>,
+    highlight: bool,
+}
+
+impl BoxPlot {
+    /// Create a plot containing multiple `boxes`. It defaults to vertically oriented elements.
+    pub fn new(boxes: Vec<BoxElem>) -> Self {
+        Self {
+            boxes,
+            default_color: Color32::TRANSPARENT,
+            name: String::new(),
+            element_formatter: None,
+            highlight: false,
+        }
+    }
+
+    /// Set the default color. It is set on all elements that do not already have a specific color.
+    /// This is the color that shows up in the legend.
+    /// It can be overridden at the element level (see [`BoxElem`]).
+    /// Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        let plot_color = color.into();
+        self.default_color = plot_color;
+        for box_elem in &mut self.boxes {
+            if box_elem.fill == Color32::TRANSPARENT
+                && box_elem.stroke.color == Color32::TRANSPARENT
+            {
+                box_elem.fill = plot_color.linear_multiply(0.2);
+                box_elem.stroke.color = plot_color;
+            }
+        }
+        self
+    }
+
+    /// Name of this box plot diagram.
+    ///
+    /// This name will show up in the plot legend, if legends are turned on. Multiple series may
+    /// share the same name, in which case they will also share an entry in the legend.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+
+    /// Set all elements to be in a vertical orientation.
+    /// Argument axis will be X and values will be on the Y axis.
+    pub fn vertical(mut self) -> Self {
+        for box_elem in &mut self.boxes {
+            box_elem.orientation = Orientation::Vertical;
+        }
+        self
+    }
+
+    /// Set all elements to be in a horizontal orientation.
+    /// Argument axis will be Y and values will be on the X axis.
+    pub fn horizontal(mut self) -> Self {
+        for box_elem in &mut self.boxes {
+            box_elem.orientation = Orientation::Horizontal;
+        }
+        self
+    }
+
+    /// Highlight all plot elements.
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
+        self
+    }
+
+    /// Add a custom way to format an element.
+    /// Can be used to display a set number of decimals or custom labels.
+    pub fn element_formatter(
+        mut self,
+        formatter: Box<dyn Fn(&BoxElem, &BoxPlot) -> String>,
+    ) -> Self {
+        self.element_formatter = Some(formatter);
+        self
+    }
+}
+
+impl PlotItem for BoxPlot {
+    fn shapes(&self, _ui: &mut Ui, transform: &ScreenTransform, shapes: &mut Vec<Shape>) {
+        for b in &self.boxes {
+            b.add_shapes(transform, self.highlight, shapes);
+        }
+    }
+
+    fn initialize(&mut self, _x_range: RangeInclusive<f64>) {
+        // nothing to do
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn color(&self) -> Color32 {
+        self.default_color
+    }
+
+    fn highlight(&mut self) {
+        self.highlight = true;
+    }
+
+    fn highlighted(&self) -> bool {
+        self.highlight
+    }
+
+    fn geometry(&self) -> PlotGeometry<'_> {
+        PlotGeometry::Rects
+    }
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        for b in &self.boxes {
+            bounds.merge(&b.bounds());
+        }
+        bounds
+    }
+
+    fn find_closest(&self, point: Pos2, transform: &ScreenTransform) -> Option<ClosestElem> {
+        find_closest_rect(&self.boxes, point, transform)
+    }
+
+    fn on_hover(
+        &self,
+        elem: ClosestElem,
+        shapes: &mut Vec<Shape>,
+        cursors: &mut Vec<Cursor>,
+        plot: &PlotConfig<'_>,
+        _: &LabelFormatter,
+    ) {
+        let box_plot = &self.boxes[elem.index];
+
+        box_plot.add_shapes(plot.transform, true, shapes);
+        box_plot.add_rulers_and_text(self, plot, shapes, cursors);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Helper functions
+
+pub(crate) fn rulers_color(ui: &Ui) -> Color32 {
+    if ui.visuals().dark_mode {
+        Color32::from_gray(100).additive()
+    } else {
+        Color32::from_black_alpha(180)
+    }
+}
+
+pub(crate) fn vertical_line(
+    pointer: Pos2,
+    transform: &ScreenTransform,
+    line_color: Color32,
+) -> Shape {
+    let frame = transform.frame();
+    Shape::line_segment(
+        [
+            pos2(pointer.x, frame.top()),
+            pos2(pointer.x, frame.bottom()),
+        ],
+        (1.0, line_color),
+    )
+}
+
+pub(crate) fn horizontal_line(
+    pointer: Pos2,
+    transform: &ScreenTransform,
+    line_color: Color32,
+) -> Shape {
+    let frame = transform.frame();
+    Shape::line_segment(
+        [
+            pos2(frame.left(), pointer.y),
+            pos2(frame.right(), pointer.y),
+        ],
+        (1.0, line_color),
+    )
+}
+
+fn add_rulers_and_text(
+    elem: &dyn RectElement,
+    plot: &PlotConfig<'_>,
+    text: Option<String>,
+    shapes: &mut Vec<Shape>,
+    cursors: &mut Vec<Cursor>,
+) {
+    let orientation = elem.orientation();
+    let show_argument = plot.show_x && orientation == Orientation::Vertical
+        || plot.show_y && orientation == Orientation::Horizontal;
+    let show_values = plot.show_y && orientation == Orientation::Vertical
+        || plot.show_x && orientation == Orientation::Horizontal;
+
+    // Rulers for argument (usually vertical)
+    if show_argument {
+        for pos in elem.arguments_with_ruler() {
+            cursors.push(match orientation {
+                Orientation::Horizontal => Cursor::Horizontal { y: pos.y },
+                Orientation::Vertical => Cursor::Vertical { x: pos.x },
+            });
+        }
+    }
+
+    // Rulers for values (usually horizontal)
+    if show_values {
+        for pos in elem.values_with_ruler() {
+            cursors.push(match orientation {
+                Orientation::Horizontal => Cursor::Vertical { x: pos.x },
+                Orientation::Vertical => Cursor::Horizontal { y: pos.y },
+            });
+        }
+    }
+
+    // Text
+    let text = text.unwrap_or({
+        let mut text = elem.name().to_owned(); // could be empty
+
+        if show_values {
+            text.push('\n');
+            text.push_str(&elem.default_values_format(plot.transform));
+        }
+
+        text
+    });
+
+    let font_id = TextStyle::Body.resolve(plot.ui.style());
+
+    let corner_value = elem.corner_value();
+    plot.ui.fonts(|f| {
+        shapes.push(Shape::text(
+            f,
+            plot.transform.position_from_point(&corner_value) + vec2(3.0, -2.0),
+            Align2::LEFT_BOTTOM,
+            text,
+            font_id,
+            plot.ui.visuals().text_color(),
+        ));
+    });
+}
+
+/// Draws a cross of horizontal and vertical ruler at the `pointer` position.
+/// `value` is used to for text displaying X/Y coordinates.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn rulers_at_value(
+    pointer: Pos2,
+    value: PlotPoint,
+    name: &str,
+    plot: &PlotConfig<'_>,
+    shapes: &mut Vec<Shape>,
+    cursors: &mut Vec<Cursor>,
+    label_formatter: &LabelFormatter,
+) {
+    if plot.show_x {
+        cursors.push(Cursor::Vertical { x: value.x });
+    }
+    if plot.show_y {
+        cursors.push(Cursor::Horizontal { y: value.y });
+    }
+
+    let mut prefix = String::new();
+
+    if !name.is_empty() {
+        prefix = format!("{}\n", name);
+    }
+
+    let text = {
+        let scale = plot.transform.dvalue_dpos();
+        let x_decimals = ((-scale[0].abs().log10()).ceil().at_least(0.0) as usize).clamp(1, 6);
+        let y_decimals = ((-scale[1].abs().log10()).ceil().at_least(0.0) as usize).clamp(1, 6);
+        if let Some(custom_label) = label_formatter {
+            custom_label(name, &value)
+        } else if plot.show_x && plot.show_y {
+            format!(
+                "{}x = {:.*}\ny = {:.*}",
+                prefix, x_decimals, value.x, y_decimals, value.y
+            )
+        } else if plot.show_x {
+            format!("{}x = {:.*}", prefix, x_decimals, value.x)
+        } else if plot.show_y {
+            format!("{}y = {:.*}", prefix, y_decimals, value.y)
+        } else {
+            unreachable!()
+        }
+    };
+
+    let font_id = TextStyle::Body.resolve(plot.ui.style());
+    plot.ui.fonts(|f| {
+        shapes.push(Shape::text(
+            f,
+            pointer + vec2(3.0, -2.0),
+            Align2::LEFT_BOTTOM,
+            text,
+            font_id,
+            plot.ui.visuals().text_color(),
+        ));
+    });
+}
+
+fn find_closest_rect<'a, T>(
+    rects: impl IntoIterator<Item = &'a T>,
+    point: Pos2,
+    transform: &ScreenTransform,
+) -> Option<ClosestElem>
+where
+    T: 'a + RectElement,
+{
+    rects
+        .into_iter()
+        .enumerate()
+        .map(|(index, bar)| {
+            let bar_rect: Rect = transform.rect_from_values(&bar.bounds_min(), &bar.bounds_max());
+            let dist_sq = bar_rect.distance_sq_to_pos(point);
+
+            ClosestElem { index, dist_sq }
+        })
+        .min_by_key(|e| e.dist_sq.ord())
+}
diff --git a/egui/crates/egui/src/widgets/plot/items/rect_elem.rs b/egui/crates/egui/src/widgets/plot/items/rect_elem.rs
new file mode 100644
index 0000000..0379a41
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/items/rect_elem.rs
@@ -0,0 +1,63 @@
+use super::{Orientation, PlotPoint};
+use crate::plot::transform::{PlotBounds, ScreenTransform};
+use epaint::emath::NumExt;
+use epaint::{Color32, Rgba, Stroke};
+
+/// Trait that abstracts from rectangular 'Value'-like elements, such as bars or boxes
+pub(super) trait RectElement {
+    fn name(&self) -> &str;
+
+    fn bounds_min(&self) -> PlotPoint;
+
+    fn bounds_max(&self) -> PlotPoint;
+
+    fn bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+        bounds.extend_with(&self.bounds_min());
+        bounds.extend_with(&self.bounds_max());
+        bounds
+    }
+
+    /// At which argument (input; usually X) there is a ruler (usually vertical)
+    fn arguments_with_ruler(&self) -> Vec<PlotPoint> {
+        // Default: one at center
+        vec![self.bounds().center()]
+    }
+
+    /// At which value (output; usually Y) there is a ruler (usually horizontal)
+    fn values_with_ruler(&self) -> Vec<PlotPoint>;
+
+    /// The diagram's orientation (vertical/horizontal)
+    fn orientation(&self) -> Orientation;
+
+    /// Get X/Y-value for (argument, value) pair, taking into account orientation
+    fn point_at(&self, argument: f64, value: f64) -> PlotPoint {
+        match self.orientation() {
+            Orientation::Horizontal => PlotPoint::new(value, argument),
+            Orientation::Vertical => PlotPoint::new(argument, value),
+        }
+    }
+
+    /// Right top of the rectangle (position of text)
+    fn corner_value(&self) -> PlotPoint {
+        //self.point_at(self.position + self.width / 2.0, value)
+        PlotPoint {
+            x: self.bounds_max().x,
+            y: self.bounds_max().y,
+        }
+    }
+
+    /// Debug formatting for hovered-over value, if none is specified by the user
+    fn default_values_format(&self, transform: &ScreenTransform) -> String;
+}
+
+// ----------------------------------------------------------------------------
+// Helper functions
+
+pub(super) fn highlighted_color(mut stroke: Stroke, fill: Color32) -> (Stroke, Color32) {
+    stroke.width *= 2.0;
+    let fill = Rgba::from(fill);
+    let fill_alpha = (2.0 * fill.a()).at_most(1.0);
+    let fill = fill.to_opaque().multiply(fill_alpha);
+    (stroke, fill.into())
+}
diff --git a/egui/crates/egui/src/widgets/plot/items/values.rs b/egui/crates/egui/src/widgets/plot/items/values.rs
new file mode 100644
index 0000000..739490d
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/items/values.rs
@@ -0,0 +1,432 @@
+use epaint::{Pos2, Shape, Stroke, Vec2};
+use std::ops::{Bound, RangeBounds, RangeInclusive};
+
+use crate::plot::transform::PlotBounds;
+
+/// A point coordinate in the plot.
+///
+/// Uses f64 for improved accuracy to enable plotting
+/// large values (e.g. unix time on x axis).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct PlotPoint {
+    /// This is often something monotonically increasing, such as time, but doesn't have to be.
+    /// Goes from left to right.
+    pub x: f64,
+
+    /// Goes from bottom to top (inverse of everything else in egui!).
+    pub y: f64,
+}
+
+impl From<[f64; 2]> for PlotPoint {
+    #[inline]
+    fn from([x, y]: [f64; 2]) -> Self {
+        Self { x, y }
+    }
+}
+
+impl PlotPoint {
+    #[inline(always)]
+    pub fn new(x: impl Into<f64>, y: impl Into<f64>) -> Self {
+        Self {
+            x: x.into(),
+            y: y.into(),
+        }
+    }
+
+    #[inline(always)]
+    pub fn to_pos2(self) -> Pos2 {
+        Pos2::new(self.x as f32, self.y as f32)
+    }
+
+    #[inline(always)]
+    pub fn to_vec2(self) -> Vec2 {
+        Vec2::new(self.x as f32, self.y as f32)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum LineStyle {
+    Solid,
+    Dotted { spacing: f32 },
+    Dashed { length: f32 },
+}
+
+impl LineStyle {
+    pub fn dashed_loose() -> Self {
+        Self::Dashed { length: 10.0 }
+    }
+
+    pub fn dashed_dense() -> Self {
+        Self::Dashed { length: 5.0 }
+    }
+
+    pub fn dotted_loose() -> Self {
+        Self::Dotted { spacing: 10.0 }
+    }
+
+    pub fn dotted_dense() -> Self {
+        Self::Dotted { spacing: 5.0 }
+    }
+
+    pub(super) fn style_line(
+        &self,
+        line: Vec<Pos2>,
+        mut stroke: Stroke,
+        highlight: bool,
+        shapes: &mut Vec<Shape>,
+    ) {
+        match line.len() {
+            0 => {}
+            1 => {
+                let mut radius = stroke.width / 2.0;
+                if highlight {
+                    radius *= 2f32.sqrt();
+                }
+                shapes.push(Shape::circle_filled(line[0], radius, stroke.color));
+            }
+            _ => {
+                match self {
+                    LineStyle::Solid => {
+                        if highlight {
+                            stroke.width *= 2.0;
+                        }
+                        shapes.push(Shape::line(line, stroke));
+                    }
+                    LineStyle::Dotted { spacing } => {
+                        // Take the stroke width for the radius even though it's not "correct", otherwise
+                        // the dots would become too small.
+                        let mut radius = stroke.width;
+                        if highlight {
+                            radius *= 2f32.sqrt();
+                        }
+                        shapes.extend(Shape::dotted_line(&line, stroke.color, *spacing, radius));
+                    }
+                    LineStyle::Dashed { length } => {
+                        if highlight {
+                            stroke.width *= 2.0;
+                        }
+                        let golden_ratio = (5.0_f32.sqrt() - 1.0) / 2.0; // 0.61803398875
+                        shapes.extend(Shape::dashed_line(
+                            &line,
+                            stroke,
+                            *length,
+                            length * golden_ratio,
+                        ));
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl ToString for LineStyle {
+    fn to_string(&self) -> String {
+        match self {
+            LineStyle::Solid => "Solid".into(),
+            LineStyle::Dotted { spacing } => format!("Dotted{}Px", spacing),
+            LineStyle::Dashed { length } => format!("Dashed{}Px", length),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Determines whether a plot element is vertically or horizontally oriented.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Orientation {
+    Horizontal,
+    Vertical,
+}
+
+impl Default for Orientation {
+    fn default() -> Self {
+        Self::Vertical
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Represents many [`PlotPoint`]s.
+///
+/// These can be an owned `Vec` or generated with a function.
+pub enum PlotPoints {
+    Owned(Vec<PlotPoint>),
+    Generator(ExplicitGenerator),
+    // Borrowed(&[PlotPoint]), // TODO: Lifetimes are tricky in this case.
+}
+
+impl Default for PlotPoints {
+    fn default() -> Self {
+        Self::Owned(Vec::new())
+    }
+}
+
+impl From<[f64; 2]> for PlotPoints {
+    fn from(coordinate: [f64; 2]) -> Self {
+        Self::new(vec![coordinate])
+    }
+}
+
+impl From<Vec<[f64; 2]>> for PlotPoints {
+    fn from(coordinates: Vec<[f64; 2]>) -> Self {
+        Self::new(coordinates)
+    }
+}
+
+impl FromIterator<[f64; 2]> for PlotPoints {
+    fn from_iter<T: IntoIterator<Item = [f64; 2]>>(iter: T) -> Self {
+        Self::Owned(iter.into_iter().map(|point| point.into()).collect())
+    }
+}
+
+impl PlotPoints {
+    pub fn new(points: Vec<[f64; 2]>) -> Self {
+        Self::from_iter(points)
+    }
+
+    pub fn points(&self) -> &[PlotPoint] {
+        match self {
+            PlotPoints::Owned(points) => points.as_slice(),
+            PlotPoints::Generator(_) => &[],
+        }
+    }
+
+    /// Draw a line based on a function `y=f(x)`, a range (which can be infinite) for x and the number of points.
+    pub fn from_explicit_callback(
+        function: impl Fn(f64) -> f64 + 'static,
+        x_range: impl RangeBounds<f64>,
+        points: usize,
+    ) -> Self {
+        let start = match x_range.start_bound() {
+            Bound::Included(x) | Bound::Excluded(x) => *x,
+            Bound::Unbounded => f64::NEG_INFINITY,
+        };
+        let end = match x_range.end_bound() {
+            Bound::Included(x) | Bound::Excluded(x) => *x,
+            Bound::Unbounded => f64::INFINITY,
+        };
+        let x_range = start..=end;
+
+        let generator = ExplicitGenerator {
+            function: Box::new(function),
+            x_range,
+            points,
+        };
+
+        Self::Generator(generator)
+    }
+
+    /// Draw a line based on a function `(x,y)=f(t)`, a range for t and the number of points.
+    /// The range may be specified as start..end or as start..=end.
+    pub fn from_parametric_callback(
+        function: impl Fn(f64) -> (f64, f64),
+        t_range: impl RangeBounds<f64>,
+        points: usize,
+    ) -> Self {
+        let start = match t_range.start_bound() {
+            Bound::Included(x) => x,
+            Bound::Excluded(_) => unreachable!(),
+            Bound::Unbounded => panic!("The range for parametric functions must be bounded!"),
+        };
+        let end = match t_range.end_bound() {
+            Bound::Included(x) | Bound::Excluded(x) => x,
+            Bound::Unbounded => panic!("The range for parametric functions must be bounded!"),
+        };
+        let last_point_included = matches!(t_range.end_bound(), Bound::Included(_));
+        let increment = if last_point_included {
+            (end - start) / (points - 1) as f64
+        } else {
+            (end - start) / points as f64
+        };
+        (0..points)
+            .map(|i| {
+                let t = start + i as f64 * increment;
+                let (x, y) = function(t);
+                [x, y]
+            })
+            .collect()
+    }
+
+    /// From a series of y-values.
+    /// The x-values will be the indices of these values
+    pub fn from_ys_f32(ys: &[f32]) -> Self {
+        ys.iter()
+            .enumerate()
+            .map(|(i, &y)| [i as f64, y as f64])
+            .collect()
+    }
+
+    /// From a series of y-values.
+    /// The x-values will be the indices of these values
+    pub fn from_ys_f64(ys: &[f64]) -> Self {
+        ys.iter().enumerate().map(|(i, &y)| [i as f64, y]).collect()
+    }
+
+    /// Returns true if there are no data points available and there is no function to generate any.
+    pub(crate) fn is_empty(&self) -> bool {
+        match self {
+            PlotPoints::Owned(points) => points.is_empty(),
+            PlotPoints::Generator(_) => false,
+        }
+    }
+
+    /// If initialized with a generator function, this will generate `n` evenly spaced points in the
+    /// given range.
+    pub(super) fn generate_points(&mut self, x_range: RangeInclusive<f64>) {
+        if let Self::Generator(generator) = self {
+            *self = Self::range_intersection(&x_range, &generator.x_range)
+                .map(|intersection| {
+                    let increment =
+                        (intersection.end() - intersection.start()) / (generator.points - 1) as f64;
+                    (0..generator.points)
+                        .map(|i| {
+                            let x = intersection.start() + i as f64 * increment;
+                            let y = (generator.function)(x);
+                            [x, y]
+                        })
+                        .collect()
+                })
+                .unwrap_or_default();
+        }
+    }
+
+    /// Returns the intersection of two ranges if they intersect.
+    fn range_intersection(
+        range1: &RangeInclusive<f64>,
+        range2: &RangeInclusive<f64>,
+    ) -> Option<RangeInclusive<f64>> {
+        let start = range1.start().max(*range2.start());
+        let end = range1.end().min(*range2.end());
+        (start < end).then_some(start..=end)
+    }
+
+    pub(super) fn bounds(&self) -> PlotBounds {
+        match self {
+            PlotPoints::Owned(points) => {
+                let mut bounds = PlotBounds::NOTHING;
+                for point in points {
+                    bounds.extend_with(point);
+                }
+                bounds
+            }
+            PlotPoints::Generator(generator) => generator.estimate_bounds(),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum MarkerShape {
+    Circle,
+    Diamond,
+    Square,
+    Cross,
+    Plus,
+    Up,
+    Down,
+    Left,
+    Right,
+    Asterisk,
+}
+
+impl MarkerShape {
+    /// Get a vector containing all marker shapes.
+    pub fn all() -> impl ExactSizeIterator<Item = MarkerShape> {
+        [
+            Self::Circle,
+            Self::Diamond,
+            Self::Square,
+            Self::Cross,
+            Self::Plus,
+            Self::Up,
+            Self::Down,
+            Self::Left,
+            Self::Right,
+            Self::Asterisk,
+        ]
+        .iter()
+        .copied()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Query the points of the plot, for geometric relations like closest checks
+pub(crate) enum PlotGeometry<'a> {
+    /// No geometry based on single elements (examples: text, image, horizontal/vertical line)
+    None,
+
+    /// Point values (X-Y graphs)
+    Points(&'a [PlotPoint]),
+
+    /// Rectangles (examples: boxes or bars)
+    // Has currently no data, as it would require copying rects or iterating a list of pointers.
+    // Instead, geometry-based functions are directly implemented in the respective PlotItem impl.
+    Rects,
+}
+
+// ----------------------------------------------------------------------------
+
+/// Describes a function y = f(x) with an optional range for x and a number of points.
+pub struct ExplicitGenerator {
+    function: Box<dyn Fn(f64) -> f64>,
+    x_range: RangeInclusive<f64>,
+    points: usize,
+}
+
+impl ExplicitGenerator {
+    fn estimate_bounds(&self) -> PlotBounds {
+        let mut bounds = PlotBounds::NOTHING;
+
+        let mut add_x = |x: f64| {
+            // avoid infinities, as we cannot auto-bound on them!
+            if x.is_finite() {
+                bounds.extend_with_x(x);
+            }
+            let y = (self.function)(x);
+            if y.is_finite() {
+                bounds.extend_with_y(y);
+            }
+        };
+
+        let min_x = *self.x_range.start();
+        let max_x = *self.x_range.end();
+
+        add_x(min_x);
+        add_x(max_x);
+
+        if min_x.is_finite() && max_x.is_finite() {
+            // Sample some points in the interval:
+            const N: u32 = 8;
+            for i in 1..N {
+                let t = i as f64 / (N - 1) as f64;
+                let x = crate::lerp(min_x..=max_x, t);
+                add_x(x);
+            }
+        } else {
+            // Try adding some points anyway:
+            for x in [-1, 0, 1] {
+                let x = x as f64;
+                if min_x <= x && x <= max_x {
+                    add_x(x);
+                }
+            }
+        }
+
+        bounds
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Result of [`super::PlotItem::find_closest()`] search, identifies an element inside the item for immediate use
+pub(crate) struct ClosestElem {
+    /// Position of hovered-over value (or bar/box-plot/...) in PlotItem
+    pub index: usize,
+
+    /// Squared distance from the mouse cursor (needed to compare against other PlotItems, which might be nearer)
+    pub dist_sq: f32,
+}
diff --git a/egui/crates/egui/src/widgets/plot/legend.rs b/egui/crates/egui/src/widgets/plot/legend.rs
new file mode 100644
index 0000000..ab17f5b
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/legend.rs
@@ -0,0 +1,258 @@
+use std::{collections::BTreeMap, string::String};
+
+use crate::*;
+
+use super::items::PlotItem;
+
+/// Where to place the plot legend.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Corner {
+    LeftTop,
+    RightTop,
+    LeftBottom,
+    RightBottom,
+}
+
+impl Corner {
+    pub fn all() -> impl Iterator<Item = Corner> {
+        [
+            Corner::LeftTop,
+            Corner::RightTop,
+            Corner::LeftBottom,
+            Corner::RightBottom,
+        ]
+        .iter()
+        .copied()
+    }
+}
+
+/// The configuration for a plot legend.
+#[derive(Clone, PartialEq)]
+pub struct Legend {
+    pub text_style: TextStyle,
+    pub background_alpha: f32,
+    pub position: Corner,
+}
+
+impl Default for Legend {
+    fn default() -> Self {
+        Self {
+            text_style: TextStyle::Body,
+            background_alpha: 0.75,
+            position: Corner::RightTop,
+        }
+    }
+}
+
+impl Legend {
+    /// Which text style to use for the legend. Default: `TextStyle::Body`.
+    pub fn text_style(mut self, style: TextStyle) -> Self {
+        self.text_style = style;
+        self
+    }
+
+    /// The alpha of the legend background. Default: `0.75`.
+    pub fn background_alpha(mut self, alpha: f32) -> Self {
+        self.background_alpha = alpha;
+        self
+    }
+
+    /// In which corner to place the legend. Default: `Corner::RightTop`.
+    pub fn position(mut self, corner: Corner) -> Self {
+        self.position = corner;
+        self
+    }
+}
+
+#[derive(Clone)]
+struct LegendEntry {
+    color: Color32,
+    checked: bool,
+    hovered: bool,
+}
+
+impl LegendEntry {
+    fn new(color: Color32, checked: bool) -> Self {
+        Self {
+            color,
+            checked,
+            hovered: false,
+        }
+    }
+
+    fn ui(&mut self, ui: &mut Ui, text: String, text_style: &TextStyle) -> Response {
+        let Self {
+            color,
+            checked,
+            hovered,
+        } = self;
+
+        let font_id = text_style.resolve(ui.style());
+
+        let galley = ui.fonts(|f| f.layout_delayed_color(text, font_id, f32::INFINITY));
+
+        let icon_size = galley.size().y;
+        let icon_spacing = icon_size / 5.0;
+        let total_extra = vec2(icon_size + icon_spacing, 0.0);
+
+        let desired_size = total_extra + galley.size();
+        let (rect, response) = ui.allocate_exact_size(desired_size, Sense::click());
+
+        response
+            .widget_info(|| WidgetInfo::selected(WidgetType::Checkbox, *checked, galley.text()));
+
+        let visuals = ui.style().interact(&response);
+        let label_on_the_left = ui.layout().horizontal_placement() == Align::RIGHT;
+
+        let icon_position_x = if label_on_the_left {
+            rect.right() - icon_size / 2.0
+        } else {
+            rect.left() + icon_size / 2.0
+        };
+        let icon_position = pos2(icon_position_x, rect.center().y);
+        let icon_rect = Rect::from_center_size(icon_position, vec2(icon_size, icon_size));
+
+        let painter = ui.painter();
+
+        painter.add(epaint::CircleShape {
+            center: icon_rect.center(),
+            radius: icon_size * 0.5,
+            fill: visuals.bg_fill,
+            stroke: visuals.bg_stroke,
+        });
+
+        if *checked {
+            let fill = if *color == Color32::TRANSPARENT {
+                ui.visuals().noninteractive().fg_stroke.color
+            } else {
+                *color
+            };
+            painter.add(epaint::Shape::circle_filled(
+                icon_rect.center(),
+                icon_size * 0.4,
+                fill,
+            ));
+        }
+
+        let text_position_x = if label_on_the_left {
+            rect.right() - icon_size - icon_spacing - galley.size().x
+        } else {
+            rect.left() + icon_size + icon_spacing
+        };
+
+        let text_position = pos2(text_position_x, rect.center().y - 0.5 * galley.size().y);
+        painter.galley_with_color(text_position, galley, visuals.text_color());
+
+        *checked ^= response.clicked_by(PointerButton::Primary);
+        *hovered = response.hovered();
+
+        response
+    }
+}
+
+#[derive(Clone)]
+pub(super) struct LegendWidget {
+    rect: Rect,
+    entries: BTreeMap<String, LegendEntry>,
+    config: Legend,
+}
+
+impl LegendWidget {
+    /// Create a new legend from items, the names of items that are hidden and the style of the
+    /// text. Returns `None` if the legend has no entries.
+    pub(super) fn try_new(
+        rect: Rect,
+        config: Legend,
+        items: &[Box<dyn PlotItem>],
+        hidden_items: &ahash::HashSet<String>,
+    ) -> Option<Self> {
+        // Collect the legend entries. If multiple items have the same name, they share a
+        // checkbox. If their colors don't match, we pick a neutral color for the checkbox.
+        let mut entries: BTreeMap<String, LegendEntry> = BTreeMap::new();
+        items
+            .iter()
+            .filter(|item| !item.name().is_empty())
+            .for_each(|item| {
+                entries
+                    .entry(item.name().to_owned())
+                    .and_modify(|entry| {
+                        if entry.color != item.color() {
+                            // Multiple items with different colors
+                            entry.color = Color32::TRANSPARENT;
+                        }
+                    })
+                    .or_insert_with(|| {
+                        let color = item.color();
+                        let checked = !hidden_items.contains(item.name());
+                        LegendEntry::new(color, checked)
+                    });
+            });
+        (!entries.is_empty()).then_some(Self {
+            rect,
+            entries,
+            config,
+        })
+    }
+
+    // Get the names of the hidden items.
+    pub fn hidden_items(&self) -> ahash::HashSet<String> {
+        self.entries
+            .iter()
+            .filter(|(_, entry)| !entry.checked)
+            .map(|(name, _)| name.clone())
+            .collect()
+    }
+
+    // Get the name of the hovered items.
+    pub fn hovered_entry_name(&self) -> Option<String> {
+        self.entries
+            .iter()
+            .find(|(_, entry)| entry.hovered)
+            .map(|(name, _)| name.to_string())
+    }
+}
+
+impl Widget for &mut LegendWidget {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let LegendWidget {
+            rect,
+            entries,
+            config,
+        } = self;
+
+        let main_dir = match config.position {
+            Corner::LeftTop | Corner::RightTop => Direction::TopDown,
+            Corner::LeftBottom | Corner::RightBottom => Direction::BottomUp,
+        };
+        let cross_align = match config.position {
+            Corner::LeftTop | Corner::LeftBottom => Align::LEFT,
+            Corner::RightTop | Corner::RightBottom => Align::RIGHT,
+        };
+        let layout = Layout::from_main_dir_and_cross_align(main_dir, cross_align);
+        let legend_pad = 4.0;
+        let legend_rect = rect.shrink(legend_pad);
+        let mut legend_ui = ui.child_ui(legend_rect, layout);
+        legend_ui
+            .scope(|ui| {
+                let background_frame = Frame {
+                    inner_margin: vec2(8.0, 4.0).into(),
+                    rounding: ui.style().visuals.window_rounding,
+                    shadow: epaint::Shadow::NONE,
+                    fill: ui.style().visuals.extreme_bg_color,
+                    stroke: ui.style().visuals.window_stroke(),
+                    ..Default::default()
+                }
+                .multiply_with_opacity(config.background_alpha);
+                background_frame
+                    .show(ui, |ui| {
+                        entries
+                            .iter_mut()
+                            .map(|(name, entry)| entry.ui(ui, name.clone(), &config.text_style))
+                            .reduce(|r1, r2| r1.union(r2))
+                            .unwrap()
+                    })
+                    .inner
+            })
+            .inner
+    }
+}
diff --git a/egui/crates/egui/src/widgets/plot/mod.rs b/egui/crates/egui/src/widgets/plot/mod.rs
new file mode 100644
index 0000000..8797d61
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/mod.rs
@@ -0,0 +1,1627 @@
+//! Simple plotting library.
+
+use ahash::HashMap;
+use std::ops::RangeInclusive;
+
+use crate::*;
+use epaint::util::FloatOrd;
+use epaint::Hsva;
+
+use items::PlotItem;
+use legend::LegendWidget;
+use transform::ScreenTransform;
+
+pub use items::{
+    Arrows, Bar, BarChart, BoxElem, BoxPlot, BoxSpread, HLine, Line, LineStyle, MarkerShape,
+    Orientation, PlotImage, PlotPoint, PlotPoints, Points, Polygon, Text, VLine,
+};
+pub use legend::{Corner, Legend};
+pub use transform::PlotBounds;
+
+use self::items::{horizontal_line, rulers_color, vertical_line};
+
+mod items;
+mod legend;
+mod transform;
+
+type LabelFormatterFn = dyn Fn(&str, &PlotPoint) -> String;
+type LabelFormatter = Option<Box<LabelFormatterFn>>;
+type AxisFormatterFn = dyn Fn(f64, &RangeInclusive<f64>) -> String;
+type AxisFormatter = Option<Box<AxisFormatterFn>>;
+
+type GridSpacerFn = dyn Fn(GridInput) -> Vec<GridMark>;
+type GridSpacer = Box<GridSpacerFn>;
+
+type CoordinatesFormatterFn = dyn Fn(&PlotPoint, &PlotBounds) -> String;
+
+/// Specifies the coordinates formatting when passed to [`Plot::coordinates_formatter`].
+pub struct CoordinatesFormatter {
+    function: Box<CoordinatesFormatterFn>,
+}
+
+impl CoordinatesFormatter {
+    /// Create a new formatter based on the pointer coordinate and the plot bounds.
+    pub fn new(function: impl Fn(&PlotPoint, &PlotBounds) -> String + 'static) -> Self {
+        Self {
+            function: Box::new(function),
+        }
+    }
+
+    /// Show a fixed number of decimal places.
+    pub fn with_decimals(num_decimals: usize) -> Self {
+        Self {
+            function: Box::new(move |value, _| {
+                format!("x: {:.d$}\ny: {:.d$}", value.x, value.y, d = num_decimals)
+            }),
+        }
+    }
+
+    fn format(&self, value: &PlotPoint, bounds: &PlotBounds) -> String {
+        (self.function)(value, bounds)
+    }
+}
+
+impl Default for CoordinatesFormatter {
+    fn default() -> Self {
+        Self::with_decimals(3)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+const MIN_LINE_SPACING_IN_POINTS: f64 = 6.0; // TODO(emilk): large enough for a wide label
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Copy, Clone)]
+struct AxisBools {
+    x: bool,
+    y: bool,
+}
+
+impl AxisBools {
+    #[inline]
+    fn any(&self) -> bool {
+        self.x || self.y
+    }
+}
+
+impl From<bool> for AxisBools {
+    fn from(val: bool) -> Self {
+        AxisBools { x: val, y: val }
+    }
+}
+
+/// Information about the plot that has to persist between frames.
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Clone)]
+struct PlotMemory {
+    /// Indicates if the user has modified the bounds, for example by moving or zooming,
+    /// or if the bounds should be calculated based by included point or auto bounds.
+    bounds_modified: AxisBools,
+    hovered_entry: Option<String>,
+    hidden_items: ahash::HashSet<String>,
+    last_screen_transform: ScreenTransform,
+    /// Allows to remember the first click position when performing a boxed zoom
+    last_click_pos_for_zoom: Option<Pos2>,
+}
+
+impl PlotMemory {
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        ctx.data_mut(|d| d.get_persisted(id))
+    }
+
+    pub fn store(self, ctx: &Context, id: Id) {
+        ctx.data_mut(|d| d.insert_persisted(id, self));
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Indicates a vertical or horizontal cursor line in plot coordinates.
+#[derive(Copy, Clone, PartialEq)]
+enum Cursor {
+    Horizontal { y: f64 },
+    Vertical { x: f64 },
+}
+
+/// Contains the cursors drawn for a plot widget in a single frame.
+#[derive(PartialEq, Clone)]
+struct PlotFrameCursors {
+    id: Id,
+    cursors: Vec<Cursor>,
+}
+
+#[derive(Default, Clone)]
+struct CursorLinkGroups(HashMap<Id, Vec<PlotFrameCursors>>);
+
+#[derive(Clone)]
+struct LinkedBounds {
+    bounds: PlotBounds,
+    bounds_modified: AxisBools,
+}
+
+#[derive(Default, Clone)]
+struct BoundsLinkGroups(HashMap<Id, LinkedBounds>);
+
+// ----------------------------------------------------------------------------
+
+/// A 2D plot, e.g. a graph of a function.
+///
+/// [`Plot`] supports multiple lines and points.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// use egui::plot::{Line, Plot, PlotPoints};
+/// let sin: PlotPoints = (0..1000).map(|i| {
+///     let x = i as f64 * 0.01;
+///     [x, x.sin()]
+/// }).collect();
+/// let line = Line::new(sin);
+/// Plot::new("my_plot").view_aspect(2.0).show(ui, |plot_ui| plot_ui.line(line));
+/// # });
+/// ```
+pub struct Plot {
+    id_source: Id,
+
+    center_x_axis: bool,
+    center_y_axis: bool,
+    allow_zoom: bool,
+    allow_drag: bool,
+    allow_scroll: bool,
+    allow_double_click_reset: bool,
+    allow_boxed_zoom: bool,
+    auto_bounds: AxisBools,
+    min_auto_bounds: PlotBounds,
+    margin_fraction: Vec2,
+    boxed_zoom_pointer_button: PointerButton,
+    linked_axes: Option<(Id, AxisBools)>,
+    linked_cursors: Option<(Id, AxisBools)>,
+
+    min_size: Vec2,
+    width: Option<f32>,
+    height: Option<f32>,
+    data_aspect: Option<f32>,
+    view_aspect: Option<f32>,
+
+    reset: bool,
+
+    show_x: bool,
+    show_y: bool,
+    label_formatter: LabelFormatter,
+    coordinates_formatter: Option<(Corner, CoordinatesFormatter)>,
+    axis_formatters: [AxisFormatter; 2],
+    legend_config: Option<Legend>,
+    show_background: bool,
+    show_axes: [bool; 2],
+
+    grid_spacers: [GridSpacer; 2],
+    sharp_grid_lines: bool,
+    clamp_grid: bool,
+}
+
+impl Plot {
+    /// Give a unique id for each plot within the same [`Ui`].
+    pub fn new(id_source: impl std::hash::Hash) -> Self {
+        Self {
+            id_source: Id::new(id_source),
+
+            center_x_axis: false,
+            center_y_axis: false,
+            allow_zoom: true,
+            allow_drag: true,
+            allow_scroll: true,
+            allow_double_click_reset: true,
+            allow_boxed_zoom: true,
+            auto_bounds: false.into(),
+            min_auto_bounds: PlotBounds::NOTHING,
+            margin_fraction: Vec2::splat(0.05),
+            boxed_zoom_pointer_button: PointerButton::Secondary,
+            linked_axes: None,
+            linked_cursors: None,
+
+            min_size: Vec2::splat(64.0),
+            width: None,
+            height: None,
+            data_aspect: None,
+            view_aspect: None,
+
+            reset: false,
+
+            show_x: true,
+            show_y: true,
+            label_formatter: None,
+            coordinates_formatter: None,
+            axis_formatters: [None, None], // [None; 2] requires Copy
+            legend_config: None,
+            show_background: true,
+            show_axes: [true; 2],
+
+            grid_spacers: [log_grid_spacer(10), log_grid_spacer(10)],
+            sharp_grid_lines: true,
+            clamp_grid: false,
+        }
+    }
+
+    /// width / height ratio of the data.
+    /// For instance, it can be useful to set this to `1.0` for when the two axes show the same
+    /// unit.
+    /// By default the plot window's aspect ratio is used.
+    pub fn data_aspect(mut self, data_aspect: f32) -> Self {
+        self.data_aspect = Some(data_aspect);
+        self
+    }
+
+    /// width / height ratio of the plot region.
+    /// By default no fixed aspect ratio is set (and width/height will fill the ui it is in).
+    pub fn view_aspect(mut self, view_aspect: f32) -> Self {
+        self.view_aspect = Some(view_aspect);
+        self
+    }
+
+    /// Width of plot. By default a plot will fill the ui it is in.
+    /// If you set [`Self::view_aspect`], the width can be calculated from the height.
+    pub fn width(mut self, width: f32) -> Self {
+        self.min_size.x = width;
+        self.width = Some(width);
+        self
+    }
+
+    /// Height of plot. By default a plot will fill the ui it is in.
+    /// If you set [`Self::view_aspect`], the height can be calculated from the width.
+    pub fn height(mut self, height: f32) -> Self {
+        self.min_size.y = height;
+        self.height = Some(height);
+        self
+    }
+
+    /// Minimum size of the plot view.
+    pub fn min_size(mut self, min_size: Vec2) -> Self {
+        self.min_size = min_size;
+        self
+    }
+
+    /// Show the x-value (e.g. when hovering). Default: `true`.
+    pub fn show_x(mut self, show_x: bool) -> Self {
+        self.show_x = show_x;
+        self
+    }
+
+    /// Show the y-value (e.g. when hovering). Default: `true`.
+    pub fn show_y(mut self, show_y: bool) -> Self {
+        self.show_y = show_y;
+        self
+    }
+
+    /// Always keep the x-axis centered. Default: `false`.
+    pub fn center_x_axis(mut self, on: bool) -> Self {
+        self.center_x_axis = on;
+        self
+    }
+
+    /// Always keep the y-axis centered. Default: `false`.
+    pub fn center_y_axis(mut self, on: bool) -> Self {
+        self.center_y_axis = on;
+        self
+    }
+
+    /// Whether to allow zooming in the plot. Default: `true`.
+    pub fn allow_zoom(mut self, on: bool) -> Self {
+        self.allow_zoom = on;
+        self
+    }
+
+    /// Whether to allow scrolling in the plot. Default: `true`.
+    pub fn allow_scroll(mut self, on: bool) -> Self {
+        self.allow_scroll = on;
+        self
+    }
+
+    /// Whether to allow double clicking to reset the view.
+    /// Default: `true`.
+    pub fn allow_double_click_reset(mut self, on: bool) -> Self {
+        self.allow_double_click_reset = on;
+        self
+    }
+
+    /// Set the side margin as a fraction of the plot size. Only used for auto bounds.
+    ///
+    /// For instance, a value of `0.1` will add 10% space on both sides.
+    pub fn set_margin_fraction(mut self, margin_fraction: Vec2) -> Self {
+        self.margin_fraction = margin_fraction;
+        self
+    }
+
+    /// Whether to allow zooming in the plot by dragging out a box with the secondary mouse button.
+    ///
+    /// Default: `true`.
+    pub fn allow_boxed_zoom(mut self, on: bool) -> Self {
+        self.allow_boxed_zoom = on;
+        self
+    }
+
+    /// Config the button pointer to use for boxed zooming. Default: [`Secondary`](PointerButton::Secondary)
+    pub fn boxed_zoom_pointer_button(mut self, boxed_zoom_pointer_button: PointerButton) -> Self {
+        self.boxed_zoom_pointer_button = boxed_zoom_pointer_button;
+        self
+    }
+
+    /// Whether to allow dragging in the plot to move the bounds. Default: `true`.
+    pub fn allow_drag(mut self, on: bool) -> Self {
+        self.allow_drag = on;
+        self
+    }
+
+    /// Provide a function to customize the on-hover label for the x and y axis
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// use egui::plot::{Line, Plot, PlotPoints};
+    /// let sin: PlotPoints = (0..1000).map(|i| {
+    ///     let x = i as f64 * 0.01;
+    ///     [x, x.sin()]
+    /// }).collect();
+    /// let line = Line::new(sin);
+    /// Plot::new("my_plot").view_aspect(2.0)
+    /// .label_formatter(|name, value| {
+    ///     if !name.is_empty() {
+    ///         format!("{}: {:.*}%", name, 1, value.y)
+    ///     } else {
+    ///         "".to_owned()
+    ///     }
+    /// })
+    /// .show(ui, |plot_ui| plot_ui.line(line));
+    /// # });
+    /// ```
+    pub fn label_formatter(
+        mut self,
+        label_formatter: impl Fn(&str, &PlotPoint) -> String + 'static,
+    ) -> Self {
+        self.label_formatter = Some(Box::new(label_formatter));
+        self
+    }
+
+    /// Show the pointer coordinates in the plot.
+    pub fn coordinates_formatter(
+        mut self,
+        position: Corner,
+        formatter: CoordinatesFormatter,
+    ) -> Self {
+        self.coordinates_formatter = Some((position, formatter));
+        self
+    }
+
+    /// Provide a function to customize the labels for the X axis based on the current visible value range.
+    ///
+    /// This is useful for custom input domains, e.g. date/time.
+    ///
+    /// If axis labels should not appear for certain values or beyond a certain zoom/resolution,
+    /// the formatter function can return empty strings. This is also useful if your domain is
+    /// discrete (e.g. only full days in a calendar).
+    pub fn x_axis_formatter(
+        mut self,
+        func: impl Fn(f64, &RangeInclusive<f64>) -> String + 'static,
+    ) -> Self {
+        self.axis_formatters[0] = Some(Box::new(func));
+        self
+    }
+
+    /// Provide a function to customize the labels for the Y axis based on the current value range.
+    ///
+    /// This is useful for custom value representation, e.g. percentage or units.
+    ///
+    /// If axis labels should not appear for certain values or beyond a certain zoom/resolution,
+    /// the formatter function can return empty strings. This is also useful if your Y values are
+    /// discrete (e.g. only integers).
+    pub fn y_axis_formatter(
+        mut self,
+        func: impl Fn(f64, &RangeInclusive<f64>) -> String + 'static,
+    ) -> Self {
+        self.axis_formatters[1] = Some(Box::new(func));
+        self
+    }
+
+    /// Configure how the grid in the background is spaced apart along the X axis.
+    ///
+    /// Default is a log-10 grid, i.e. every plot unit is divided into 10 other units.
+    ///
+    /// The function has this signature:
+    /// ```ignore
+    /// fn step_sizes(input: GridInput) -> Vec<GridMark>;
+    /// ```
+    ///
+    /// This function should return all marks along the visible range of the X axis.
+    /// `step_size` also determines how thick/faint each line is drawn.
+    /// For example, if x = 80..=230 is visible and you want big marks at steps of
+    /// 100 and small ones at 25, you can return:
+    /// ```no_run
+    /// # use egui::plot::GridMark;
+    /// vec![
+    ///    // 100s
+    ///    GridMark { value: 100.0, step_size: 100.0 },
+    ///    GridMark { value: 200.0, step_size: 100.0 },
+    ///
+    ///    // 25s
+    ///    GridMark { value: 125.0, step_size: 25.0 },
+    ///    GridMark { value: 150.0, step_size: 25.0 },
+    ///    GridMark { value: 175.0, step_size: 25.0 },
+    ///    GridMark { value: 225.0, step_size: 25.0 },
+    /// ];
+    /// # ()
+    /// ```
+    ///
+    /// There are helpers for common cases, see [`log_grid_spacer`] and [`uniform_grid_spacer`].
+    pub fn x_grid_spacer(mut self, spacer: impl Fn(GridInput) -> Vec<GridMark> + 'static) -> Self {
+        self.grid_spacers[0] = Box::new(spacer);
+        self
+    }
+
+    /// Default is a log-10 grid, i.e. every plot unit is divided into 10 other units.
+    ///
+    /// See [`Self::x_grid_spacer`] for explanation.
+    pub fn y_grid_spacer(mut self, spacer: impl Fn(GridInput) -> Vec<GridMark> + 'static) -> Self {
+        self.grid_spacers[1] = Box::new(spacer);
+        self
+    }
+
+    /// Clamp the grid to only be visible at the range of data where we have values.
+    ///
+    /// Default: `false`.
+    pub fn clamp_grid(mut self, clamp_grid: bool) -> Self {
+        self.clamp_grid = clamp_grid;
+        self
+    }
+
+    /// Expand bounds to include the given x value.
+    /// For instance, to always show the y axis, call `plot.include_x(0.0)`.
+    pub fn include_x(mut self, x: impl Into<f64>) -> Self {
+        self.min_auto_bounds.extend_with_x(x.into());
+        self
+    }
+
+    /// Expand bounds to include the given y value.
+    /// For instance, to always show the x axis, call `plot.include_y(0.0)`.
+    pub fn include_y(mut self, y: impl Into<f64>) -> Self {
+        self.min_auto_bounds.extend_with_y(y.into());
+        self
+    }
+
+    /// Expand bounds to fit all items across the x axis, including values given by `include_x`.
+    pub fn auto_bounds_x(mut self) -> Self {
+        self.auto_bounds.x = true;
+        self
+    }
+
+    /// Expand bounds to fit all items across the y axis, including values given by `include_y`.
+    pub fn auto_bounds_y(mut self) -> Self {
+        self.auto_bounds.y = true;
+        self
+    }
+
+    /// Show a legend including all named items.
+    pub fn legend(mut self, legend: Legend) -> Self {
+        self.legend_config = Some(legend);
+        self
+    }
+
+    /// Whether or not to show the background [`Rect`].
+    /// Can be useful to disable if the plot is overlaid over existing content.
+    /// Default: `true`.
+    pub fn show_background(mut self, show: bool) -> Self {
+        self.show_background = show;
+        self
+    }
+
+    /// Show the axes.
+    /// Can be useful to disable if the plot is overlaid over an existing grid or content.
+    /// Default: `[true; 2]`.
+    pub fn show_axes(mut self, show: [bool; 2]) -> Self {
+        self.show_axes = show;
+        self
+    }
+
+    /// Add this plot to an axis link group so that this plot will share the bounds with other plots in the
+    /// same group. A plot cannot belong to more than one axis group.
+    pub fn link_axis(mut self, group_id: impl Into<Id>, link_x: bool, link_y: bool) -> Self {
+        self.linked_axes = Some((
+            group_id.into(),
+            AxisBools {
+                x: link_x,
+                y: link_y,
+            },
+        ));
+        self
+    }
+
+    /// Add this plot to a cursor link group so that this plot will share the cursor position with other plots
+    /// in the same group. A plot cannot belong to more than one cursor group.
+    pub fn link_cursor(mut self, group_id: impl Into<Id>, link_x: bool, link_y: bool) -> Self {
+        self.linked_cursors = Some((
+            group_id.into(),
+            AxisBools {
+                x: link_x,
+                y: link_y,
+            },
+        ));
+        self
+    }
+
+    /// Round grid positions to full pixels to avoid aliasing. Improves plot appearance but might have an
+    /// undesired effect when shifting the plot bounds. Enabled by default.
+    pub fn sharp_grid_lines(mut self, enabled: bool) -> Self {
+        self.sharp_grid_lines = enabled;
+        self
+    }
+
+    /// Resets the plot.
+    pub fn reset(mut self) -> Self {
+        self.reset = true;
+        self
+    }
+
+    /// Interact with and add items to the plot and finally draw it.
+    pub fn show<R>(self, ui: &mut Ui, build_fn: impl FnOnce(&mut PlotUi) -> R) -> InnerResponse<R> {
+        self.show_dyn(ui, Box::new(build_fn))
+    }
+
+    fn show_dyn<'a, R>(
+        self,
+        ui: &mut Ui,
+        build_fn: Box<dyn FnOnce(&mut PlotUi) -> R + 'a>,
+    ) -> InnerResponse<R> {
+        let Self {
+            id_source,
+            center_x_axis,
+            center_y_axis,
+            allow_zoom,
+            allow_drag,
+            allow_scroll,
+            allow_double_click_reset,
+            allow_boxed_zoom,
+            boxed_zoom_pointer_button: boxed_zoom_pointer,
+            auto_bounds,
+            min_auto_bounds,
+            margin_fraction,
+            width,
+            height,
+            min_size,
+            data_aspect,
+            view_aspect,
+            mut show_x,
+            mut show_y,
+            label_formatter,
+            coordinates_formatter,
+            axis_formatters,
+            legend_config,
+            reset,
+            show_background,
+            show_axes,
+            linked_axes,
+            linked_cursors,
+
+            clamp_grid,
+            grid_spacers,
+            sharp_grid_lines,
+        } = self;
+
+        // Determine the size of the plot in the UI
+        let size = {
+            let width = width
+                .unwrap_or_else(|| {
+                    if let (Some(height), Some(aspect)) = (height, view_aspect) {
+                        height * aspect
+                    } else {
+                        ui.available_size_before_wrap().x
+                    }
+                })
+                .at_least(min_size.x);
+
+            let height = height
+                .unwrap_or_else(|| {
+                    if let Some(aspect) = view_aspect {
+                        width / aspect
+                    } else {
+                        ui.available_size_before_wrap().y
+                    }
+                })
+                .at_least(min_size.y);
+            vec2(width, height)
+        };
+
+        // Allocate the space.
+        let (rect, response) = ui.allocate_exact_size(size, Sense::drag());
+
+        // Load or initialize the memory.
+        let plot_id = ui.make_persistent_id(id_source);
+        ui.ctx().check_for_id_clash(plot_id, rect, "Plot");
+        let memory = if reset {
+            if let Some((name, _)) = linked_axes.as_ref() {
+                ui.memory_mut(|memory| {
+                    let link_groups: &mut BoundsLinkGroups =
+                        memory.data.get_temp_mut_or_default(Id::null());
+                    link_groups.0.remove(name);
+                });
+            };
+            None
+        } else {
+            PlotMemory::load(ui.ctx(), plot_id)
+        }
+        .unwrap_or_else(|| PlotMemory {
+            bounds_modified: false.into(),
+            hovered_entry: None,
+            hidden_items: Default::default(),
+            last_screen_transform: ScreenTransform::new(
+                rect,
+                min_auto_bounds,
+                center_x_axis,
+                center_y_axis,
+            ),
+            last_click_pos_for_zoom: None,
+        });
+
+        let PlotMemory {
+            mut bounds_modified,
+            mut hovered_entry,
+            mut hidden_items,
+            last_screen_transform,
+            mut last_click_pos_for_zoom,
+        } = memory;
+
+        // Call the plot build function.
+        let mut plot_ui = PlotUi {
+            items: Vec::new(),
+            next_auto_color_idx: 0,
+            last_screen_transform,
+            response,
+            bounds_modifications: Vec::new(),
+            ctx: ui.ctx().clone(),
+        };
+        let inner = build_fn(&mut plot_ui);
+        let PlotUi {
+            mut items,
+            mut response,
+            last_screen_transform,
+            bounds_modifications,
+            ..
+        } = plot_ui;
+
+        // Background
+        if show_background {
+            ui.painter().with_clip_rect(rect).add(epaint::RectShape {
+                rect,
+                rounding: Rounding::same(2.0),
+                fill: ui.visuals().extreme_bg_color,
+                stroke: ui.visuals().widgets.noninteractive.bg_stroke,
+            });
+        }
+
+        // --- Legend ---
+        let legend = legend_config
+            .and_then(|config| LegendWidget::try_new(rect, config, &items, &hidden_items));
+        // Don't show hover cursor when hovering over legend.
+        if hovered_entry.is_some() {
+            show_x = false;
+            show_y = false;
+        }
+        // Remove the deselected items.
+        items.retain(|item| !hidden_items.contains(item.name()));
+        // Highlight the hovered items.
+        if let Some(hovered_name) = &hovered_entry {
+            items
+                .iter_mut()
+                .filter(|entry| entry.name() == hovered_name)
+                .for_each(|entry| entry.highlight());
+        }
+        // Move highlighted items to front.
+        items.sort_by_key(|item| item.highlighted());
+
+        // --- Bound computation ---
+        let mut bounds = *last_screen_transform.bounds();
+
+        // Find the cursors from other plots we need to draw
+        let draw_cursors: Vec<Cursor> = if let Some((id, _)) = linked_cursors.as_ref() {
+            ui.memory_mut(|memory| {
+                let frames: &mut CursorLinkGroups = memory.data.get_temp_mut_or_default(Id::null());
+                let cursors = frames.0.entry(*id).or_default();
+
+                // Look for our previous frame
+                let index = cursors
+                    .iter()
+                    .enumerate()
+                    .find(|(_, frame)| frame.id == plot_id)
+                    .map(|(i, _)| i);
+
+                // Remove our previous frame and all older frames as these are no longer displayed. This avoids
+                // unbounded growth, as we add an entry each time we draw a plot.
+                index.map(|index| cursors.drain(0..=index));
+
+                // Gather all cursors of the remaining frames. This will be all the cursors of the
+                // other plots in the group. We want to draw these in the current plot too.
+                cursors
+                    .iter()
+                    .flat_map(|frame| frame.cursors.iter().copied())
+                    .collect()
+            })
+        } else {
+            Vec::new()
+        };
+
+        // Transfer the bounds from a link group.
+        if let Some((id, axes)) = linked_axes.as_ref() {
+            ui.memory_mut(|memory| {
+                let link_groups: &mut BoundsLinkGroups =
+                    memory.data.get_temp_mut_or_default(Id::null());
+                if let Some(linked_bounds) = link_groups.0.get(id) {
+                    if axes.x {
+                        bounds.set_x(&linked_bounds.bounds);
+                        bounds_modified.x = linked_bounds.bounds_modified.x;
+                    }
+                    if axes.y {
+                        bounds.set_y(&linked_bounds.bounds);
+                        bounds_modified.y = linked_bounds.bounds_modified.y;
+                    }
+                };
+            });
+        };
+
+        // Allow double clicking to reset to the initial bounds.
+        if allow_double_click_reset && response.double_clicked() {
+            bounds_modified = false.into();
+        }
+
+        // Apply bounds modifications.
+        for modification in bounds_modifications {
+            match modification {
+                BoundsModification::Set(new_bounds) => {
+                    bounds = new_bounds;
+                    bounds_modified = true.into();
+                }
+                BoundsModification::Translate(delta) => {
+                    bounds.translate(delta);
+                    bounds_modified = true.into();
+                }
+            }
+        }
+
+        // Reset bounds to initial bounds if they haven't been modified.
+        if !bounds_modified.x {
+            bounds.set_x(&min_auto_bounds);
+        }
+        if !bounds_modified.y {
+            bounds.set_y(&min_auto_bounds);
+        }
+
+        let auto_x = !bounds_modified.x && (!min_auto_bounds.is_valid_x() || auto_bounds.x);
+        let auto_y = !bounds_modified.y && (!min_auto_bounds.is_valid_y() || auto_bounds.y);
+
+        // Set bounds automatically based on content.
+        if auto_x || auto_y {
+            for item in &items {
+                let item_bounds = item.bounds();
+                if auto_x {
+                    bounds.merge_x(&item_bounds);
+                }
+                if auto_y {
+                    bounds.merge_y(&item_bounds);
+                }
+            }
+
+            if auto_x {
+                bounds.add_relative_margin_x(margin_fraction);
+            }
+
+            if auto_y {
+                bounds.add_relative_margin_y(margin_fraction);
+            }
+        }
+
+        let mut transform = ScreenTransform::new(rect, bounds, center_x_axis, center_y_axis);
+
+        // Enforce aspect ratio
+        if let Some(data_aspect) = data_aspect {
+            if let Some((_, linked_axes)) = &linked_axes {
+                let change_x = linked_axes.y && !linked_axes.x;
+                transform.set_aspect_by_changing_axis(data_aspect as f64, change_x);
+            } else if auto_bounds.any() {
+                transform.set_aspect_by_expanding(data_aspect as f64);
+            } else {
+                transform.set_aspect_by_changing_axis(data_aspect as f64, false);
+            }
+        }
+
+        // Dragging
+        if allow_drag && response.dragged_by(PointerButton::Primary) {
+            response = response.on_hover_cursor(CursorIcon::Grabbing);
+            transform.translate_bounds(-response.drag_delta());
+            bounds_modified = true.into();
+        }
+
+        // Zooming
+        let mut boxed_zoom_rect = None;
+        if allow_boxed_zoom {
+            // Save last click to allow boxed zooming
+            if response.drag_started() && response.dragged_by(boxed_zoom_pointer) {
+                // it would be best for egui that input has a memory of the last click pos because it's a common pattern
+                last_click_pos_for_zoom = response.hover_pos();
+            }
+            let box_start_pos = last_click_pos_for_zoom;
+            let box_end_pos = response.hover_pos();
+            if let (Some(box_start_pos), Some(box_end_pos)) = (box_start_pos, box_end_pos) {
+                // while dragging prepare a Shape and draw it later on top of the plot
+                if response.dragged_by(boxed_zoom_pointer) {
+                    response = response.on_hover_cursor(CursorIcon::ZoomIn);
+                    let rect = epaint::Rect::from_two_pos(box_start_pos, box_end_pos);
+                    boxed_zoom_rect = Some((
+                        epaint::RectShape::stroke(
+                            rect,
+                            0.0,
+                            epaint::Stroke::new(4., Color32::DARK_BLUE),
+                        ), // Outer stroke
+                        epaint::RectShape::stroke(
+                            rect,
+                            0.0,
+                            epaint::Stroke::new(2., Color32::WHITE),
+                        ), // Inner stroke
+                    ));
+                }
+                // when the click is release perform the zoom
+                if response.drag_released() {
+                    let box_start_pos = transform.value_from_position(box_start_pos);
+                    let box_end_pos = transform.value_from_position(box_end_pos);
+                    let new_bounds = PlotBounds {
+                        min: [
+                            box_start_pos.x.min(box_end_pos.x),
+                            box_start_pos.y.min(box_end_pos.y),
+                        ],
+                        max: [
+                            box_start_pos.x.max(box_end_pos.x),
+                            box_start_pos.y.max(box_end_pos.y),
+                        ],
+                    };
+                    if new_bounds.is_valid() {
+                        transform.set_bounds(new_bounds);
+                        bounds_modified = true.into();
+                    }
+                    // reset the boxed zoom state
+                    last_click_pos_for_zoom = None;
+                }
+            }
+        }
+
+        let hover_pos = response.hover_pos();
+        if let Some(hover_pos) = hover_pos {
+            if allow_zoom {
+                let zoom_factor = if data_aspect.is_some() {
+                    Vec2::splat(ui.input(|i| i.zoom_delta()))
+                } else {
+                    ui.input(|i| i.zoom_delta_2d())
+                };
+                if zoom_factor != Vec2::splat(1.0) {
+                    transform.zoom(zoom_factor, hover_pos);
+                    bounds_modified = true.into();
+                }
+            }
+            if allow_scroll {
+                let scroll_delta = ui.input(|i| i.scroll_delta);
+                if scroll_delta != Vec2::ZERO {
+                    transform.translate_bounds(-scroll_delta);
+                    bounds_modified = true.into();
+                }
+            }
+        }
+
+        // Initialize values from functions.
+        for item in &mut items {
+            item.initialize(transform.bounds().range_x());
+        }
+
+        let prepared = PreparedPlot {
+            items,
+            show_x,
+            show_y,
+            label_formatter,
+            coordinates_formatter,
+            axis_formatters,
+            show_axes,
+            transform: transform.clone(),
+            draw_cursor_x: linked_cursors.as_ref().map_or(false, |(_, group)| group.x),
+            draw_cursor_y: linked_cursors.as_ref().map_or(false, |(_, group)| group.y),
+            draw_cursors,
+            grid_spacers,
+            sharp_grid_lines,
+            clamp_grid,
+        };
+        let plot_cursors = prepared.ui(ui, &response);
+
+        if let Some(boxed_zoom_rect) = boxed_zoom_rect {
+            ui.painter().with_clip_rect(rect).add(boxed_zoom_rect.0);
+            ui.painter().with_clip_rect(rect).add(boxed_zoom_rect.1);
+        }
+
+        if let Some(mut legend) = legend {
+            ui.add(&mut legend);
+            hidden_items = legend.hidden_items();
+            hovered_entry = legend.hovered_entry_name();
+        }
+
+        if let Some((id, _)) = linked_cursors.as_ref() {
+            // Push the frame we just drew to the list of frames
+            ui.memory_mut(|memory| {
+                let frames: &mut CursorLinkGroups = memory.data.get_temp_mut_or_default(Id::null());
+                let cursors = frames.0.entry(*id).or_default();
+                cursors.push(PlotFrameCursors {
+                    id: plot_id,
+                    cursors: plot_cursors,
+                });
+            });
+        }
+
+        if let Some((id, _)) = linked_axes.as_ref() {
+            // Save the linked bounds.
+            ui.memory_mut(|memory| {
+                let link_groups: &mut BoundsLinkGroups =
+                    memory.data.get_temp_mut_or_default(Id::null());
+                link_groups.0.insert(
+                    *id,
+                    LinkedBounds {
+                        bounds: *transform.bounds(),
+                        bounds_modified,
+                    },
+                );
+            });
+        }
+
+        let memory = PlotMemory {
+            bounds_modified,
+            hovered_entry,
+            hidden_items,
+            last_screen_transform: transform,
+            last_click_pos_for_zoom,
+        };
+        memory.store(ui.ctx(), plot_id);
+
+        let response = if show_x || show_y {
+            response.on_hover_cursor(CursorIcon::Crosshair)
+        } else {
+            response
+        };
+
+        InnerResponse { inner, response }
+    }
+}
+
+/// User-requested modifications to the plot bounds. We collect them in the plot build function to later apply
+/// them at the right time, as other modifications need to happen first.
+enum BoundsModification {
+    Set(PlotBounds),
+    Translate(Vec2),
+}
+
+/// Provides methods to interact with a plot while building it. It is the single argument of the closure
+/// provided to [`Plot::show`]. See [`Plot`] for an example of how to use it.
+pub struct PlotUi {
+    items: Vec<Box<dyn PlotItem>>,
+    next_auto_color_idx: usize,
+    last_screen_transform: ScreenTransform,
+    response: Response,
+    bounds_modifications: Vec<BoundsModification>,
+    ctx: Context,
+}
+
+impl PlotUi {
+    fn auto_color(&mut self) -> Color32 {
+        let i = self.next_auto_color_idx;
+        self.next_auto_color_idx += 1;
+        let golden_ratio = (5.0_f32.sqrt() - 1.0) / 2.0; // 0.61803398875
+        let h = i as f32 * golden_ratio;
+        Hsva::new(h, 0.85, 0.5, 1.0).into() // TODO(emilk): OkLab or some other perspective color space
+    }
+
+    pub fn ctx(&self) -> &Context {
+        &self.ctx
+    }
+
+    /// The plot bounds as they were in the last frame. If called on the first frame and the bounds were not
+    /// further specified in the plot builder, this will return bounds centered on the origin. The bounds do
+    /// not change until the plot is drawn.
+    pub fn plot_bounds(&self) -> PlotBounds {
+        *self.last_screen_transform.bounds()
+    }
+
+    /// Set the plot bounds. Can be useful for implementing alternative plot navigation methods.
+    pub fn set_plot_bounds(&mut self, plot_bounds: PlotBounds) {
+        self.bounds_modifications
+            .push(BoundsModification::Set(plot_bounds));
+    }
+
+    /// Move the plot bounds. Can be useful for implementing alternative plot navigation methods.
+    pub fn translate_bounds(&mut self, delta_pos: Vec2) {
+        self.bounds_modifications
+            .push(BoundsModification::Translate(delta_pos));
+    }
+
+    /// Returns `true` if the plot area is currently hovered.
+    pub fn plot_hovered(&self) -> bool {
+        self.response.hovered()
+    }
+
+    /// Returns `true` if the plot was clicked by the primary button.
+    pub fn plot_clicked(&self) -> bool {
+        self.response.clicked()
+    }
+
+    /// Returns `true` if the plot was clicked by the secondary button.
+    pub fn plot_secondary_clicked(&self) -> bool {
+        self.response.secondary_clicked()
+    }
+
+    /// The pointer position in plot coordinates. Independent of whether the pointer is in the plot area.
+    pub fn pointer_coordinate(&self) -> Option<PlotPoint> {
+        // We need to subtract the drag delta to keep in sync with the frame-delayed screen transform:
+        let last_pos = self.ctx().input(|i| i.pointer.latest_pos())? - self.response.drag_delta();
+        let value = self.plot_from_screen(last_pos);
+        Some(value)
+    }
+
+    /// The pointer drag delta in plot coordinates.
+    pub fn pointer_coordinate_drag_delta(&self) -> Vec2 {
+        let delta = self.response.drag_delta();
+        let dp_dv = self.last_screen_transform.dpos_dvalue();
+        Vec2::new(delta.x / dp_dv[0] as f32, delta.y / dp_dv[1] as f32)
+    }
+
+    /// Transform the plot coordinates to screen coordinates.
+    pub fn screen_from_plot(&self, position: PlotPoint) -> Pos2 {
+        self.last_screen_transform.position_from_point(&position)
+    }
+
+    /// Transform the screen coordinates to plot coordinates.
+    pub fn plot_from_screen(&self, position: Pos2) -> PlotPoint {
+        self.last_screen_transform.value_from_position(position)
+    }
+
+    /// Add a data line.
+    pub fn line(&mut self, mut line: Line) {
+        if line.series.is_empty() {
+            return;
+        };
+
+        // Give the stroke an automatic color if no color has been assigned.
+        if line.stroke.color == Color32::TRANSPARENT {
+            line.stroke.color = self.auto_color();
+        }
+        self.items.push(Box::new(line));
+    }
+
+    /// Add a polygon. The polygon has to be convex.
+    pub fn polygon(&mut self, mut polygon: Polygon) {
+        if polygon.series.is_empty() {
+            return;
+        };
+
+        // Give the stroke an automatic color if no color has been assigned.
+        if polygon.stroke.color == Color32::TRANSPARENT {
+            polygon.stroke.color = self.auto_color();
+        }
+        self.items.push(Box::new(polygon));
+    }
+
+    /// Add a text.
+    pub fn text(&mut self, text: Text) {
+        if text.text.is_empty() {
+            return;
+        };
+
+        self.items.push(Box::new(text));
+    }
+
+    /// Add data points.
+    pub fn points(&mut self, mut points: Points) {
+        if points.series.is_empty() {
+            return;
+        };
+
+        // Give the points an automatic color if no color has been assigned.
+        if points.color == Color32::TRANSPARENT {
+            points.color = self.auto_color();
+        }
+        self.items.push(Box::new(points));
+    }
+
+    /// Add arrows.
+    pub fn arrows(&mut self, mut arrows: Arrows) {
+        if arrows.origins.is_empty() || arrows.tips.is_empty() {
+            return;
+        };
+
+        // Give the arrows an automatic color if no color has been assigned.
+        if arrows.color == Color32::TRANSPARENT {
+            arrows.color = self.auto_color();
+        }
+        self.items.push(Box::new(arrows));
+    }
+
+    /// Add an image.
+    pub fn image(&mut self, image: PlotImage) {
+        self.items.push(Box::new(image));
+    }
+
+    /// Add a horizontal line.
+    /// Can be useful e.g. to show min/max bounds or similar.
+    /// Always fills the full width of the plot.
+    pub fn hline(&mut self, mut hline: HLine) {
+        if hline.stroke.color == Color32::TRANSPARENT {
+            hline.stroke.color = self.auto_color();
+        }
+        self.items.push(Box::new(hline));
+    }
+
+    /// Add a vertical line.
+    /// Can be useful e.g. to show min/max bounds or similar.
+    /// Always fills the full height of the plot.
+    pub fn vline(&mut self, mut vline: VLine) {
+        if vline.stroke.color == Color32::TRANSPARENT {
+            vline.stroke.color = self.auto_color();
+        }
+        self.items.push(Box::new(vline));
+    }
+
+    /// Add a box plot diagram.
+    pub fn box_plot(&mut self, mut box_plot: BoxPlot) {
+        if box_plot.boxes.is_empty() {
+            return;
+        }
+
+        // Give the elements an automatic color if no color has been assigned.
+        if box_plot.default_color == Color32::TRANSPARENT {
+            box_plot = box_plot.color(self.auto_color());
+        }
+        self.items.push(Box::new(box_plot));
+    }
+
+    /// Add a bar chart.
+    pub fn bar_chart(&mut self, mut chart: BarChart) {
+        if chart.bars.is_empty() {
+            return;
+        }
+
+        // Give the elements an automatic color if no color has been assigned.
+        if chart.default_color == Color32::TRANSPARENT {
+            chart = chart.color(self.auto_color());
+        }
+        self.items.push(Box::new(chart));
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Grid
+
+/// Input for "grid spacer" functions.
+///
+/// See [`Plot::x_grid_spacer()`] and [`Plot::y_grid_spacer()`].
+pub struct GridInput {
+    /// Min/max of the visible data range (the values at the two edges of the plot,
+    /// for the current axis).
+    pub bounds: (f64, f64),
+
+    /// Recommended (but not required) lower-bound on the step size returned by custom grid spacers.
+    ///
+    /// Computed as the ratio between the diagram's bounds (in plot coordinates) and the viewport
+    /// (in frame/window coordinates), scaled up to represent the minimal possible step.
+    pub base_step_size: f64,
+}
+
+/// One mark (horizontal or vertical line) in the background grid of a plot.
+pub struct GridMark {
+    /// X or Y value in the plot.
+    pub value: f64,
+
+    /// The (approximate) distance to the next value of same thickness.
+    ///
+    /// Determines how thick the grid line is painted. It's not important that `step_size`
+    /// matches the difference between two `value`s precisely, but rather that grid marks of
+    /// same thickness have same `step_size`. For example, months can have a different number
+    /// of days, but consistently using a `step_size` of 30 days is a valid approximation.
+    pub step_size: f64,
+}
+
+/// Recursively splits the grid into `base` subdivisions (e.g. 100, 10, 1).
+///
+/// The logarithmic base, expressing how many times each grid unit is subdivided.
+/// 10 is a typical value, others are possible though.
+pub fn log_grid_spacer(log_base: i64) -> GridSpacer {
+    let log_base = log_base as f64;
+    let step_sizes = move |input: GridInput| -> Vec<GridMark> {
+        // The distance between two of the thinnest grid lines is "rounded" up
+        // to the next-bigger power of base
+        let smallest_visible_unit = next_power(input.base_step_size, log_base);
+
+        let step_sizes = [
+            smallest_visible_unit,
+            smallest_visible_unit * log_base,
+            smallest_visible_unit * log_base * log_base,
+        ];
+
+        generate_marks(step_sizes, input.bounds)
+    };
+
+    Box::new(step_sizes)
+}
+
+/// Splits the grid into uniform-sized spacings (e.g. 100, 25, 1).
+///
+/// This function should return 3 positive step sizes, designating where the lines in the grid are drawn.
+/// Lines are thicker for larger step sizes. Ordering of returned value is irrelevant.
+///
+/// Why only 3 step sizes? Three is the number of different line thicknesses that egui typically uses in the grid.
+/// Ideally, those 3 are not hardcoded values, but depend on the visible range (accessible through `GridInput`).
+pub fn uniform_grid_spacer(spacer: impl Fn(GridInput) -> [f64; 3] + 'static) -> GridSpacer {
+    let get_marks = move |input: GridInput| -> Vec<GridMark> {
+        let bounds = input.bounds;
+        let step_sizes = spacer(input);
+        generate_marks(step_sizes, bounds)
+    };
+
+    Box::new(get_marks)
+}
+
+// ----------------------------------------------------------------------------
+
+struct PreparedPlot {
+    items: Vec<Box<dyn PlotItem>>,
+    show_x: bool,
+    show_y: bool,
+    label_formatter: LabelFormatter,
+    coordinates_formatter: Option<(Corner, CoordinatesFormatter)>,
+    axis_formatters: [AxisFormatter; 2],
+    show_axes: [bool; 2],
+    transform: ScreenTransform,
+    draw_cursor_x: bool,
+    draw_cursor_y: bool,
+    draw_cursors: Vec<Cursor>,
+
+    grid_spacers: [GridSpacer; 2],
+    sharp_grid_lines: bool,
+    clamp_grid: bool,
+}
+
+impl PreparedPlot {
+    fn ui(self, ui: &mut Ui, response: &Response) -> Vec<Cursor> {
+        let mut axes_shapes = Vec::new();
+
+        for d in 0..2 {
+            if self.show_axes[d] {
+                self.paint_axis(
+                    ui,
+                    d,
+                    self.show_axes[1 - d],
+                    &mut axes_shapes,
+                    self.sharp_grid_lines,
+                );
+            }
+        }
+
+        // Sort the axes by strength so that those with higher strength are drawn in front.
+        axes_shapes.sort_by(|(_, strength1), (_, strength2)| strength1.total_cmp(strength2));
+
+        let mut shapes = axes_shapes.into_iter().map(|(shape, _)| shape).collect();
+
+        let transform = &self.transform;
+
+        let mut plot_ui = ui.child_ui(*transform.frame(), Layout::default());
+        plot_ui.set_clip_rect(*transform.frame());
+        for item in &self.items {
+            item.shapes(&mut plot_ui, transform, &mut shapes);
+        }
+
+        let hover_pos = response.hover_pos();
+        let cursors = if let Some(pointer) = hover_pos {
+            self.hover(ui, pointer, &mut shapes)
+        } else {
+            Vec::new()
+        };
+
+        // Draw cursors
+        let line_color = rulers_color(ui);
+
+        let mut draw_cursor = |cursors: &Vec<Cursor>, always| {
+            for &cursor in cursors {
+                match cursor {
+                    Cursor::Horizontal { y } => {
+                        if self.draw_cursor_y || always {
+                            shapes.push(horizontal_line(
+                                transform.position_from_point(&PlotPoint::new(0.0, y)),
+                                &self.transform,
+                                line_color,
+                            ));
+                        }
+                    }
+                    Cursor::Vertical { x } => {
+                        if self.draw_cursor_x || always {
+                            shapes.push(vertical_line(
+                                transform.position_from_point(&PlotPoint::new(x, 0.0)),
+                                &self.transform,
+                                line_color,
+                            ));
+                        }
+                    }
+                }
+            }
+        };
+
+        draw_cursor(&self.draw_cursors, false);
+        draw_cursor(&cursors, true);
+
+        let painter = ui.painter().with_clip_rect(*transform.frame());
+        painter.extend(shapes);
+
+        if let Some((corner, formatter)) = self.coordinates_formatter.as_ref() {
+            let hover_pos = response.hover_pos();
+            if let Some(pointer) = hover_pos {
+                let font_id = TextStyle::Monospace.resolve(ui.style());
+                let coordinate = transform.value_from_position(pointer);
+                let text = formatter.format(&coordinate, transform.bounds());
+                let padded_frame = transform.frame().shrink(4.0);
+                let (anchor, position) = match corner {
+                    Corner::LeftTop => (Align2::LEFT_TOP, padded_frame.left_top()),
+                    Corner::RightTop => (Align2::RIGHT_TOP, padded_frame.right_top()),
+                    Corner::LeftBottom => (Align2::LEFT_BOTTOM, padded_frame.left_bottom()),
+                    Corner::RightBottom => (Align2::RIGHT_BOTTOM, padded_frame.right_bottom()),
+                };
+                painter.text(position, anchor, text, font_id, ui.visuals().text_color());
+            }
+        }
+
+        cursors
+    }
+
+    fn paint_axis(
+        &self,
+        ui: &Ui,
+        axis: usize,
+        other_axis_shown: bool,
+        shapes: &mut Vec<(Shape, f32)>,
+        sharp_grid_lines: bool,
+    ) {
+        #![allow(clippy::collapsible_else_if)]
+
+        let Self {
+            transform,
+            axis_formatters,
+            grid_spacers,
+            clamp_grid,
+            ..
+        } = self;
+
+        let bounds = transform.bounds();
+        let axis_range = match axis {
+            0 => bounds.range_x(),
+            1 => bounds.range_y(),
+            _ => panic!("Axis {} does not exist.", axis),
+        };
+
+        let font_id = TextStyle::Body.resolve(ui.style());
+
+        // Where on the cross-dimension to show the label values
+        let value_cross = 0.0_f64.clamp(bounds.min[1 - axis], bounds.max[1 - axis]);
+
+        let input = GridInput {
+            bounds: (bounds.min[axis], bounds.max[axis]),
+            base_step_size: transform.dvalue_dpos()[axis] * MIN_LINE_SPACING_IN_POINTS,
+        };
+        let steps = (grid_spacers[axis])(input);
+
+        let clamp_range = clamp_grid.then(|| {
+            let mut tight_bounds = PlotBounds::NOTHING;
+            for item in &self.items {
+                let item_bounds = item.bounds();
+                tight_bounds.merge_x(&item_bounds);
+                tight_bounds.merge_y(&item_bounds);
+            }
+            tight_bounds
+        });
+
+        for step in steps {
+            let value_main = step.value;
+
+            if let Some(clamp_range) = clamp_range {
+                if axis == 0 {
+                    if !clamp_range.range_x().contains(&value_main) {
+                        continue;
+                    };
+                } else {
+                    if !clamp_range.range_y().contains(&value_main) {
+                        continue;
+                    };
+                }
+            }
+
+            let value = if axis == 0 {
+                PlotPoint::new(value_main, value_cross)
+            } else {
+                PlotPoint::new(value_cross, value_main)
+            };
+
+            let pos_in_gui = transform.position_from_point(&value);
+            let spacing_in_points = (transform.dpos_dvalue()[axis] * step.step_size).abs() as f32;
+
+            if spacing_in_points > MIN_LINE_SPACING_IN_POINTS as f32 {
+                let line_strength = remap_clamp(
+                    spacing_in_points,
+                    MIN_LINE_SPACING_IN_POINTS as f32..=300.0,
+                    0.0..=1.0,
+                );
+
+                let line_color = color_from_contrast(ui, line_strength);
+
+                let mut p0 = pos_in_gui;
+                let mut p1 = pos_in_gui;
+                p0[1 - axis] = transform.frame().min[1 - axis];
+                p1[1 - axis] = transform.frame().max[1 - axis];
+
+                if let Some(clamp_range) = clamp_range {
+                    if axis == 0 {
+                        p0.y = transform.position_from_point_y(clamp_range.min[1]);
+                        p1.y = transform.position_from_point_y(clamp_range.max[1]);
+                    } else {
+                        p0.x = transform.position_from_point_x(clamp_range.min[0]);
+                        p1.x = transform.position_from_point_x(clamp_range.max[0]);
+                    }
+                }
+
+                if sharp_grid_lines {
+                    // Round to avoid aliasing
+                    p0 = ui.ctx().round_pos_to_pixels(p0);
+                    p1 = ui.ctx().round_pos_to_pixels(p1);
+                }
+
+                shapes.push((
+                    Shape::line_segment([p0, p1], Stroke::new(1.0, line_color)),
+                    line_strength,
+                ));
+            }
+
+            const MIN_TEXT_SPACING: f32 = 40.0;
+            if spacing_in_points > MIN_TEXT_SPACING {
+                let text_strength =
+                    remap_clamp(spacing_in_points, MIN_TEXT_SPACING..=150.0, 0.0..=1.0);
+                let color = color_from_contrast(ui, text_strength);
+
+                let text: String = if let Some(formatter) = axis_formatters[axis].as_deref() {
+                    formatter(value_main, &axis_range)
+                } else {
+                    emath::round_to_decimals(value_main, 5).to_string() // hack
+                };
+
+                // Skip origin label for y-axis if x-axis is already showing it (otherwise displayed twice)
+                let skip_origin_y = axis == 1 && other_axis_shown && value_main == 0.0;
+
+                // Custom formatters can return empty string to signal "no label at this resolution"
+                if !text.is_empty() && !skip_origin_y {
+                    let galley = ui.painter().layout_no_wrap(text, font_id.clone(), color);
+
+                    let mut text_pos = pos_in_gui + vec2(1.0, -galley.size().y);
+
+                    // Make sure we see the labels, even if the axis is off-screen:
+                    text_pos[1 - axis] = text_pos[1 - axis]
+                        .at_most(transform.frame().max[1 - axis] - galley.size()[1 - axis] - 2.0)
+                        .at_least(transform.frame().min[1 - axis] + 1.0);
+
+                    shapes.push((Shape::galley(text_pos, galley), text_strength));
+                }
+            }
+        }
+
+        fn color_from_contrast(ui: &Ui, contrast: f32) -> Color32 {
+            let bg = ui.visuals().extreme_bg_color;
+            let fg = ui.visuals().widgets.open.fg_stroke.color;
+            let mix = 0.5 * contrast.sqrt();
+            Color32::from_rgb(
+                lerp((bg.r() as f32)..=(fg.r() as f32), mix) as u8,
+                lerp((bg.g() as f32)..=(fg.g() as f32), mix) as u8,
+                lerp((bg.b() as f32)..=(fg.b() as f32), mix) as u8,
+            )
+        }
+    }
+
+    fn hover(&self, ui: &Ui, pointer: Pos2, shapes: &mut Vec<Shape>) -> Vec<Cursor> {
+        let Self {
+            transform,
+            show_x,
+            show_y,
+            label_formatter,
+            items,
+            ..
+        } = self;
+
+        if !show_x && !show_y {
+            return Vec::new();
+        }
+
+        let interact_radius_sq: f32 = (16.0f32).powi(2);
+
+        let candidates = items.iter().filter_map(|item| {
+            let item = &**item;
+            let closest = item.find_closest(pointer, transform);
+
+            Some(item).zip(closest)
+        });
+
+        let closest = candidates
+            .min_by_key(|(_, elem)| elem.dist_sq.ord())
+            .filter(|(_, elem)| elem.dist_sq <= interact_radius_sq);
+
+        let mut cursors = Vec::new();
+
+        let plot = items::PlotConfig {
+            ui,
+            transform,
+            show_x: *show_x,
+            show_y: *show_y,
+        };
+
+        if let Some((item, elem)) = closest {
+            item.on_hover(elem, shapes, &mut cursors, &plot, label_formatter);
+        } else {
+            let value = transform.value_from_position(pointer);
+            items::rulers_at_value(
+                pointer,
+                value,
+                "",
+                &plot,
+                shapes,
+                &mut cursors,
+                label_formatter,
+            );
+        }
+
+        cursors
+    }
+}
+
+/// Returns next bigger power in given base
+/// e.g.
+/// ```ignore
+/// use egui::plot::next_power;
+/// assert_eq!(next_power(0.01, 10.0), 0.01);
+/// assert_eq!(next_power(0.02, 10.0), 0.1);
+/// assert_eq!(next_power(0.2,  10.0), 1);
+/// ```
+fn next_power(value: f64, base: f64) -> f64 {
+    assert_ne!(value, 0.0); // can be negative (typical for Y axis)
+    base.powi(value.abs().log(base).ceil() as i32)
+}
+
+/// Fill in all values between [min, max] which are a multiple of `step_size`
+fn generate_marks(step_sizes: [f64; 3], bounds: (f64, f64)) -> Vec<GridMark> {
+    let mut steps = vec![];
+    fill_marks_between(&mut steps, step_sizes[0], bounds);
+    fill_marks_between(&mut steps, step_sizes[1], bounds);
+    fill_marks_between(&mut steps, step_sizes[2], bounds);
+    steps
+}
+
+/// Fill in all values between [min, max] which are a multiple of `step_size`
+fn fill_marks_between(out: &mut Vec<GridMark>, step_size: f64, (min, max): (f64, f64)) {
+    assert!(max > min);
+    let first = (min / step_size).ceil() as i64;
+    let last = (max / step_size).ceil() as i64;
+
+    let marks_iter = (first..last).map(|i| {
+        let value = (i as f64) * step_size;
+        GridMark { value, step_size }
+    });
+    out.extend(marks_iter);
+}
+
+/// Helper for formatting a number so that we always show at least a few decimals,
+/// unless it is an integer, in which case we never show any decimals.
+pub fn format_number(number: f64, num_decimals: usize) -> String {
+    let is_integral = number as i64 as f64 == number;
+    if is_integral {
+        // perfect integer - show it as such:
+        format!("{:.0}", number)
+    } else {
+        // make sure we tell the user it is not an integer by always showing a decimal or two:
+        format!("{:.*}", num_decimals.at_least(1), number)
+    }
+}
diff --git a/egui/crates/egui/src/widgets/plot/transform.rs b/egui/crates/egui/src/widgets/plot/transform.rs
new file mode 100644
index 0000000..ceff3a9
--- /dev/null
+++ b/egui/crates/egui/src/widgets/plot/transform.rs
@@ -0,0 +1,383 @@
+use std::ops::RangeInclusive;
+
+use super::PlotPoint;
+use crate::*;
+
+/// 2D bounding box of f64 precision.
+/// The range of data values we show.
+#[derive(Clone, Copy, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PlotBounds {
+    pub(crate) min: [f64; 2],
+    pub(crate) max: [f64; 2],
+}
+
+impl PlotBounds {
+    pub const NOTHING: Self = Self {
+        min: [f64::INFINITY; 2],
+        max: [-f64::INFINITY; 2],
+    };
+
+    pub fn from_min_max(min: [f64; 2], max: [f64; 2]) -> Self {
+        Self { min, max }
+    }
+
+    pub fn min(&self) -> [f64; 2] {
+        self.min
+    }
+
+    pub fn max(&self) -> [f64; 2] {
+        self.max
+    }
+
+    pub(crate) fn new_symmetrical(half_extent: f64) -> Self {
+        Self {
+            min: [-half_extent; 2],
+            max: [half_extent; 2],
+        }
+    }
+
+    pub fn is_finite(&self) -> bool {
+        self.min[0].is_finite()
+            && self.min[1].is_finite()
+            && self.max[0].is_finite()
+            && self.max[1].is_finite()
+    }
+
+    pub fn is_finite_x(&self) -> bool {
+        self.min[0].is_finite() && self.max[0].is_finite()
+    }
+
+    pub fn is_finite_y(&self) -> bool {
+        self.min[1].is_finite() && self.max[1].is_finite()
+    }
+
+    pub fn is_valid(&self) -> bool {
+        self.is_finite() && self.width() > 0.0 && self.height() > 0.0
+    }
+
+    pub fn is_valid_x(&self) -> bool {
+        self.is_finite_x() && self.width() > 0.0
+    }
+
+    pub fn is_valid_y(&self) -> bool {
+        self.is_finite_y() && self.height() > 0.0
+    }
+
+    pub fn width(&self) -> f64 {
+        self.max[0] - self.min[0]
+    }
+
+    pub fn height(&self) -> f64 {
+        self.max[1] - self.min[1]
+    }
+
+    pub fn center(&self) -> PlotPoint {
+        [
+            (self.min[0] + self.max[0]) / 2.0,
+            (self.min[1] + self.max[1]) / 2.0,
+        ]
+        .into()
+    }
+
+    /// Expand to include the given (x,y) value
+    pub(crate) fn extend_with(&mut self, value: &PlotPoint) {
+        self.extend_with_x(value.x);
+        self.extend_with_y(value.y);
+    }
+
+    /// Expand to include the given x coordinate
+    pub(crate) fn extend_with_x(&mut self, x: f64) {
+        self.min[0] = self.min[0].min(x);
+        self.max[0] = self.max[0].max(x);
+    }
+
+    /// Expand to include the given y coordinate
+    pub(crate) fn extend_with_y(&mut self, y: f64) {
+        self.min[1] = self.min[1].min(y);
+        self.max[1] = self.max[1].max(y);
+    }
+
+    pub(crate) fn expand_x(&mut self, pad: f64) {
+        self.min[0] -= pad;
+        self.max[0] += pad;
+    }
+
+    pub(crate) fn expand_y(&mut self, pad: f64) {
+        self.min[1] -= pad;
+        self.max[1] += pad;
+    }
+
+    pub(crate) fn merge_x(&mut self, other: &PlotBounds) {
+        self.min[0] = self.min[0].min(other.min[0]);
+        self.max[0] = self.max[0].max(other.max[0]);
+    }
+
+    pub(crate) fn merge_y(&mut self, other: &PlotBounds) {
+        self.min[1] = self.min[1].min(other.min[1]);
+        self.max[1] = self.max[1].max(other.max[1]);
+    }
+
+    pub(crate) fn set_x(&mut self, other: &PlotBounds) {
+        self.min[0] = other.min[0];
+        self.max[0] = other.max[0];
+    }
+
+    pub(crate) fn set_y(&mut self, other: &PlotBounds) {
+        self.min[1] = other.min[1];
+        self.max[1] = other.max[1];
+    }
+
+    pub(crate) fn merge(&mut self, other: &PlotBounds) {
+        self.min[0] = self.min[0].min(other.min[0]);
+        self.min[1] = self.min[1].min(other.min[1]);
+        self.max[0] = self.max[0].max(other.max[0]);
+        self.max[1] = self.max[1].max(other.max[1]);
+    }
+
+    pub(crate) fn translate_x(&mut self, delta: f64) {
+        self.min[0] += delta;
+        self.max[0] += delta;
+    }
+
+    pub(crate) fn translate_y(&mut self, delta: f64) {
+        self.min[1] += delta;
+        self.max[1] += delta;
+    }
+
+    pub(crate) fn translate(&mut self, delta: Vec2) {
+        self.translate_x(delta.x as f64);
+        self.translate_y(delta.y as f64);
+    }
+
+    pub(crate) fn add_relative_margin_x(&mut self, margin_fraction: Vec2) {
+        let width = self.width().max(0.0);
+        self.expand_x(margin_fraction.x as f64 * width);
+    }
+
+    pub(crate) fn add_relative_margin_y(&mut self, margin_fraction: Vec2) {
+        let height = self.height().max(0.0);
+        self.expand_y(margin_fraction.y as f64 * height);
+    }
+
+    pub(crate) fn range_x(&self) -> RangeInclusive<f64> {
+        self.min[0]..=self.max[0]
+    }
+
+    pub(crate) fn range_y(&self) -> RangeInclusive<f64> {
+        self.min[1]..=self.max[1]
+    }
+
+    pub(crate) fn make_x_symmetrical(&mut self) {
+        let x_abs = self.min[0].abs().max(self.max[0].abs());
+        self.min[0] = -x_abs;
+        self.max[0] = x_abs;
+    }
+
+    pub(crate) fn make_y_symmetrical(&mut self) {
+        let y_abs = self.min[1].abs().max(self.max[1].abs());
+        self.min[1] = -y_abs;
+        self.max[1] = y_abs;
+    }
+}
+
+/// Contains the screen rectangle and the plot bounds and provides methods to transform them.
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Clone)]
+pub(crate) struct ScreenTransform {
+    /// The screen rectangle.
+    frame: Rect,
+
+    /// The plot bounds.
+    bounds: PlotBounds,
+
+    /// Whether to always center the x-range of the bounds.
+    x_centered: bool,
+
+    /// Whether to always center the y-range of the bounds.
+    y_centered: bool,
+}
+
+impl ScreenTransform {
+    pub fn new(frame: Rect, mut bounds: PlotBounds, x_centered: bool, y_centered: bool) -> Self {
+        // Make sure they are not empty.
+        if !bounds.is_valid_x() {
+            bounds.set_x(&PlotBounds::new_symmetrical(1.0));
+        }
+        if !bounds.is_valid_y() {
+            bounds.set_y(&PlotBounds::new_symmetrical(1.0));
+        }
+
+        // Scale axes so that the origin is in the center.
+        if x_centered {
+            bounds.make_x_symmetrical();
+        };
+        if y_centered {
+            bounds.make_y_symmetrical();
+        };
+
+        Self {
+            frame,
+            bounds,
+            x_centered,
+            y_centered,
+        }
+    }
+
+    /// ui-space rectangle.
+    pub fn frame(&self) -> &Rect {
+        &self.frame
+    }
+
+    pub fn bounds(&self) -> &PlotBounds {
+        &self.bounds
+    }
+
+    pub fn set_bounds(&mut self, bounds: PlotBounds) {
+        self.bounds = bounds;
+    }
+
+    pub fn translate_bounds(&mut self, mut delta_pos: Vec2) {
+        if self.x_centered {
+            delta_pos.x = 0.;
+        }
+        if self.y_centered {
+            delta_pos.y = 0.;
+        }
+        delta_pos.x *= self.dvalue_dpos()[0] as f32;
+        delta_pos.y *= self.dvalue_dpos()[1] as f32;
+        self.bounds.translate(delta_pos);
+    }
+
+    /// Zoom by a relative factor with the given screen position as center.
+    pub fn zoom(&mut self, zoom_factor: Vec2, center: Pos2) {
+        let center = self.value_from_position(center);
+
+        let mut new_bounds = self.bounds;
+        new_bounds.min[0] = center.x + (new_bounds.min[0] - center.x) / (zoom_factor.x as f64);
+        new_bounds.max[0] = center.x + (new_bounds.max[0] - center.x) / (zoom_factor.x as f64);
+        new_bounds.min[1] = center.y + (new_bounds.min[1] - center.y) / (zoom_factor.y as f64);
+        new_bounds.max[1] = center.y + (new_bounds.max[1] - center.y) / (zoom_factor.y as f64);
+
+        if new_bounds.is_valid() {
+            self.bounds = new_bounds;
+        }
+    }
+
+    pub fn position_from_point_x(&self, value: f64) -> f32 {
+        remap(
+            value,
+            self.bounds.min[0]..=self.bounds.max[0],
+            (self.frame.left() as f64)..=(self.frame.right() as f64),
+        ) as f32
+    }
+
+    pub fn position_from_point_y(&self, value: f64) -> f32 {
+        remap(
+            value,
+            self.bounds.min[1]..=self.bounds.max[1],
+            (self.frame.bottom() as f64)..=(self.frame.top() as f64), // negated y axis!
+        ) as f32
+    }
+
+    pub fn position_from_point(&self, value: &PlotPoint) -> Pos2 {
+        pos2(
+            self.position_from_point_x(value.x),
+            self.position_from_point_y(value.y),
+        )
+    }
+
+    pub fn value_from_position(&self, pos: Pos2) -> PlotPoint {
+        let x = remap(
+            pos.x as f64,
+            (self.frame.left() as f64)..=(self.frame.right() as f64),
+            self.bounds.min[0]..=self.bounds.max[0],
+        );
+        let y = remap(
+            pos.y as f64,
+            (self.frame.bottom() as f64)..=(self.frame.top() as f64), // negated y axis!
+            self.bounds.min[1]..=self.bounds.max[1],
+        );
+        PlotPoint::new(x, y)
+    }
+
+    /// Transform a rectangle of plot values to a screen-coordinate rectangle.
+    ///
+    /// This typically means that the rect is mirrored vertically (top becomes bottom and vice versa),
+    /// since the plot's coordinate system has +Y up, while egui has +Y down.
+    pub fn rect_from_values(&self, value1: &PlotPoint, value2: &PlotPoint) -> Rect {
+        let pos1 = self.position_from_point(value1);
+        let pos2 = self.position_from_point(value2);
+
+        let mut rect = Rect::NOTHING;
+        rect.extend_with(pos1);
+        rect.extend_with(pos2);
+        rect
+    }
+
+    /// delta position / delta value
+    pub fn dpos_dvalue_x(&self) -> f64 {
+        self.frame.width() as f64 / self.bounds.width()
+    }
+
+    /// delta position / delta value
+    pub fn dpos_dvalue_y(&self) -> f64 {
+        -self.frame.height() as f64 / self.bounds.height() // negated y axis!
+    }
+
+    /// delta position / delta value
+    pub fn dpos_dvalue(&self) -> [f64; 2] {
+        [self.dpos_dvalue_x(), self.dpos_dvalue_y()]
+    }
+
+    /// delta value / delta position
+    pub fn dvalue_dpos(&self) -> [f64; 2] {
+        [1.0 / self.dpos_dvalue_x(), 1.0 / self.dpos_dvalue_y()]
+    }
+
+    fn aspect(&self) -> f64 {
+        let rw = self.frame.width() as f64;
+        let rh = self.frame.height() as f64;
+        (self.bounds.width() / rw) / (self.bounds.height() / rh)
+    }
+
+    /// Sets the aspect ratio by expanding the x- or y-axis.
+    ///
+    /// This never contracts, so we don't miss out on any data.
+    pub fn set_aspect_by_expanding(&mut self, aspect: f64) {
+        let current_aspect = self.aspect();
+
+        let epsilon = 1e-5;
+        if (current_aspect - aspect).abs() < epsilon {
+            // Don't make any changes when the aspect is already almost correct.
+            return;
+        }
+
+        if current_aspect < aspect {
+            self.bounds
+                .expand_x((aspect / current_aspect - 1.0) * self.bounds.width() * 0.5);
+        } else {
+            self.bounds
+                .expand_y((current_aspect / aspect - 1.0) * self.bounds.height() * 0.5);
+        }
+    }
+
+    /// Sets the aspect ratio by changing either the X or Y axis (callers choice).
+    pub fn set_aspect_by_changing_axis(&mut self, aspect: f64, change_x: bool) {
+        let current_aspect = self.aspect();
+
+        let epsilon = 1e-5;
+        if (current_aspect - aspect).abs() < epsilon {
+            // Don't make any changes when the aspect is already almost correct.
+            return;
+        }
+
+        if change_x {
+            self.bounds
+                .expand_x((aspect / current_aspect - 1.0) * self.bounds.width() * 0.5);
+        } else {
+            self.bounds
+                .expand_y((current_aspect / aspect - 1.0) * self.bounds.height() * 0.5);
+        }
+    }
+}
diff --git a/egui/crates/egui/src/widgets/progress_bar.rs b/egui/crates/egui/src/widgets/progress_bar.rs
new file mode 100644
index 0000000..ef6d16c
--- /dev/null
+++ b/egui/crates/egui/src/widgets/progress_bar.rs
@@ -0,0 +1,159 @@
+use crate::*;
+
+enum ProgressBarText {
+    Custom(WidgetText),
+    Percentage,
+}
+
+/// A simple progress bar.
+///
+/// See also: [`crate::Spinner`].
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct ProgressBar {
+    progress: f32,
+    desired_width: Option<f32>,
+    text: Option<ProgressBarText>,
+    fill: Option<Color32>,
+    animate: bool,
+}
+
+impl ProgressBar {
+    /// Progress in the `[0, 1]` range, where `1` means "completed".
+    pub fn new(progress: f32) -> Self {
+        Self {
+            progress: progress.clamp(0.0, 1.0),
+            desired_width: None,
+            text: None,
+            fill: None,
+            animate: false,
+        }
+    }
+
+    /// The desired width of the bar. Will use all horizontal space if not set.
+    pub fn desired_width(mut self, desired_width: f32) -> Self {
+        self.desired_width = Some(desired_width);
+        self
+    }
+
+    /// The fill color of the bar.
+    pub fn fill(mut self, color: Color32) -> Self {
+        self.fill = Some(color);
+        self
+    }
+
+    /// A custom text to display on the progress bar.
+    pub fn text(mut self, text: impl Into<WidgetText>) -> Self {
+        self.text = Some(ProgressBarText::Custom(text.into()));
+        self
+    }
+
+    /// Show the progress in percent on the progress bar.
+    pub fn show_percentage(mut self) -> Self {
+        self.text = Some(ProgressBarText::Percentage);
+        self
+    }
+
+    /// Whether to display a loading animation when progress `< 1`.
+    /// Note that this will cause the UI to be redrawn.
+    /// Defaults to `false`.
+    pub fn animate(mut self, animate: bool) -> Self {
+        self.animate = animate;
+        self
+    }
+}
+
+impl Widget for ProgressBar {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let ProgressBar {
+            progress,
+            desired_width,
+            text,
+            fill,
+            animate,
+        } = self;
+
+        let animate = animate && progress < 1.0;
+
+        let desired_width =
+            desired_width.unwrap_or_else(|| ui.available_size_before_wrap().x.at_least(96.0));
+        let height = ui.spacing().interact_size.y;
+        let (outer_rect, response) =
+            ui.allocate_exact_size(vec2(desired_width, height), Sense::hover());
+
+        if ui.is_rect_visible(response.rect) {
+            if animate {
+                ui.ctx().request_repaint();
+            }
+
+            let visuals = ui.style().visuals.clone();
+            let rounding = outer_rect.height() / 2.0;
+            ui.painter()
+                .rect(outer_rect, rounding, visuals.extreme_bg_color, Stroke::NONE);
+            let inner_rect = Rect::from_min_size(
+                outer_rect.min,
+                vec2(
+                    (outer_rect.width() * progress).at_least(outer_rect.height()),
+                    outer_rect.height(),
+                ),
+            );
+
+            let (dark, bright) = (0.7, 1.0);
+            let color_factor = if animate {
+                let time = ui.input(|i| i.time);
+                lerp(dark..=bright, time.cos().abs())
+            } else {
+                bright
+            };
+
+            ui.painter().rect(
+                inner_rect,
+                rounding,
+                Color32::from(
+                    Rgba::from(fill.unwrap_or(visuals.selection.bg_fill)) * color_factor as f32,
+                ),
+                Stroke::NONE,
+            );
+
+            if animate {
+                let n_points = 20;
+                let time = ui.input(|i| i.time);
+                let start_angle = time * std::f64::consts::TAU;
+                let end_angle = start_angle + 240f64.to_radians() * time.sin();
+                let circle_radius = rounding - 2.0;
+                let points: Vec<Pos2> = (0..n_points)
+                    .map(|i| {
+                        let angle = lerp(start_angle..=end_angle, i as f64 / n_points as f64);
+                        let (sin, cos) = angle.sin_cos();
+                        inner_rect.right_center()
+                            + circle_radius * vec2(cos as f32, sin as f32)
+                            + vec2(-rounding, 0.0)
+                    })
+                    .collect();
+                ui.painter()
+                    .add(Shape::line(points, Stroke::new(2.0, visuals.text_color())));
+            }
+
+            if let Some(text_kind) = text {
+                let text = match text_kind {
+                    ProgressBarText::Custom(text) => text,
+                    ProgressBarText::Percentage => {
+                        format!("{}%", (progress * 100.0) as usize).into()
+                    }
+                };
+                let galley = text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button);
+                let text_pos = outer_rect.left_center() - Vec2::new(0.0, galley.size().y / 2.0)
+                    + vec2(ui.spacing().item_spacing.x, 0.0);
+                let text_color = visuals
+                    .override_text_color
+                    .unwrap_or(visuals.selection.stroke.color);
+                galley.paint_with_fallback_color(
+                    &ui.painter().with_clip_rect(outer_rect),
+                    text_pos,
+                    text_color,
+                );
+            }
+        }
+
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/selected_label.rs b/egui/crates/egui/src/widgets/selected_label.rs
new file mode 100644
index 0000000..364ba03
--- /dev/null
+++ b/egui/crates/egui/src/widgets/selected_label.rs
@@ -0,0 +1,80 @@
+use crate::*;
+
+/// One out of several alternatives, either selected or not.
+/// Will mark selected items with a different background color.
+/// An alternative to [`RadioButton`] and [`Checkbox`].
+///
+/// Usually you'd use [`Ui::selectable_value`] or [`Ui::selectable_label`] instead.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// #[derive(PartialEq)]
+/// enum Enum { First, Second, Third }
+/// let mut my_enum = Enum::First;
+///
+/// ui.selectable_value(&mut my_enum, Enum::First, "First");
+///
+/// // is equivalent to:
+///
+/// if ui.add(egui::SelectableLabel::new(my_enum == Enum::First, "First")).clicked() {
+///     my_enum = Enum::First
+/// }
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct SelectableLabel {
+    selected: bool,
+    text: WidgetText,
+}
+
+impl SelectableLabel {
+    pub fn new(selected: bool, text: impl Into<WidgetText>) -> Self {
+        Self {
+            selected,
+            text: text.into(),
+        }
+    }
+}
+
+impl Widget for SelectableLabel {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Self { selected, text } = self;
+
+        let button_padding = ui.spacing().button_padding;
+        let total_extra = button_padding + button_padding;
+
+        let wrap_width = ui.available_width() - total_extra.x;
+        let text = text.into_galley(ui, None, wrap_width, TextStyle::Button);
+
+        let mut desired_size = total_extra + text.size();
+        desired_size.y = desired_size.y.at_least(ui.spacing().interact_size.y);
+        let (rect, response) = ui.allocate_at_least(desired_size, Sense::click());
+        response.widget_info(|| {
+            WidgetInfo::selected(WidgetType::SelectableLabel, selected, text.text())
+        });
+
+        if ui.is_rect_visible(response.rect) {
+            let text_pos = ui
+                .layout()
+                .align_size_within_rect(text.size(), rect.shrink2(button_padding))
+                .min;
+
+            let visuals = ui.style().interact_selectable(&response, selected);
+
+            if selected || response.hovered() || response.highlighted() || response.has_focus() {
+                let rect = rect.expand(visuals.expansion);
+
+                ui.painter().rect(
+                    rect,
+                    visuals.rounding,
+                    visuals.weak_bg_fill,
+                    visuals.bg_stroke,
+                );
+            }
+
+            text.paint_with_visuals(ui.painter(), text_pos, &visuals);
+        }
+
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/separator.rs b/egui/crates/egui/src/widgets/separator.rs
new file mode 100644
index 0000000..1c0ee1d
--- /dev/null
+++ b/egui/crates/egui/src/widgets/separator.rs
@@ -0,0 +1,124 @@
+use crate::*;
+
+/// A visual separator. A horizontal or vertical line (depending on [`Layout`]).
+///
+/// Usually you'd use the shorter version [`Ui::separator`].
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// // These are equivalent:
+/// ui.separator();
+/// ui.add(egui::Separator::default());
+/// # });
+/// ```
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Separator {
+    spacing: f32,
+    grow: f32,
+    is_horizontal_line: Option<bool>,
+}
+
+impl Default for Separator {
+    fn default() -> Self {
+        Self {
+            spacing: 6.0,
+            grow: 0.0,
+            is_horizontal_line: None,
+        }
+    }
+}
+
+impl Separator {
+    /// How much space we take up. The line is painted in the middle of this.
+    ///
+    /// In a vertical layout, with a horizontal Separator,
+    /// this is the height of the separator widget.
+    ///
+    /// In a horizontal layout, with a vertical Separator,
+    /// this is the width of the separator widget.
+    pub fn spacing(mut self, spacing: f32) -> Self {
+        self.spacing = spacing;
+        self
+    }
+
+    /// Explicitly ask for a horizontal line.
+    ///
+    /// By default you will get a horizontal line in vertical layouts,
+    /// and a vertical line in horizontal layouts.
+    pub fn horizontal(mut self) -> Self {
+        self.is_horizontal_line = Some(true);
+        self
+    }
+
+    /// Explicitly ask for a vertical line.
+    ///
+    /// By default you will get a horizontal line in vertical layouts,
+    /// and a vertical line in horizontal layouts.
+    pub fn vertical(mut self) -> Self {
+        self.is_horizontal_line = Some(false);
+        self
+    }
+
+    /// Extend each end of the separator line by this much.
+    ///
+    /// The default is to take up the available width/height of the parent.
+    ///
+    /// This will make the line extend outside the parent ui.
+    pub fn grow(mut self, extra: f32) -> Self {
+        self.grow += extra;
+        self
+    }
+
+    /// Contract each end of the separator line by this much.
+    ///
+    /// The default is to take up the available width/height of the parent.
+    ///
+    /// This effectively adds margins to the line.
+    pub fn shrink(mut self, shrink: f32) -> Self {
+        self.grow -= shrink;
+        self
+    }
+}
+
+impl Widget for Separator {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let Separator {
+            spacing,
+            grow,
+            is_horizontal_line,
+        } = self;
+
+        let is_horizontal_line = is_horizontal_line
+            .unwrap_or_else(|| ui.is_grid() || !ui.layout().main_dir().is_horizontal());
+
+        let available_space = ui.available_size_before_wrap();
+
+        let size = if is_horizontal_line {
+            vec2(available_space.x, spacing)
+        } else {
+            vec2(spacing, available_space.y)
+        };
+
+        let (rect, response) = ui.allocate_at_least(size, Sense::hover());
+
+        if ui.is_rect_visible(response.rect) {
+            let stroke = ui.visuals().widgets.noninteractive.bg_stroke;
+            let painter = ui.painter();
+            if is_horizontal_line {
+                painter.hline(
+                    (rect.left() - grow)..=(rect.right() + grow),
+                    painter.round_to_pixel(rect.center().y),
+                    stroke,
+                );
+            } else {
+                painter.vline(
+                    painter.round_to_pixel(rect.center().x),
+                    (rect.top() - grow)..=(rect.bottom() + grow),
+                    stroke,
+                );
+            }
+        }
+
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/slider.rs b/egui/crates/egui/src/widgets/slider.rs
new file mode 100644
index 0000000..9ebcaf4
--- /dev/null
+++ b/egui/crates/egui/src/widgets/slider.rs
@@ -0,0 +1,1012 @@
+#![allow(clippy::needless_pass_by_value)] // False positives with `impl ToString`
+
+use std::ops::RangeInclusive;
+
+use crate::*;
+
+// ----------------------------------------------------------------------------
+
+type NumFormatter<'a> = Box<dyn 'a + Fn(f64, RangeInclusive<usize>) -> String>;
+type NumParser<'a> = Box<dyn 'a + Fn(&str) -> Option<f64>>;
+
+// ----------------------------------------------------------------------------
+
+/// Combined into one function (rather than two) to make it easier
+/// for the borrow checker.
+type GetSetValue<'a> = Box<dyn 'a + FnMut(Option<f64>) -> f64>;
+
+fn get(get_set_value: &mut GetSetValue<'_>) -> f64 {
+    (get_set_value)(None)
+}
+
+fn set(get_set_value: &mut GetSetValue<'_>, value: f64) {
+    (get_set_value)(Some(value));
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone)]
+struct SliderSpec {
+    logarithmic: bool,
+
+    /// For logarithmic sliders, the smallest positive value we are interested in.
+    /// 1 for integer sliders, maybe 1e-6 for others.
+    smallest_positive: f64,
+
+    /// For logarithmic sliders, the largest positive value we are interested in
+    /// before the slider switches to `INFINITY`, if that is the higher end.
+    /// Default: INFINITY.
+    largest_finite: f64,
+}
+
+/// Specifies the orientation of a [`Slider`].
+pub enum SliderOrientation {
+    Horizontal,
+    Vertical,
+}
+
+/// Control a number with a slider.
+///
+/// The slider range defines the values you get when pulling the slider to the far edges.
+/// By default, the slider can still show values outside this range,
+/// and still allows users to enter values outside the range by clicking the slider value and editing it.
+/// If you want to clamp incoming and outgoing values, use [`Slider::clamp_to_range`].
+///
+/// The range can include any numbers, and go from low-to-high or from high-to-low.
+///
+/// The slider consists of three parts: a slider, a value display, and an optional text.
+/// The user can click the value display to edit its value. It can be turned off with `.show_value(false)`.
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # let mut my_f32: f32 = 0.0;
+/// ui.add(egui::Slider::new(&mut my_f32, 0.0..=100.0).text("My value"));
+/// # });
+/// ```
+///
+/// The default [`Slider`] size is set by [`crate::style::Spacing::slider_width`].
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct Slider<'a> {
+    get_set_value: GetSetValue<'a>,
+    range: RangeInclusive<f64>,
+    spec: SliderSpec,
+    clamp_to_range: bool,
+    smart_aim: bool,
+    show_value: bool,
+    orientation: SliderOrientation,
+    prefix: String,
+    suffix: String,
+    text: WidgetText,
+    /// Sets the minimal step of the widget value
+    step: Option<f64>,
+    drag_value_speed: Option<f64>,
+    min_decimals: usize,
+    max_decimals: Option<usize>,
+    custom_formatter: Option<NumFormatter<'a>>,
+    custom_parser: Option<NumParser<'a>>,
+    trailing_fill: Option<bool>,
+}
+
+impl<'a> Slider<'a> {
+    /// Creates a new horizontal slider.
+    pub fn new<Num: emath::Numeric>(value: &'a mut Num, range: RangeInclusive<Num>) -> Self {
+        let range_f64 = range.start().to_f64()..=range.end().to_f64();
+        let slf = Self::from_get_set(range_f64, move |v: Option<f64>| {
+            if let Some(v) = v {
+                *value = Num::from_f64(v);
+            }
+            value.to_f64()
+        });
+
+        if Num::INTEGRAL {
+            slf.integer()
+        } else {
+            slf
+        }
+    }
+
+    pub fn from_get_set(
+        range: RangeInclusive<f64>,
+        get_set_value: impl 'a + FnMut(Option<f64>) -> f64,
+    ) -> Self {
+        Self {
+            get_set_value: Box::new(get_set_value),
+            range,
+            spec: SliderSpec {
+                logarithmic: false,
+                smallest_positive: 1e-6,
+                largest_finite: f64::INFINITY,
+            },
+            clamp_to_range: true,
+            smart_aim: true,
+            show_value: true,
+            orientation: SliderOrientation::Horizontal,
+            prefix: Default::default(),
+            suffix: Default::default(),
+            text: Default::default(),
+            step: None,
+            drag_value_speed: None,
+            min_decimals: 0,
+            max_decimals: None,
+            custom_formatter: None,
+            custom_parser: None,
+            trailing_fill: None,
+        }
+    }
+
+    /// Control whether or not the slider shows the current value.
+    /// Default: `true`.
+    pub fn show_value(mut self, show_value: bool) -> Self {
+        self.show_value = show_value;
+        self
+    }
+
+    /// Show a prefix before the number, e.g. "x: "
+    pub fn prefix(mut self, prefix: impl ToString) -> Self {
+        self.prefix = prefix.to_string();
+        self
+    }
+
+    /// Add a suffix to the number, this can be e.g. a unit ("°" or " m")
+    pub fn suffix(mut self, suffix: impl ToString) -> Self {
+        self.suffix = suffix.to_string();
+        self
+    }
+
+    /// Show a text next to the slider (e.g. explaining what the slider controls).
+    pub fn text(mut self, text: impl Into<WidgetText>) -> Self {
+        self.text = text.into();
+        self
+    }
+
+    pub fn text_color(mut self, text_color: Color32) -> Self {
+        self.text = self.text.color(text_color);
+        self
+    }
+
+    /// Vertical or horizontal slider? The default is horizontal.
+    pub fn orientation(mut self, orientation: SliderOrientation) -> Self {
+        self.orientation = orientation;
+        self
+    }
+
+    /// Make this a vertical slider.
+    pub fn vertical(mut self) -> Self {
+        self.orientation = SliderOrientation::Vertical;
+        self
+    }
+
+    /// Make this a logarithmic slider.
+    /// This is great for when the slider spans a huge range,
+    /// e.g. from one to a million.
+    /// The default is OFF.
+    pub fn logarithmic(mut self, logarithmic: bool) -> Self {
+        self.spec.logarithmic = logarithmic;
+        self
+    }
+
+    /// For logarithmic sliders that includes zero:
+    /// what is the smallest positive value you want to be able to select?
+    /// The default is `1` for integer sliders and `1e-6` for real sliders.
+    pub fn smallest_positive(mut self, smallest_positive: f64) -> Self {
+        self.spec.smallest_positive = smallest_positive;
+        self
+    }
+
+    /// For logarithmic sliders, the largest positive value we are interested in
+    /// before the slider switches to `INFINITY`, if that is the higher end.
+    /// Default: INFINITY.
+    pub fn largest_finite(mut self, largest_finite: f64) -> Self {
+        self.spec.largest_finite = largest_finite;
+        self
+    }
+
+    /// If set to `true`, all incoming and outgoing values will be clamped to the slider range.
+    /// Default: `true`.
+    pub fn clamp_to_range(mut self, clamp_to_range: bool) -> Self {
+        self.clamp_to_range = clamp_to_range;
+        self
+    }
+
+    /// Turn smart aim on/off. Default is ON.
+    /// There is almost no point in turning this off.
+    pub fn smart_aim(mut self, smart_aim: bool) -> Self {
+        self.smart_aim = smart_aim;
+        self
+    }
+
+    /// Sets the minimal change of the value.
+    ///
+    /// Value `0.0` effectively disables the feature. If the new value is out of range
+    /// and `clamp_to_range` is enabled, you would not have the ability to change the value.
+    ///
+    /// Default: `0.0` (disabled).
+    pub fn step_by(mut self, step: f64) -> Self {
+        self.step = if step != 0.0 { Some(step) } else { None };
+        self
+    }
+
+    /// When dragging the value, how fast does it move?
+    ///
+    /// Unit: values per point (logical pixel).
+    /// See also [`DragValue::speed`].
+    ///
+    /// By default this is the same speed as when dragging the slider,
+    /// but you can change it here to for instance have a much finer control
+    /// by dragging the slider value rather than the slider itself.
+    pub fn drag_value_speed(mut self, drag_value_speed: f64) -> Self {
+        self.drag_value_speed = Some(drag_value_speed);
+        self
+    }
+
+    // TODO(emilk): we should also have a "min precision".
+    /// Set a minimum number of decimals to display.
+    ///
+    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
+    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
+    pub fn min_decimals(mut self, min_decimals: usize) -> Self {
+        self.min_decimals = min_decimals;
+        self
+    }
+
+    // TODO(emilk): we should also have a "max precision".
+    /// Set a maximum number of decimals to display.
+    ///
+    /// Values will also be rounded to this number of decimals.
+    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
+    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
+    pub fn max_decimals(mut self, max_decimals: usize) -> Self {
+        self.max_decimals = Some(max_decimals);
+        self
+    }
+
+    /// Set an exact number of decimals to display.
+    ///
+    /// Values will also be rounded to this number of decimals.
+    /// Normally you don't need to pick a precision, as the slider will intelligently pick a precision for you.
+    /// Regardless of precision the slider will use "smart aim" to help the user select nice, round values.
+    pub fn fixed_decimals(mut self, num_decimals: usize) -> Self {
+        self.min_decimals = num_decimals;
+        self.max_decimals = Some(num_decimals);
+        self
+    }
+
+    /// Display trailing color behind the slider's circle. Default is OFF.
+    ///
+    /// This setting can be enabled globally for all sliders with [`Visuals::slider_trailing_fill`].
+    /// Toggling it here will override the above setting ONLY for this individual slider.
+    ///
+    /// The fill color will be taken from `selection.bg_fill` in your [`Visuals`], the same as a [`ProgressBar`].
+    pub fn trailing_fill(mut self, trailing_fill: bool) -> Self {
+        self.trailing_fill = Some(trailing_fill);
+        self
+    }
+
+    /// Set custom formatter defining how numbers are converted into text.
+    ///
+    /// A custom formatter takes a `f64` for the numeric value and a `RangeInclusive<usize>` representing
+    /// the decimal range i.e. minimum and maximum number of decimal places shown.
+    ///
+    /// See also: [`DragValue::custom_parser`]
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::Slider::new(&mut my_i32, 0..=((60 * 60 * 24) - 1))
+    ///     .custom_formatter(|n, _| {
+    ///         let n = n as i32;
+    ///         let hours = n / (60 * 60);
+    ///         let mins = (n / 60) % 60;
+    ///         let secs = n % 60;
+    ///         format!("{hours:02}:{mins:02}:{secs:02}")
+    ///     })
+    ///     .custom_parser(|s| {
+    ///         let parts: Vec<&str> = s.split(':').collect();
+    ///         if parts.len() == 3 {
+    ///             parts[0].parse::<i32>().and_then(|h| {
+    ///                 parts[1].parse::<i32>().and_then(|m| {
+    ///                     parts[2].parse::<i32>().map(|s| {
+    ///                         ((h * 60 * 60) + (m * 60) + s) as f64
+    ///                     })
+    ///                 })
+    ///             })
+    ///             .ok()
+    ///         } else {
+    ///             None
+    ///         }
+    ///     }));
+    /// # });
+    /// ```
+    pub fn custom_formatter(
+        mut self,
+        formatter: impl 'a + Fn(f64, RangeInclusive<usize>) -> String,
+    ) -> Self {
+        self.custom_formatter = Some(Box::new(formatter));
+        self
+    }
+
+    /// Set custom parser defining how the text input is parsed into a number.
+    ///
+    /// A custom parser takes an `&str` to parse into a number and returns `Some` if it was successfully parsed
+    /// or `None` otherwise.
+    ///
+    /// See also: [`DragValue::custom_formatter`]
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::Slider::new(&mut my_i32, 0..=((60 * 60 * 24) - 1))
+    ///     .custom_formatter(|n, _| {
+    ///         let n = n as i32;
+    ///         let hours = n / (60 * 60);
+    ///         let mins = (n / 60) % 60;
+    ///         let secs = n % 60;
+    ///         format!("{hours:02}:{mins:02}:{secs:02}")
+    ///     })
+    ///     .custom_parser(|s| {
+    ///         let parts: Vec<&str> = s.split(':').collect();
+    ///         if parts.len() == 3 {
+    ///             parts[0].parse::<i32>().and_then(|h| {
+    ///                 parts[1].parse::<i32>().and_then(|m| {
+    ///                     parts[2].parse::<i32>().map(|s| {
+    ///                         ((h * 60 * 60) + (m * 60) + s) as f64
+    ///                     })
+    ///                 })
+    ///             })
+    ///             .ok()
+    ///         } else {
+    ///             None
+    ///         }
+    ///     }));
+    /// # });
+    /// ```
+    pub fn custom_parser(mut self, parser: impl 'a + Fn(&str) -> Option<f64>) -> Self {
+        self.custom_parser = Some(Box::new(parser));
+        self
+    }
+
+    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as binary integers. Floating point
+    /// numbers are *not* supported.
+    ///
+    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
+    /// prefixed with additional 0s to match `min_width`.
+    ///
+    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
+    /// they will be prefixed with a '-' sign.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min_width` is 0.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::Slider::new(&mut my_i32, -100..=100).binary(64, false));
+    /// # });
+    /// ```
+    pub fn binary(self, min_width: usize, twos_complement: bool) -> Self {
+        assert!(
+            min_width > 0,
+            "Slider::binary: `min_width` must be greater than 0"
+        );
+        if twos_complement {
+            self.custom_formatter(move |n, _| format!("{:0>min_width$b}", n as i64))
+        } else {
+            self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$b}", n.abs() as i64)
+            })
+        }
+        .custom_parser(|s| i64::from_str_radix(s, 2).map(|n| n as f64).ok())
+    }
+
+    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as octal integers. Floating point
+    /// numbers are *not* supported.
+    ///
+    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
+    /// prefixed with additional 0s to match `min_width`.
+    ///
+    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
+    /// they will be prefixed with a '-' sign.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min_width` is 0.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::Slider::new(&mut my_i32, -100..=100).octal(22, false));
+    /// # });
+    /// ```
+    pub fn octal(self, min_width: usize, twos_complement: bool) -> Self {
+        assert!(
+            min_width > 0,
+            "Slider::octal: `min_width` must be greater than 0"
+        );
+        if twos_complement {
+            self.custom_formatter(move |n, _| format!("{:0>min_width$o}", n as i64))
+        } else {
+            self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$o}", n.abs() as i64)
+            })
+        }
+        .custom_parser(|s| i64::from_str_radix(s, 8).map(|n| n as f64).ok())
+    }
+
+    /// Set `custom_formatter` and `custom_parser` to display and parse numbers as hexadecimal integers. Floating point
+    /// numbers are *not* supported.
+    ///
+    /// `min_width` specifies the minimum number of displayed digits; if the number is shorter than this, it will be
+    /// prefixed with additional 0s to match `min_width`.
+    ///
+    /// If `twos_complement` is true, negative values will be displayed as the 2's complement representation. Otherwise
+    /// they will be prefixed with a '-' sign.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min_width` is 0.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_i32: i32 = 0;
+    /// ui.add(egui::Slider::new(&mut my_i32, -100..=100).hexadecimal(16, false, true));
+    /// # });
+    /// ```
+    pub fn hexadecimal(self, min_width: usize, twos_complement: bool, upper: bool) -> Self {
+        assert!(
+            min_width > 0,
+            "Slider::hexadecimal: `min_width` must be greater than 0"
+        );
+        match (twos_complement, upper) {
+            (true, true) => {
+                self.custom_formatter(move |n, _| format!("{:0>min_width$X}", n as i64))
+            }
+            (true, false) => {
+                self.custom_formatter(move |n, _| format!("{:0>min_width$x}", n as i64))
+            }
+            (false, true) => self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$X}", n.abs() as i64)
+            }),
+            (false, false) => self.custom_formatter(move |n, _| {
+                let sign = if n < 0.0 { "-" } else { "" };
+                format!("{sign}{:0>min_width$x}", n.abs() as i64)
+            }),
+        }
+        .custom_parser(|s| i64::from_str_radix(s, 16).map(|n| n as f64).ok())
+    }
+
+    /// Helper: equivalent to `self.precision(0).smallest_positive(1.0)`.
+    /// If you use one of the integer constructors (e.g. `Slider::i32`) this is called for you,
+    /// but if you want to have a slider for picking integer values in an `Slider::f64`, use this.
+    pub fn integer(self) -> Self {
+        self.fixed_decimals(0).smallest_positive(1.0).step_by(1.0)
+    }
+
+    fn get_value(&mut self) -> f64 {
+        let value = get(&mut self.get_set_value);
+        if self.clamp_to_range {
+            let start = *self.range.start();
+            let end = *self.range.end();
+            value.clamp(start.min(end), start.max(end))
+        } else {
+            value
+        }
+    }
+
+    fn set_value(&mut self, mut value: f64) {
+        if self.clamp_to_range {
+            let start = *self.range.start();
+            let end = *self.range.end();
+            value = value.clamp(start.min(end), start.max(end));
+        }
+        if let Some(max_decimals) = self.max_decimals {
+            value = emath::round_to_decimals(value, max_decimals);
+        }
+        if let Some(step) = self.step {
+            value = (value / step).round() * step;
+        }
+        set(&mut self.get_set_value, value);
+    }
+
+    fn clamp_range(&self) -> RangeInclusive<f64> {
+        if self.clamp_to_range {
+            self.range()
+        } else {
+            f64::NEG_INFINITY..=f64::INFINITY
+        }
+    }
+
+    fn range(&self) -> RangeInclusive<f64> {
+        self.range.clone()
+    }
+
+    /// For instance, `position` is the mouse position and `position_range` is the physical location of the slider on the screen.
+    fn value_from_position(&self, position: f32, position_range: RangeInclusive<f32>) -> f64 {
+        let normalized = remap_clamp(position, position_range, 0.0..=1.0) as f64;
+        value_from_normalized(normalized, self.range(), &self.spec)
+    }
+
+    fn position_from_value(&self, value: f64, position_range: RangeInclusive<f32>) -> f32 {
+        let normalized = normalized_from_value(value, self.range(), &self.spec);
+        lerp(position_range, normalized as f32)
+    }
+}
+
+impl<'a> Slider<'a> {
+    /// Just the slider, no text
+    fn allocate_slider_space(&self, ui: &mut Ui, thickness: f32) -> Response {
+        let desired_size = match self.orientation {
+            SliderOrientation::Horizontal => vec2(ui.spacing().slider_width, thickness),
+            SliderOrientation::Vertical => vec2(thickness, ui.spacing().slider_width),
+        };
+        ui.allocate_response(desired_size, Sense::drag())
+    }
+
+    /// Just the slider, no text
+    fn slider_ui(&mut self, ui: &mut Ui, response: &Response) {
+        let rect = &response.rect;
+        let position_range = self.position_range(rect);
+
+        if let Some(pointer_position_2d) = response.interact_pointer_pos() {
+            let position = self.pointer_position(pointer_position_2d);
+            let new_value = if self.smart_aim {
+                let aim_radius = ui.input(|i| i.aim_radius());
+                emath::smart_aim::best_in_range_f64(
+                    self.value_from_position(position - aim_radius, position_range.clone()),
+                    self.value_from_position(position + aim_radius, position_range.clone()),
+                )
+            } else {
+                self.value_from_position(position, position_range.clone())
+            };
+            self.set_value(new_value);
+        }
+
+        let mut decrement = 0usize;
+        let mut increment = 0usize;
+
+        if response.has_focus() {
+            let (dec_key, inc_key) = match self.orientation {
+                SliderOrientation::Horizontal => (Key::ArrowLeft, Key::ArrowRight),
+                // Note that this is for moving the slider position,
+                // so up = decrement y coordinate:
+                SliderOrientation::Vertical => (Key::ArrowUp, Key::ArrowDown),
+            };
+
+            ui.input(|input| {
+                decrement += input.num_presses(dec_key);
+                increment += input.num_presses(inc_key);
+            });
+        }
+
+        #[cfg(feature = "accesskit")]
+        {
+            use accesskit::Action;
+            ui.input(|input| {
+                decrement += input.num_accesskit_action_requests(response.id, Action::Decrement);
+                increment += input.num_accesskit_action_requests(response.id, Action::Increment);
+            });
+        }
+
+        let kb_step = increment as f32 - decrement as f32;
+
+        if kb_step != 0.0 {
+            let prev_value = self.get_value();
+            let prev_position = self.position_from_value(prev_value, position_range.clone());
+            let new_position = prev_position + kb_step;
+            let new_value = match self.step {
+                Some(step) => prev_value + (kb_step as f64 * step),
+                None if self.smart_aim => {
+                    let aim_radius = ui.input(|i| i.aim_radius());
+                    emath::smart_aim::best_in_range_f64(
+                        self.value_from_position(new_position - aim_radius, position_range.clone()),
+                        self.value_from_position(new_position + aim_radius, position_range.clone()),
+                    )
+                }
+                _ => self.value_from_position(new_position, position_range.clone()),
+            };
+            self.set_value(new_value);
+        }
+
+        #[cfg(feature = "accesskit")]
+        {
+            use accesskit::{Action, ActionData};
+            ui.input(|input| {
+                for request in input.accesskit_action_requests(response.id, Action::SetValue) {
+                    if let Some(ActionData::NumericValue(new_value)) = request.data {
+                        self.set_value(new_value);
+                    }
+                }
+            });
+        }
+
+        // Paint it:
+        if ui.is_rect_visible(response.rect) {
+            let value = self.get_value();
+
+            let rail_radius = ui.painter().round_to_pixel(self.rail_radius_limit(rect));
+            let rail_rect = self.rail_rect(rect, rail_radius);
+
+            let visuals = ui.style().interact(response);
+            let widget_visuals = &ui.visuals().widgets;
+
+            ui.painter().rect_filled(
+                rail_rect,
+                widget_visuals.inactive.rounding,
+                widget_visuals.inactive.bg_fill,
+            );
+
+            let position_1d = self.position_from_value(value, position_range);
+            let center = self.marker_center(position_1d, &rail_rect);
+
+            // Decide if we should add trailing fill.
+            let trailing_fill = self
+                .trailing_fill
+                .unwrap_or_else(|| ui.visuals().slider_trailing_fill);
+
+            // Paint trailing fill.
+            if trailing_fill {
+                let mut trailing_rail_rect = rail_rect;
+
+                // The trailing rect has to be drawn differently depending on the orientation.
+                match self.orientation {
+                    SliderOrientation::Vertical => trailing_rail_rect.min.y = center.y,
+                    SliderOrientation::Horizontal => trailing_rail_rect.max.x = center.x,
+                };
+
+                ui.painter().rect_filled(
+                    trailing_rail_rect,
+                    widget_visuals.inactive.rounding,
+                    ui.visuals().selection.bg_fill,
+                );
+            }
+
+            ui.painter().add(epaint::CircleShape {
+                center,
+                radius: self.handle_radius(rect) + visuals.expansion,
+                fill: visuals.bg_fill,
+                stroke: visuals.fg_stroke,
+            });
+        }
+    }
+
+    fn marker_center(&self, position_1d: f32, rail_rect: &Rect) -> Pos2 {
+        match self.orientation {
+            SliderOrientation::Horizontal => pos2(position_1d, rail_rect.center().y),
+            SliderOrientation::Vertical => pos2(rail_rect.center().x, position_1d),
+        }
+    }
+
+    fn pointer_position(&self, pointer_position_2d: Pos2) -> f32 {
+        match self.orientation {
+            SliderOrientation::Horizontal => pointer_position_2d.x,
+            SliderOrientation::Vertical => pointer_position_2d.y,
+        }
+    }
+
+    fn position_range(&self, rect: &Rect) -> RangeInclusive<f32> {
+        let handle_radius = self.handle_radius(rect);
+        match self.orientation {
+            SliderOrientation::Horizontal => {
+                (rect.left() + handle_radius)..=(rect.right() - handle_radius)
+            }
+            SliderOrientation::Vertical => {
+                (rect.bottom() - handle_radius)..=(rect.top() + handle_radius)
+            }
+        }
+    }
+
+    fn rail_rect(&self, rect: &Rect, radius: f32) -> Rect {
+        match self.orientation {
+            SliderOrientation::Horizontal => Rect::from_min_max(
+                pos2(rect.left(), rect.center().y - radius),
+                pos2(rect.right(), rect.center().y + radius),
+            ),
+            SliderOrientation::Vertical => Rect::from_min_max(
+                pos2(rect.center().x - radius, rect.top()),
+                pos2(rect.center().x + radius, rect.bottom()),
+            ),
+        }
+    }
+
+    fn handle_radius(&self, rect: &Rect) -> f32 {
+        let limit = match self.orientation {
+            SliderOrientation::Horizontal => rect.height(),
+            SliderOrientation::Vertical => rect.width(),
+        };
+        limit / 2.5
+    }
+
+    fn rail_radius_limit(&self, rect: &Rect) -> f32 {
+        match self.orientation {
+            SliderOrientation::Horizontal => (rect.height() / 4.0).at_least(2.0),
+            SliderOrientation::Vertical => (rect.width() / 4.0).at_least(2.0),
+        }
+    }
+
+    fn value_ui(&mut self, ui: &mut Ui, position_range: RangeInclusive<f32>) -> Response {
+        // If [`DragValue`] is controlled from the keyboard and `step` is defined, set speed to `step`
+        let change = ui.input(|input| {
+            input.num_presses(Key::ArrowUp) as i32 + input.num_presses(Key::ArrowRight) as i32
+                - input.num_presses(Key::ArrowDown) as i32
+                - input.num_presses(Key::ArrowLeft) as i32
+        });
+
+        let any_change = change != 0;
+        let speed = if let (Some(step), true) = (self.step, any_change) {
+            // If [`DragValue`] is controlled from the keyboard and `step` is defined, set speed to `step`
+            step
+        } else {
+            self.drag_value_speed
+                .unwrap_or_else(|| self.current_gradient(&position_range))
+        };
+
+        let mut value = self.get_value();
+        let response = ui.add({
+            let mut dv = DragValue::new(&mut value)
+                .speed(speed)
+                .clamp_range(self.clamp_range())
+                .min_decimals(self.min_decimals)
+                .max_decimals_opt(self.max_decimals)
+                .suffix(self.suffix.clone())
+                .prefix(self.prefix.clone());
+            if let Some(fmt) = &self.custom_formatter {
+                dv = dv.custom_formatter(fmt);
+            };
+            if let Some(parser) = &self.custom_parser {
+                dv = dv.custom_parser(parser);
+            }
+            dv
+        });
+        if value != self.get_value() {
+            self.set_value(value);
+        }
+        response
+    }
+
+    /// delta(value) / delta(points)
+    fn current_gradient(&mut self, position_range: &RangeInclusive<f32>) -> f64 {
+        // TODO(emilk): handle clamping
+        let value = self.get_value();
+        let value_from_pos =
+            |position: f32| self.value_from_position(position, position_range.clone());
+        let pos_from_value = |value: f64| self.position_from_value(value, position_range.clone());
+        let left_value = value_from_pos(pos_from_value(value) - 0.5);
+        let right_value = value_from_pos(pos_from_value(value) + 0.5);
+        right_value - left_value
+    }
+
+    fn add_contents(&mut self, ui: &mut Ui) -> Response {
+        let old_value = self.get_value();
+
+        let thickness = ui
+            .text_style_height(&TextStyle::Body)
+            .at_least(ui.spacing().interact_size.y);
+        let mut response = self.allocate_slider_space(ui, thickness);
+        self.slider_ui(ui, &response);
+
+        let value = self.get_value();
+        response.changed = value != old_value;
+        response.widget_info(|| WidgetInfo::slider(value, self.text.text()));
+
+        #[cfg(feature = "accesskit")]
+        ui.ctx().accesskit_node_builder(response.id, |builder| {
+            use accesskit::Action;
+            builder.set_min_numeric_value(*self.range.start());
+            builder.set_max_numeric_value(*self.range.end());
+            if let Some(step) = self.step {
+                builder.set_numeric_value_step(step);
+            }
+            builder.add_action(Action::SetValue);
+            let clamp_range = self.clamp_range();
+            if value < *clamp_range.end() {
+                builder.add_action(Action::Increment);
+            }
+            if value > *clamp_range.start() {
+                builder.add_action(Action::Decrement);
+            }
+        });
+
+        let slider_response = response.clone();
+
+        let value_response = if self.show_value {
+            let position_range = self.position_range(&response.rect);
+            let value_response = self.value_ui(ui, position_range);
+            if value_response.gained_focus()
+                || value_response.has_focus()
+                || value_response.lost_focus()
+            {
+                // Use the [`DragValue`] id as the id of the whole widget,
+                // so that the focus events work as expected.
+                response = value_response.union(response);
+            } else {
+                // Use the slider id as the id for the whole widget
+                response = response.union(value_response.clone());
+            }
+            Some(value_response)
+        } else {
+            None
+        };
+
+        if !self.text.is_empty() {
+            let label_response = ui.add(Label::new(self.text.clone()).wrap(false));
+            // The slider already has an accessibility label via widget info,
+            // but sometimes it's useful for a screen reader to know
+            // that a piece of text is a label for another widget,
+            // e.g. so the text itself can be excluded from navigation.
+            slider_response.labelled_by(label_response.id);
+            if let Some(value_response) = value_response {
+                value_response.labelled_by(label_response.id);
+            }
+        }
+
+        response
+    }
+}
+
+impl<'a> Widget for Slider<'a> {
+    fn ui(mut self, ui: &mut Ui) -> Response {
+        let inner_response = match self.orientation {
+            SliderOrientation::Horizontal => ui.horizontal(|ui| self.add_contents(ui)),
+            SliderOrientation::Vertical => ui.vertical(|ui| self.add_contents(ui)),
+        };
+
+        inner_response.inner | inner_response.response
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Helpers for converting slider range to/from normalized [0-1] range.
+// Always clamps.
+// Logarithmic sliders are allowed to include zero and infinity,
+// even though mathematically it doesn't make sense.
+
+use std::f64::INFINITY;
+
+/// When the user asks for an infinitely large range (e.g. logarithmic from zero),
+/// give a scale that this many orders of magnitude in size.
+const INF_RANGE_MAGNITUDE: f64 = 10.0;
+
+fn value_from_normalized(normalized: f64, range: RangeInclusive<f64>, spec: &SliderSpec) -> f64 {
+    let (min, max) = (*range.start(), *range.end());
+
+    if min.is_nan() || max.is_nan() {
+        f64::NAN
+    } else if min == max {
+        min
+    } else if min > max {
+        value_from_normalized(1.0 - normalized, max..=min, spec)
+    } else if normalized <= 0.0 {
+        min
+    } else if normalized >= 1.0 {
+        max
+    } else if spec.logarithmic {
+        if max <= 0.0 {
+            // non-positive range
+            -value_from_normalized(normalized, -min..=-max, spec)
+        } else if 0.0 <= min {
+            let (min_log, max_log) = range_log10(min, max, spec);
+            let log = lerp(min_log..=max_log, normalized);
+            10.0_f64.powf(log)
+        } else {
+            assert!(min < 0.0 && 0.0 < max);
+            let zero_cutoff = logarithmic_zero_cutoff(min, max);
+            if normalized < zero_cutoff {
+                // negative
+                value_from_normalized(
+                    remap(normalized, 0.0..=zero_cutoff, 0.0..=1.0),
+                    min..=0.0,
+                    spec,
+                )
+            } else {
+                // positive
+                value_from_normalized(
+                    remap(normalized, zero_cutoff..=1.0, 0.0..=1.0),
+                    0.0..=max,
+                    spec,
+                )
+            }
+        }
+    } else {
+        crate::egui_assert!(
+            min.is_finite() && max.is_finite(),
+            "You should use a logarithmic range"
+        );
+        lerp(range, normalized.clamp(0.0, 1.0))
+    }
+}
+
+fn normalized_from_value(value: f64, range: RangeInclusive<f64>, spec: &SliderSpec) -> f64 {
+    let (min, max) = (*range.start(), *range.end());
+
+    if min.is_nan() || max.is_nan() {
+        f64::NAN
+    } else if min == max {
+        0.5 // empty range, show center of slider
+    } else if min > max {
+        1.0 - normalized_from_value(value, max..=min, spec)
+    } else if value <= min {
+        0.0
+    } else if value >= max {
+        1.0
+    } else if spec.logarithmic {
+        if max <= 0.0 {
+            // non-positive range
+            normalized_from_value(-value, -min..=-max, spec)
+        } else if 0.0 <= min {
+            let (min_log, max_log) = range_log10(min, max, spec);
+            let value_log = value.log10();
+            remap_clamp(value_log, min_log..=max_log, 0.0..=1.0)
+        } else {
+            assert!(min < 0.0 && 0.0 < max);
+            let zero_cutoff = logarithmic_zero_cutoff(min, max);
+            if value < 0.0 {
+                // negative
+                remap(
+                    normalized_from_value(value, min..=0.0, spec),
+                    0.0..=1.0,
+                    0.0..=zero_cutoff,
+                )
+            } else {
+                // positive side
+                remap(
+                    normalized_from_value(value, 0.0..=max, spec),
+                    0.0..=1.0,
+                    zero_cutoff..=1.0,
+                )
+            }
+        }
+    } else {
+        crate::egui_assert!(
+            min.is_finite() && max.is_finite(),
+            "You should use a logarithmic range"
+        );
+        remap_clamp(value, range, 0.0..=1.0)
+    }
+}
+
+fn range_log10(min: f64, max: f64, spec: &SliderSpec) -> (f64, f64) {
+    assert!(spec.logarithmic);
+    assert!(min <= max);
+
+    if min == 0.0 && max == INFINITY {
+        (spec.smallest_positive.log10(), INF_RANGE_MAGNITUDE)
+    } else if min == 0.0 {
+        if spec.smallest_positive < max {
+            (spec.smallest_positive.log10(), max.log10())
+        } else {
+            (max.log10() - INF_RANGE_MAGNITUDE, max.log10())
+        }
+    } else if max == INFINITY {
+        if min < spec.largest_finite {
+            (min.log10(), spec.largest_finite.log10())
+        } else {
+            (min.log10(), min.log10() + INF_RANGE_MAGNITUDE)
+        }
+    } else {
+        (min.log10(), max.log10())
+    }
+}
+
+/// where to put the zero cutoff for logarithmic sliders
+/// that crosses zero ?
+fn logarithmic_zero_cutoff(min: f64, max: f64) -> f64 {
+    assert!(min < 0.0 && 0.0 < max);
+
+    let min_magnitude = if min == -INFINITY {
+        INF_RANGE_MAGNITUDE
+    } else {
+        min.abs().log10().abs()
+    };
+    let max_magnitude = if max == INFINITY {
+        INF_RANGE_MAGNITUDE
+    } else {
+        max.log10().abs()
+    };
+
+    let cutoff = min_magnitude / (min_magnitude + max_magnitude);
+    crate::egui_assert!(0.0 <= cutoff && cutoff <= 1.0);
+    cutoff
+}
diff --git a/egui/crates/egui/src/widgets/spinner.rs b/egui/crates/egui/src/widgets/spinner.rs
new file mode 100644
index 0000000..f2b253b
--- /dev/null
+++ b/egui/crates/egui/src/widgets/spinner.rs
@@ -0,0 +1,67 @@
+use epaint::{emath::lerp, vec2, Color32, Pos2, Shape, Stroke};
+
+use crate::{Response, Sense, Ui, Widget};
+
+/// A spinner widget used to indicate loading.
+///
+/// See also: [`crate::ProgressBar`].
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+#[derive(Default)]
+pub struct Spinner {
+    /// Uses the style's `interact_size` if `None`.
+    size: Option<f32>,
+    color: Option<Color32>,
+}
+
+impl Spinner {
+    /// Create a new spinner that uses the style's `interact_size` unless changed.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets the spinner's size. The size sets both the height and width, as the spinner is always
+    /// square. If the size isn't set explicitly, the active style's `interact_size` is used.
+    pub fn size(mut self, size: f32) -> Self {
+        self.size = Some(size);
+        self
+    }
+
+    /// Sets the spinner's color.
+    pub fn color(mut self, color: impl Into<Color32>) -> Self {
+        self.color = Some(color.into());
+        self
+    }
+}
+
+impl Widget for Spinner {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let size = self
+            .size
+            .unwrap_or_else(|| ui.style().spacing.interact_size.y);
+        let color = self
+            .color
+            .unwrap_or_else(|| ui.visuals().strong_text_color());
+        let (rect, response) = ui.allocate_exact_size(vec2(size, size), Sense::hover());
+
+        if ui.is_rect_visible(rect) {
+            ui.ctx().request_repaint();
+
+            let radius = (rect.height() / 2.0) - 2.0;
+            let n_points = 20;
+            let time = ui.input(|i| i.time);
+            let start_angle = time * std::f64::consts::TAU;
+            let end_angle = start_angle + 240f64.to_radians() * time.sin();
+            let points: Vec<Pos2> = (0..n_points)
+                .map(|i| {
+                    let angle = lerp(start_angle..=end_angle, i as f64 / n_points as f64);
+                    let (sin, cos) = angle.sin_cos();
+                    rect.center() + radius * vec2(cos as f32, sin as f32)
+                })
+                .collect();
+            ui.painter()
+                .add(Shape::line(points, Stroke::new(3.0, color)));
+        }
+
+        response
+    }
+}
diff --git a/egui/crates/egui/src/widgets/text_edit/builder.rs b/egui/crates/egui/src/widgets/text_edit/builder.rs
new file mode 100644
index 0000000..b76c6e3
--- /dev/null
+++ b/egui/crates/egui/src/widgets/text_edit/builder.rs
@@ -0,0 +1,1643 @@
+use std::sync::Arc;
+
+use epaint::text::{cursor::*, Galley, LayoutJob};
+
+use crate::{output::OutputEvent, *};
+
+use super::{CCursorRange, CursorRange, TextEditOutput, TextEditState};
+
+/// A text region that the user can edit the contents of.
+///
+/// See also [`Ui::text_edit_singleline`] and [`Ui::text_edit_multiline`].
+///
+/// Example:
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # let mut my_string = String::new();
+/// let response = ui.add(egui::TextEdit::singleline(&mut my_string));
+/// if response.changed() {
+///     // …
+/// }
+/// if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+///     // …
+/// }
+/// # });
+/// ```
+///
+/// To fill an [`Ui`] with a [`TextEdit`] use [`Ui::add_sized`]:
+///
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// # let mut my_string = String::new();
+/// ui.add_sized(ui.available_size(), egui::TextEdit::multiline(&mut my_string));
+/// # });
+/// ```
+///
+///
+/// You can also use [`TextEdit`] to show text that can be selected, but not edited.
+/// To do so, pass in a `&mut` reference to a `&str`, for instance:
+///
+/// ```
+/// fn selectable_text(ui: &mut egui::Ui, mut text: &str) {
+///     ui.add(egui::TextEdit::multiline(&mut text));
+/// }
+/// ```
+///
+/// ## Advanced usage
+/// See [`TextEdit::show`].
+///
+/// ## Other
+/// The background color of a [`TextEdit`] is [`Visuals::extreme_bg_color`].
+#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
+pub struct TextEdit<'t> {
+    text: &'t mut dyn TextBuffer,
+    hint_text: WidgetText,
+    id: Option<Id>,
+    id_source: Option<Id>,
+    font_selection: FontSelection,
+    text_color: Option<Color32>,
+    layouter: Option<&'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>>,
+    password: bool,
+    frame: bool,
+    margin: Vec2,
+    multiline: bool,
+    interactive: bool,
+    desired_width: Option<f32>,
+    desired_height_rows: usize,
+    lock_focus: bool,
+    cursor_at_end: bool,
+    min_size: Vec2,
+    align: Align2,
+    clip_text: bool,
+    char_limit: usize,
+}
+
+impl<'t> WidgetWithState for TextEdit<'t> {
+    type State = TextEditState;
+}
+
+impl<'t> TextEdit<'t> {
+    pub fn load_state(ctx: &Context, id: Id) -> Option<TextEditState> {
+        TextEditState::load(ctx, id)
+    }
+
+    pub fn store_state(ctx: &Context, id: Id, state: TextEditState) {
+        state.store(ctx, id);
+    }
+}
+
+impl<'t> TextEdit<'t> {
+    /// No newlines (`\n`) allowed. Pressing enter key will result in the [`TextEdit`] losing focus (`response.lost_focus`).
+    pub fn singleline(text: &'t mut dyn TextBuffer) -> Self {
+        Self {
+            desired_height_rows: 1,
+            multiline: false,
+            clip_text: true,
+            ..Self::multiline(text)
+        }
+    }
+
+    /// A [`TextEdit`] for multiple lines. Pressing enter key will create a new line.
+    pub fn multiline(text: &'t mut dyn TextBuffer) -> Self {
+        Self {
+            text,
+            hint_text: Default::default(),
+            id: None,
+            id_source: None,
+            font_selection: Default::default(),
+            text_color: None,
+            layouter: None,
+            password: false,
+            frame: true,
+            margin: vec2(4.0, 2.0),
+            multiline: true,
+            interactive: true,
+            desired_width: None,
+            desired_height_rows: 4,
+            lock_focus: false,
+            cursor_at_end: true,
+            min_size: Vec2::ZERO,
+            align: Align2::LEFT_TOP,
+            clip_text: false,
+            char_limit: usize::MAX,
+        }
+    }
+
+    /// Build a [`TextEdit`] focused on code editing.
+    /// By default it comes with:
+    /// - monospaced font
+    /// - focus lock
+    pub fn code_editor(self) -> Self {
+        self.font(TextStyle::Monospace).lock_focus(true)
+    }
+
+    /// Use if you want to set an explicit [`Id`] for this widget.
+    pub fn id(mut self, id: Id) -> Self {
+        self.id = Some(id);
+        self
+    }
+
+    /// A source for the unique [`Id`], e.g. `.id_source("second_text_edit_field")` or `.id_source(loop_index)`.
+    pub fn id_source(mut self, id_source: impl std::hash::Hash) -> Self {
+        self.id_source = Some(Id::new(id_source));
+        self
+    }
+
+    /// Show a faint hint text when the text field is empty.
+    ///
+    /// If the hint text needs to be persisted even when the text field has input,
+    /// the following workaround can be used:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_string = String::new();
+    /// # use egui::{ Color32, FontId };
+    /// let text_edit = egui::TextEdit::multiline(&mut my_string)
+    ///     .desired_width(f32::INFINITY);
+    /// let output = text_edit.show(ui);
+    /// let painter = ui.painter_at(output.response.rect);
+    /// let galley = painter.layout(
+    ///     String::from("Enter text"),
+    ///     FontId::default(),
+    ///     Color32::from_rgba_premultiplied(100, 100, 100, 100),
+    ///     f32::INFINITY
+    /// );
+    /// painter.galley(output.text_draw_pos, galley);
+    /// # });
+    /// ```
+    pub fn hint_text(mut self, hint_text: impl Into<WidgetText>) -> Self {
+        self.hint_text = hint_text.into();
+        self
+    }
+
+    /// If true, hide the letters from view and prevent copying from the field.
+    pub fn password(mut self, password: bool) -> Self {
+        self.password = password;
+        self
+    }
+
+    /// Pick a [`FontId`] or [`TextStyle`].
+    pub fn font(mut self, font_selection: impl Into<FontSelection>) -> Self {
+        self.font_selection = font_selection.into();
+        self
+    }
+
+    #[deprecated = "Use .font(…) instead"]
+    pub fn text_style(self, text_style: TextStyle) -> Self {
+        self.font(text_style)
+    }
+
+    pub fn text_color(mut self, text_color: Color32) -> Self {
+        self.text_color = Some(text_color);
+        self
+    }
+
+    pub fn text_color_opt(mut self, text_color: Option<Color32>) -> Self {
+        self.text_color = text_color;
+        self
+    }
+
+    /// Override how text is being shown inside the [`TextEdit`].
+    ///
+    /// This can be used to implement things like syntax highlighting.
+    ///
+    /// This function will be called at least once per frame,
+    /// so it is strongly suggested that you cache the results of any syntax highlighter
+    /// so as not to waste CPU highlighting the same string every frame.
+    ///
+    /// The arguments is the enclosing [`Ui`] (so you can access e.g. [`Ui::fonts`]),
+    /// the text and the wrap width.
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_code = String::new();
+    /// # fn my_memoized_highlighter(s: &str) -> egui::text::LayoutJob { Default::default() }
+    /// let mut layouter = |ui: &egui::Ui, string: &str, wrap_width: f32| {
+    ///     let mut layout_job: egui::text::LayoutJob = my_memoized_highlighter(string);
+    ///     layout_job.wrap.max_width = wrap_width;
+    ///     ui.fonts(|f| f.layout_job(layout_job))
+    /// };
+    /// ui.add(egui::TextEdit::multiline(&mut my_code).layouter(&mut layouter));
+    /// # });
+    /// ```
+    pub fn layouter(mut self, layouter: &'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>) -> Self {
+        self.layouter = Some(layouter);
+
+        self
+    }
+
+    /// Default is `true`. If set to `false` then you cannot interact with the text (neither edit or select it).
+    ///
+    /// Consider using [`Ui::add_enabled`] instead to also give the [`TextEdit`] a greyed out look.
+    pub fn interactive(mut self, interactive: bool) -> Self {
+        self.interactive = interactive;
+        self
+    }
+
+    /// Default is `true`. If set to `false` there will be no frame showing that this is editable text!
+    pub fn frame(mut self, frame: bool) -> Self {
+        self.frame = frame;
+        self
+    }
+
+    /// Set margin of text. Default is [4.0,2.0]
+    pub fn margin(mut self, margin: Vec2) -> Self {
+        self.margin = margin;
+        self
+    }
+
+    /// Set to 0.0 to keep as small as possible.
+    /// Set to [`f32::INFINITY`] to take up all available space (i.e. disable automatic word wrap).
+    pub fn desired_width(mut self, desired_width: f32) -> Self {
+        self.desired_width = Some(desired_width);
+        self
+    }
+
+    /// Set the number of rows to show by default.
+    /// The default for singleline text is `1`.
+    /// The default for multiline text is `4`.
+    pub fn desired_rows(mut self, desired_height_rows: usize) -> Self {
+        self.desired_height_rows = desired_height_rows;
+        self
+    }
+
+    /// When `false` (default), pressing TAB will move focus
+    /// to the next widget.
+    ///
+    /// When `true`, the widget will keep the focus and pressing TAB
+    /// will insert the `'\t'` character.
+    pub fn lock_focus(mut self, b: bool) -> Self {
+        self.lock_focus = b;
+        self
+    }
+
+    /// When `true` (default), the cursor will initially be placed at the end of the text.
+    ///
+    /// When `false`, the cursor will initially be placed at the beginning of the text.
+    pub fn cursor_at_end(mut self, b: bool) -> Self {
+        self.cursor_at_end = b;
+        self
+    }
+
+    /// When `true` (default), overflowing text will be clipped.
+    ///
+    /// When `false`, widget width will expand to make all text visible.
+    ///
+    /// This only works for singleline [`TextEdit`].
+    pub fn clip_text(mut self, b: bool) -> Self {
+        // always show everything in multiline
+        if !self.multiline {
+            self.clip_text = b;
+        }
+        self
+    }
+
+    /// Sets the limit for the amount of characters can be entered
+    ///
+    /// This only works for singleline [`TextEdit`]
+    pub fn char_limit(mut self, limit: usize) -> Self {
+        self.char_limit = limit;
+        self
+    }
+
+    /// Set the horizontal align of the inner text.
+    pub fn horizontal_align(mut self, align: Align) -> Self {
+        self.align.0[0] = align;
+        self
+    }
+
+    /// Set the vertical align of the inner text.
+    pub fn vertical_align(mut self, align: Align) -> Self {
+        self.align.0[1] = align;
+        self
+    }
+
+    /// Set the minimum size of the [`TextEdit`].
+    pub fn min_size(mut self, min_size: Vec2) -> Self {
+        self.min_size = min_size;
+        self
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+impl<'t> Widget for TextEdit<'t> {
+    fn ui(self, ui: &mut Ui) -> Response {
+        self.show(ui).response
+    }
+}
+
+impl<'t> TextEdit<'t> {
+    /// Show the [`TextEdit`], returning a rich [`TextEditOutput`].
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// # let mut my_string = String::new();
+    /// let output = egui::TextEdit::singleline(&mut my_string).show(ui);
+    /// if let Some(text_cursor_range) = output.cursor_range {
+    ///     use egui::TextBuffer as _;
+    ///     let selected_chars = text_cursor_range.as_sorted_char_range();
+    ///     let selected_text = my_string.char_range(selected_chars);
+    ///     ui.label("Selected text: ");
+    ///     ui.monospace(selected_text);
+    /// }
+    /// # });
+    /// ```
+    pub fn show(self, ui: &mut Ui) -> TextEditOutput {
+        let is_mutable = self.text.is_mutable();
+        let frame = self.frame;
+        let interactive = self.interactive;
+        let where_to_put_background = ui.painter().add(Shape::Noop);
+
+        let margin = self.margin;
+        let max_rect = ui.available_rect_before_wrap().shrink2(margin);
+        let mut content_ui = ui.child_ui(max_rect, *ui.layout());
+        let mut output = self.show_content(&mut content_ui);
+        let id = output.response.id;
+        let frame_rect = output.response.rect.expand2(margin);
+        ui.allocate_space(frame_rect.size());
+        if interactive {
+            output.response |= ui.interact(frame_rect, id, Sense::click());
+        }
+        if output.response.clicked() && !output.response.lost_focus() {
+            ui.memory_mut(|mem| mem.request_focus(output.response.id));
+        }
+
+        if frame {
+            let visuals = ui.style().interact(&output.response);
+            let frame_rect = frame_rect.expand(visuals.expansion);
+            let shape = if is_mutable {
+                if output.response.has_focus() {
+                    epaint::RectShape {
+                        rect: frame_rect,
+                        rounding: visuals.rounding,
+                        // fill: ui.visuals().selection.bg_fill,
+                        fill: ui.visuals().extreme_bg_color,
+                        stroke: ui.visuals().selection.stroke,
+                    }
+                } else {
+                    epaint::RectShape {
+                        rect: frame_rect,
+                        rounding: visuals.rounding,
+                        fill: ui.visuals().extreme_bg_color,
+                        stroke: visuals.bg_stroke, // TODO(emilk): we want to show something here, or a text-edit field doesn't "pop".
+                    }
+                }
+            } else {
+                let visuals = &ui.style().visuals.widgets.inactive;
+                epaint::RectShape {
+                    rect: frame_rect,
+                    rounding: visuals.rounding,
+                    // fill: ui.visuals().extreme_bg_color,
+                    // fill: visuals.bg_fill,
+                    fill: Color32::TRANSPARENT,
+                    stroke: visuals.bg_stroke, // TODO(emilk): we want to show something here, or a text-edit field doesn't "pop".
+                }
+            };
+
+            ui.painter().set(where_to_put_background, shape);
+        }
+
+        output
+    }
+
+    fn show_content(self, ui: &mut Ui) -> TextEditOutput {
+        let TextEdit {
+            text,
+            hint_text,
+            id,
+            id_source,
+            font_selection,
+            text_color,
+            layouter,
+            password,
+            frame: _,
+            margin,
+            multiline,
+            interactive,
+            desired_width,
+            desired_height_rows,
+            lock_focus,
+            cursor_at_end,
+            min_size,
+            align,
+            clip_text,
+            char_limit,
+        } = self;
+
+        let text_color = text_color
+            .or(ui.visuals().override_text_color)
+            // .unwrap_or_else(|| ui.style().interact(&response).text_color()); // too bright
+            .unwrap_or_else(|| ui.visuals().widgets.inactive.text_color());
+
+        let prev_text = text.as_str().to_owned();
+
+        let font_id = font_selection.resolve(ui.style());
+        let row_height = ui.fonts(|f| f.row_height(&font_id));
+        const MIN_WIDTH: f32 = 24.0; // Never make a [`TextEdit`] more narrow than this.
+        let available_width = ui.available_width().at_least(MIN_WIDTH);
+        let desired_width = desired_width.unwrap_or_else(|| ui.spacing().text_edit_width);
+        let wrap_width = if ui.layout().horizontal_justify() {
+            available_width
+        } else {
+            desired_width.min(available_width)
+        } - margin.x * 2.0;
+
+        let font_id_clone = font_id.clone();
+        let mut default_layouter = move |ui: &Ui, text: &str, wrap_width: f32| {
+            let text = mask_if_password(password, text);
+            let layout_job = if multiline {
+                LayoutJob::simple(text, font_id_clone.clone(), text_color, wrap_width)
+            } else {
+                LayoutJob::simple_singleline(text, font_id_clone.clone(), text_color)
+            };
+            ui.fonts(|f| f.layout_job(layout_job))
+        };
+
+        let layouter = layouter.unwrap_or(&mut default_layouter);
+
+        let mut galley = layouter(ui, text.as_str(), wrap_width);
+
+        let desired_width = if clip_text {
+            wrap_width // visual clipping with scroll in singleline input.
+        } else {
+            galley.size().x.max(wrap_width)
+        };
+        let desired_height = (desired_height_rows.at_least(1) as f32) * row_height;
+        let desired_size = vec2(desired_width, galley.size().y.max(desired_height))
+            .at_least(min_size - margin * 2.0);
+
+        let (auto_id, rect) = ui.allocate_space(desired_size);
+
+        let id = id.unwrap_or_else(|| {
+            if let Some(id_source) = id_source {
+                ui.make_persistent_id(id_source)
+            } else {
+                auto_id // Since we are only storing the cursor a persistent Id is not super important
+            }
+        });
+        let mut state = TextEditState::load(ui.ctx(), id).unwrap_or_default();
+
+        // On touch screens (e.g. mobile in `eframe` web), should
+        // dragging select text, or scroll the enclosing [`ScrollArea`] (if any)?
+        // Since currently copying selected text in not supported on `eframe` web,
+        // we prioritize touch-scrolling:
+        let allow_drag_to_select =
+            ui.input(|i| !i.any_touches()) || ui.memory(|mem| mem.has_focus(id));
+
+        let sense = if interactive {
+            if allow_drag_to_select {
+                Sense::click_and_drag()
+            } else {
+                Sense::click()
+            }
+        } else {
+            Sense::hover()
+        };
+        let mut response = ui.interact(rect, id, sense);
+        let text_clip_rect = rect;
+        let painter = ui.painter_at(text_clip_rect.expand(1.0)); // expand to avoid clipping cursor
+
+        if interactive {
+            if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
+                if response.hovered() && text.is_mutable() {
+                    ui.output_mut(|o| o.mutable_text_under_cursor = true);
+                }
+
+                // TODO(emilk): drag selected text to either move or clone (ctrl on windows, alt on mac)
+                let singleline_offset = vec2(state.singleline_offset, 0.0);
+                let cursor_at_pointer =
+                    galley.cursor_from_pos(pointer_pos - response.rect.min + singleline_offset);
+
+                if ui.visuals().text_cursor_preview
+                    && response.hovered()
+                    && ui.input(|i| i.pointer.is_moving())
+                {
+                    // preview:
+                    paint_cursor_end(
+                        ui,
+                        row_height,
+                        &painter,
+                        response.rect.min,
+                        &galley,
+                        &cursor_at_pointer,
+                    );
+                }
+
+                if response.double_clicked() {
+                    // Select word:
+                    let center = cursor_at_pointer;
+                    let ccursor_range = select_word_at(text.as_str(), center.ccursor);
+                    state.set_cursor_range(Some(CursorRange {
+                        primary: galley.from_ccursor(ccursor_range.primary),
+                        secondary: galley.from_ccursor(ccursor_range.secondary),
+                    }));
+                } else if response.triple_clicked() {
+                    // Select line:
+                    let center = cursor_at_pointer;
+                    let ccursor_range = select_line_at(text.as_str(), center.ccursor);
+                    state.set_cursor_range(Some(CursorRange {
+                        primary: galley.from_ccursor(ccursor_range.primary),
+                        secondary: galley.from_ccursor(ccursor_range.secondary),
+                    }));
+                } else if allow_drag_to_select {
+                    if response.hovered() && ui.input(|i| i.pointer.any_pressed()) {
+                        ui.memory_mut(|mem| mem.request_focus(id));
+                        if ui.input(|i| i.modifiers.shift) {
+                            if let Some(mut cursor_range) = state.cursor_range(&galley) {
+                                cursor_range.primary = cursor_at_pointer;
+                                state.set_cursor_range(Some(cursor_range));
+                            } else {
+                                state.set_cursor_range(Some(CursorRange::one(cursor_at_pointer)));
+                            }
+                        } else {
+                            state.set_cursor_range(Some(CursorRange::one(cursor_at_pointer)));
+                        }
+                    } else if ui.input(|i| i.pointer.any_down())
+                        && response.is_pointer_button_down_on()
+                    {
+                        // drag to select text:
+                        if let Some(mut cursor_range) = state.cursor_range(&galley) {
+                            cursor_range.primary = cursor_at_pointer;
+                            state.set_cursor_range(Some(cursor_range));
+                        }
+                    }
+                }
+            }
+        }
+
+        if interactive && response.hovered() {
+            ui.ctx().set_cursor_icon(CursorIcon::Text);
+        }
+
+        let mut cursor_range = None;
+        let prev_cursor_range = state.cursor_range(&galley);
+        if interactive && ui.memory(|mem| mem.has_focus(id)) {
+            ui.memory_mut(|mem| mem.lock_focus(id, lock_focus));
+
+            let default_cursor_range = if cursor_at_end {
+                CursorRange::one(galley.end())
+            } else {
+                CursorRange::default()
+            };
+
+            let (changed, new_cursor_range) = events(
+                ui,
+                &mut state,
+                text,
+                &mut galley,
+                layouter,
+                id,
+                wrap_width,
+                multiline,
+                password,
+                default_cursor_range,
+                char_limit,
+            );
+
+            if changed {
+                response.mark_changed();
+            }
+            cursor_range = Some(new_cursor_range);
+        }
+
+        let mut text_draw_pos = align
+            .align_size_within_rect(galley.size(), response.rect)
+            .intersect(response.rect) // limit pos to the response rect area
+            .min;
+        let align_offset = response.rect.left() - text_draw_pos.x;
+
+        // Visual clipping for singleline text editor with text larger than width
+        if clip_text && align_offset == 0.0 {
+            let cursor_pos = match (cursor_range, ui.memory(|mem| mem.has_focus(id))) {
+                (Some(cursor_range), true) => galley.pos_from_cursor(&cursor_range.primary).min.x,
+                _ => 0.0,
+            };
+
+            let mut offset_x = state.singleline_offset;
+            let visible_range = offset_x..=offset_x + desired_size.x;
+
+            if !visible_range.contains(&cursor_pos) {
+                if cursor_pos < *visible_range.start() {
+                    offset_x = cursor_pos;
+                } else {
+                    offset_x = cursor_pos - desired_size.x;
+                }
+            }
+
+            offset_x = offset_x
+                .at_most(galley.size().x - desired_size.x)
+                .at_least(0.0);
+
+            state.singleline_offset = offset_x;
+            text_draw_pos -= vec2(offset_x, 0.0);
+        } else {
+            state.singleline_offset = align_offset;
+        }
+
+        let selection_changed = if let (Some(cursor_range), Some(prev_cursor_range)) =
+            (cursor_range, prev_cursor_range)
+        {
+            prev_cursor_range.as_ccursor_range() != cursor_range.as_ccursor_range()
+        } else {
+            false
+        };
+
+        if ui.is_rect_visible(rect) {
+            painter.galley(text_draw_pos, galley.clone());
+
+            if text.as_str().is_empty() && !hint_text.is_empty() {
+                let hint_text_color = ui.visuals().weak_text_color();
+                let galley = if multiline {
+                    hint_text.into_galley(ui, Some(true), desired_size.x, font_id)
+                } else {
+                    hint_text.into_galley(ui, Some(false), f32::INFINITY, font_id)
+                };
+                galley.paint_with_fallback_color(&painter, response.rect.min, hint_text_color);
+            }
+
+            if ui.memory(|mem| mem.has_focus(id)) {
+                if let Some(cursor_range) = state.cursor_range(&galley) {
+                    // We paint the cursor on top of the text, in case
+                    // the text galley has backgrounds (as e.g. `code` snippets in markup do).
+                    paint_cursor_selection(ui, &painter, text_draw_pos, &galley, &cursor_range);
+
+                    if text.is_mutable() {
+                        let cursor_pos = paint_cursor_end(
+                            ui,
+                            row_height,
+                            &painter,
+                            text_draw_pos,
+                            &galley,
+                            &cursor_range.primary,
+                        );
+
+                        let is_fully_visible = ui.clip_rect().contains_rect(rect); // TODO: remove this HACK workaround for https://github.com/emilk/egui/issues/1531
+                        if (response.changed || selection_changed) && !is_fully_visible {
+                            ui.scroll_to_rect(cursor_pos, None); // keep cursor in view
+                        }
+
+                        if interactive {
+                            // eframe web uses `text_cursor_pos` when showing IME,
+                            // so only set it when text is editable and visible!
+                            // But `winit` and `egui_web` differs in how to set the
+                            // position of IME.
+                            if cfg!(target_arch = "wasm32") {
+                                ui.ctx().output_mut(|o| {
+                                    o.text_cursor_pos = Some(cursor_pos.left_top());
+                                });
+                            } else {
+                                ui.ctx().output_mut(|o| {
+                                    o.text_cursor_pos = Some(cursor_pos.left_bottom());
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        state.clone().store(ui.ctx(), id);
+
+        if response.changed {
+            response.widget_info(|| {
+                WidgetInfo::text_edit(
+                    mask_if_password(password, prev_text.as_str()),
+                    mask_if_password(password, text.as_str()),
+                )
+            });
+        } else if selection_changed {
+            let cursor_range = cursor_range.unwrap();
+            let char_range =
+                cursor_range.primary.ccursor.index..=cursor_range.secondary.ccursor.index;
+            let info = WidgetInfo::text_selection_changed(
+                char_range,
+                mask_if_password(password, text.as_str()),
+            );
+            response.output_event(OutputEvent::TextSelectionChanged(info));
+        } else {
+            response.widget_info(|| {
+                WidgetInfo::text_edit(
+                    mask_if_password(password, prev_text.as_str()),
+                    mask_if_password(password, text.as_str()),
+                )
+            });
+        }
+
+        #[cfg(feature = "accesskit")]
+        {
+            let parent_id = ui.ctx().accesskit_node_builder(response.id, |builder| {
+                use accesskit::{TextPosition, TextSelection};
+
+                let parent_id = response.id;
+
+                if let Some(cursor_range) = &cursor_range {
+                    let anchor = &cursor_range.secondary.rcursor;
+                    let focus = &cursor_range.primary.rcursor;
+                    builder.set_text_selection(TextSelection {
+                        anchor: TextPosition {
+                            node: parent_id.with(anchor.row).accesskit_id(),
+                            character_index: anchor.column,
+                        },
+                        focus: TextPosition {
+                            node: parent_id.with(focus.row).accesskit_id(),
+                            character_index: focus.column,
+                        },
+                    });
+                }
+
+                builder.set_default_action_verb(accesskit::DefaultActionVerb::Focus);
+                if self.multiline {
+                    builder.set_multiline();
+                }
+
+                parent_id
+            });
+
+            if let Some(parent_id) = parent_id {
+                // drop ctx lock before further processing
+                use accesskit::{Role, TextDirection};
+
+                ui.ctx().with_accessibility_parent(parent_id, || {
+                    for (i, row) in galley.rows.iter().enumerate() {
+                        let id = parent_id.with(i);
+                        ui.ctx().accesskit_node_builder(id, |builder| {
+                            builder.set_role(Role::InlineTextBox);
+                            let rect = row.rect.translate(text_draw_pos.to_vec2());
+                            builder.set_bounds(accesskit::Rect {
+                                x0: rect.min.x.into(),
+                                y0: rect.min.y.into(),
+                                x1: rect.max.x.into(),
+                                y1: rect.max.y.into(),
+                            });
+                            builder.set_text_direction(TextDirection::LeftToRight);
+                            // TODO(mwcampbell): Set more node fields for the row
+                            // once AccessKit adapters expose text formatting info.
+
+                            let glyph_count = row.glyphs.len();
+                            let mut value = String::new();
+                            value.reserve(glyph_count);
+                            let mut character_lengths = Vec::<u8>::new();
+                            character_lengths.reserve(glyph_count);
+                            let mut character_positions = Vec::<f32>::new();
+                            character_positions.reserve(glyph_count);
+                            let mut character_widths = Vec::<f32>::new();
+                            character_widths.reserve(glyph_count);
+                            let mut word_lengths = Vec::<u8>::new();
+                            let mut was_at_word_end = false;
+                            let mut last_word_start = 0usize;
+
+                            for glyph in &row.glyphs {
+                                let is_word_char = is_word_char(glyph.chr);
+                                if is_word_char && was_at_word_end {
+                                    word_lengths
+                                        .push((character_lengths.len() - last_word_start) as _);
+                                    last_word_start = character_lengths.len();
+                                }
+                                was_at_word_end = !is_word_char;
+                                let old_len = value.len();
+                                value.push(glyph.chr);
+                                character_lengths.push((value.len() - old_len) as _);
+                                character_positions.push(glyph.pos.x - row.rect.min.x);
+                                character_widths.push(glyph.size.x);
+                            }
+
+                            if row.ends_with_newline {
+                                value.push('\n');
+                                character_lengths.push(1);
+                                character_positions.push(row.rect.max.x - row.rect.min.x);
+                                character_widths.push(0.0);
+                            }
+                            word_lengths.push((character_lengths.len() - last_word_start) as _);
+
+                            builder.set_value(value);
+                            builder.set_character_lengths(character_lengths);
+                            builder.set_character_positions(character_positions);
+                            builder.set_character_widths(character_widths);
+                            builder.set_word_lengths(word_lengths);
+                        });
+                    }
+                });
+            }
+        }
+
+        TextEditOutput {
+            response,
+            galley,
+            text_draw_pos,
+            text_clip_rect,
+            state,
+            cursor_range,
+        }
+    }
+}
+
+fn mask_if_password(is_password: bool, text: &str) -> String {
+    fn mask_password(text: &str) -> String {
+        std::iter::repeat(epaint::text::PASSWORD_REPLACEMENT_CHAR)
+            .take(text.chars().count())
+            .collect::<String>()
+    }
+
+    if is_password {
+        mask_password(text)
+    } else {
+        text.to_owned()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "accesskit")]
+fn ccursor_from_accesskit_text_position(
+    id: Id,
+    galley: &Galley,
+    position: &accesskit::TextPosition,
+) -> Option<CCursor> {
+    let mut total_length = 0usize;
+    for (i, row) in galley.rows.iter().enumerate() {
+        let row_id = id.with(i);
+        if row_id.accesskit_id() == position.node {
+            return Some(CCursor {
+                index: total_length + position.character_index,
+                prefer_next_row: !(position.character_index == row.glyphs.len()
+                    && !row.ends_with_newline
+                    && (i + 1) < galley.rows.len()),
+            });
+        }
+        total_length += row.glyphs.len() + (row.ends_with_newline as usize);
+    }
+    None
+}
+
+/// Check for (keyboard) events to edit the cursor and/or text.
+#[allow(clippy::too_many_arguments)]
+fn events(
+    ui: &mut crate::Ui,
+    state: &mut TextEditState,
+    text: &mut dyn TextBuffer,
+    galley: &mut Arc<Galley>,
+    layouter: &mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>,
+    id: Id,
+    wrap_width: f32,
+    multiline: bool,
+    password: bool,
+    default_cursor_range: CursorRange,
+    char_limit: usize,
+) -> (bool, CursorRange) {
+    let mut cursor_range = state.cursor_range(galley).unwrap_or(default_cursor_range);
+
+    // We feed state to the undoer both before and after handling input
+    // so that the undoer creates automatic saves even when there are no events for a while.
+    state.undoer.lock().feed_state(
+        ui.input(|i| i.time),
+        &(cursor_range.as_ccursor_range(), text.as_str().to_owned()),
+    );
+
+    let copy_if_not_password = |ui: &Ui, text: String| {
+        if !password {
+            ui.ctx().output_mut(|o| o.copied_text = text);
+        }
+    };
+
+    let mut any_change = false;
+
+    let events = ui.input(|i| i.events.clone()); // avoid dead-lock by cloning. TODO(emilk): optimize
+    for event in &events {
+        let did_mutate_text = match event {
+            Event::Copy => {
+                if cursor_range.is_empty() {
+                    copy_if_not_password(ui, text.as_str().to_owned());
+                } else {
+                    copy_if_not_password(ui, selected_str(text, &cursor_range).to_owned());
+                }
+                None
+            }
+            Event::Cut => {
+                if cursor_range.is_empty() {
+                    copy_if_not_password(ui, text.take());
+                    Some(CCursorRange::default())
+                } else {
+                    copy_if_not_password(ui, selected_str(text, &cursor_range).to_owned());
+                    Some(CCursorRange::one(delete_selected(text, &cursor_range)))
+                }
+            }
+            Event::Paste(text_to_insert) => {
+                if !text_to_insert.is_empty() {
+                    let mut ccursor = delete_selected(text, &cursor_range);
+
+                    insert_text(&mut ccursor, text, text_to_insert, char_limit);
+
+                    Some(CCursorRange::one(ccursor))
+                } else {
+                    None
+                }
+            }
+            Event::Text(text_to_insert) => {
+                // Newlines are handled by `Key::Enter`.
+                if !text_to_insert.is_empty() && text_to_insert != "\n" && text_to_insert != "\r" {
+                    let mut ccursor = delete_selected(text, &cursor_range);
+
+                    insert_text(&mut ccursor, text, text_to_insert, char_limit);
+
+                    Some(CCursorRange::one(ccursor))
+                } else {
+                    None
+                }
+            }
+            Event::Key {
+                key: Key::Tab,
+                pressed: true,
+                modifiers,
+                ..
+            } => {
+                if multiline && ui.memory(|mem| mem.has_lock_focus(id)) {
+                    let mut ccursor = delete_selected(text, &cursor_range);
+                    if modifiers.shift {
+                        // TODO(emilk): support removing indentation over a selection?
+                        decrease_indentation(&mut ccursor, text);
+                    } else {
+                        insert_text(&mut ccursor, text, "\t", char_limit);
+                    }
+                    Some(CCursorRange::one(ccursor))
+                } else {
+                    None
+                }
+            }
+            Event::Key {
+                key: Key::Enter,
+                pressed: true,
+                ..
+            } => {
+                if multiline {
+                    let mut ccursor = delete_selected(text, &cursor_range);
+                    insert_text(&mut ccursor, text, "\n", char_limit);
+                    // TODO(emilk): if code editor, auto-indent by same leading tabs, + one if the lines end on an opening bracket
+                    Some(CCursorRange::one(ccursor))
+                } else {
+                    ui.memory_mut(|mem| mem.surrender_focus(id)); // End input with enter
+                    break;
+                }
+            }
+            Event::Key {
+                key: Key::Z,
+                pressed: true,
+                modifiers,
+                ..
+            } if modifiers.command && !modifiers.shift => {
+                // TODO(emilk): redo
+                if let Some((undo_ccursor_range, undo_txt)) = state
+                    .undoer
+                    .lock()
+                    .undo(&(cursor_range.as_ccursor_range(), text.as_str().to_owned()))
+                {
+                    text.replace(undo_txt);
+                    Some(*undo_ccursor_range)
+                } else {
+                    None
+                }
+            }
+
+            Event::Key {
+                key,
+                pressed: true,
+                modifiers,
+                ..
+            } => on_key_press(&mut cursor_range, text, galley, *key, modifiers),
+
+            Event::CompositionStart => {
+                state.has_ime = true;
+                None
+            }
+
+            Event::CompositionUpdate(text_mark) => {
+                // empty prediction can be produced when user press backspace
+                // or escape during ime. We should clear current text.
+                if text_mark != "\n" && text_mark != "\r" && state.has_ime {
+                    let mut ccursor = delete_selected(text, &cursor_range);
+                    let start_cursor = ccursor;
+                    if !text_mark.is_empty() {
+                        insert_text(&mut ccursor, text, text_mark, char_limit);
+                    }
+                    Some(CCursorRange::two(start_cursor, ccursor))
+                } else {
+                    None
+                }
+            }
+
+            Event::CompositionEnd(prediction) => {
+                if prediction != "\n" && prediction != "\r" && state.has_ime {
+                    state.has_ime = false;
+                    let mut ccursor = delete_selected(text, &cursor_range);
+                    if !prediction.is_empty() {
+                        insert_text(&mut ccursor, text, prediction, char_limit);
+                    }
+                    Some(CCursorRange::one(ccursor))
+                } else {
+                    None
+                }
+            }
+
+            #[cfg(feature = "accesskit")]
+            Event::AccessKitActionRequest(accesskit::ActionRequest {
+                action: accesskit::Action::SetTextSelection,
+                target,
+                data: Some(accesskit::ActionData::SetTextSelection(selection)),
+            }) => {
+                if id.accesskit_id() == *target {
+                    let primary =
+                        ccursor_from_accesskit_text_position(id, galley, &selection.focus);
+                    let secondary =
+                        ccursor_from_accesskit_text_position(id, galley, &selection.anchor);
+                    if let (Some(primary), Some(secondary)) = (primary, secondary) {
+                        Some(CCursorRange { primary, secondary })
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            }
+
+            _ => None,
+        };
+
+        if let Some(new_ccursor_range) = did_mutate_text {
+            any_change = true;
+
+            // Layout again to avoid frame delay, and to keep `text` and `galley` in sync.
+            *galley = layouter(ui, text.as_str(), wrap_width);
+
+            // Set cursor_range using new galley:
+            cursor_range = CursorRange {
+                primary: galley.from_ccursor(new_ccursor_range.primary),
+                secondary: galley.from_ccursor(new_ccursor_range.secondary),
+            };
+        }
+    }
+
+    state.set_cursor_range(Some(cursor_range));
+
+    state.undoer.lock().feed_state(
+        ui.input(|i| i.time),
+        &(cursor_range.as_ccursor_range(), text.as_str().to_owned()),
+    );
+
+    (any_change, cursor_range)
+}
+
+// ----------------------------------------------------------------------------
+
+fn paint_cursor_selection(
+    ui: &mut Ui,
+    painter: &Painter,
+    pos: Pos2,
+    galley: &Galley,
+    cursor_range: &CursorRange,
+) {
+    if cursor_range.is_empty() {
+        return;
+    }
+
+    // We paint the cursor selection on top of the text, so make it transparent:
+    let color = ui.visuals().selection.bg_fill.linear_multiply(0.5);
+    let [min, max] = cursor_range.sorted_cursors();
+    let min = min.rcursor;
+    let max = max.rcursor;
+
+    for ri in min.row..=max.row {
+        let row = &galley.rows[ri];
+        let left = if ri == min.row {
+            row.x_offset(min.column)
+        } else {
+            row.rect.left()
+        };
+        let right = if ri == max.row {
+            row.x_offset(max.column)
+        } else {
+            let newline_size = if row.ends_with_newline {
+                row.height() / 2.0 // visualize that we select the newline
+            } else {
+                0.0
+            };
+            row.rect.right() + newline_size
+        };
+        let rect = Rect::from_min_max(
+            pos + vec2(left, row.min_y()),
+            pos + vec2(right, row.max_y()),
+        );
+        painter.rect_filled(rect, 0.0, color);
+    }
+}
+
+fn paint_cursor_end(
+    ui: &mut Ui,
+    row_height: f32,
+    painter: &Painter,
+    pos: Pos2,
+    galley: &Galley,
+    cursor: &Cursor,
+) -> Rect {
+    let stroke = ui.visuals().selection.stroke;
+
+    let mut cursor_pos = galley.pos_from_cursor(cursor).translate(pos.to_vec2());
+    cursor_pos.max.y = cursor_pos.max.y.at_least(cursor_pos.min.y + row_height); // Handle completely empty galleys
+    cursor_pos = cursor_pos.expand(1.5); // slightly above/below row
+
+    let top = cursor_pos.center_top();
+    let bottom = cursor_pos.center_bottom();
+
+    painter.line_segment(
+        [top, bottom],
+        (ui.visuals().text_cursor_width, stroke.color),
+    );
+
+    if false {
+        // Roof/floor:
+        let extrusion = 3.0;
+        let width = 1.0;
+        painter.line_segment(
+            [top - vec2(extrusion, 0.0), top + vec2(extrusion, 0.0)],
+            (width, stroke.color),
+        );
+        painter.line_segment(
+            [bottom - vec2(extrusion, 0.0), bottom + vec2(extrusion, 0.0)],
+            (width, stroke.color),
+        );
+    }
+
+    cursor_pos
+}
+
+// ----------------------------------------------------------------------------
+
+fn selected_str<'s>(text: &'s dyn TextBuffer, cursor_range: &CursorRange) -> &'s str {
+    let [min, max] = cursor_range.sorted_cursors();
+    text.char_range(min.ccursor.index..max.ccursor.index)
+}
+
+fn insert_text(
+    ccursor: &mut CCursor,
+    text: &mut dyn TextBuffer,
+    text_to_insert: &str,
+    char_limit: usize,
+) {
+    if char_limit < usize::MAX {
+        let mut new_string = text_to_insert;
+        // Avoid subtract with overflow panic
+        let cutoff = char_limit.saturating_sub(text.as_str().len());
+
+        new_string = match new_string.char_indices().nth(cutoff) {
+            None => new_string,
+            Some((idx, _)) => &new_string[..idx],
+        };
+
+        ccursor.index += text.insert_text(new_string, ccursor.index);
+    } else {
+        ccursor.index += text.insert_text(text_to_insert, ccursor.index);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn delete_selected(text: &mut dyn TextBuffer, cursor_range: &CursorRange) -> CCursor {
+    let [min, max] = cursor_range.sorted_cursors();
+    delete_selected_ccursor_range(text, [min.ccursor, max.ccursor])
+}
+
+fn delete_selected_ccursor_range(text: &mut dyn TextBuffer, [min, max]: [CCursor; 2]) -> CCursor {
+    text.delete_char_range(min.index..max.index);
+    CCursor {
+        index: min.index,
+        prefer_next_row: true,
+    }
+}
+
+fn delete_previous_char(text: &mut dyn TextBuffer, ccursor: CCursor) -> CCursor {
+    if ccursor.index > 0 {
+        let max_ccursor = ccursor;
+        let min_ccursor = max_ccursor - 1;
+        delete_selected_ccursor_range(text, [min_ccursor, max_ccursor])
+    } else {
+        ccursor
+    }
+}
+
+fn delete_next_char(text: &mut dyn TextBuffer, ccursor: CCursor) -> CCursor {
+    delete_selected_ccursor_range(text, [ccursor, ccursor + 1])
+}
+
+fn delete_previous_word(text: &mut dyn TextBuffer, max_ccursor: CCursor) -> CCursor {
+    let min_ccursor = ccursor_previous_word(text.as_str(), max_ccursor);
+    delete_selected_ccursor_range(text, [min_ccursor, max_ccursor])
+}
+
+fn delete_next_word(text: &mut dyn TextBuffer, min_ccursor: CCursor) -> CCursor {
+    let max_ccursor = ccursor_next_word(text.as_str(), min_ccursor);
+    delete_selected_ccursor_range(text, [min_ccursor, max_ccursor])
+}
+
+fn delete_paragraph_before_cursor(
+    text: &mut dyn TextBuffer,
+    galley: &Galley,
+    cursor_range: &CursorRange,
+) -> CCursor {
+    let [min, max] = cursor_range.sorted_cursors();
+    let min = galley.from_pcursor(PCursor {
+        paragraph: min.pcursor.paragraph,
+        offset: 0,
+        prefer_next_row: true,
+    });
+    if min.ccursor == max.ccursor {
+        delete_previous_char(text, min.ccursor)
+    } else {
+        delete_selected(text, &CursorRange::two(min, max))
+    }
+}
+
+fn delete_paragraph_after_cursor(
+    text: &mut dyn TextBuffer,
+    galley: &Galley,
+    cursor_range: &CursorRange,
+) -> CCursor {
+    let [min, max] = cursor_range.sorted_cursors();
+    let max = galley.from_pcursor(PCursor {
+        paragraph: max.pcursor.paragraph,
+        offset: usize::MAX, // end of paragraph
+        prefer_next_row: false,
+    });
+    if min.ccursor == max.ccursor {
+        delete_next_char(text, min.ccursor)
+    } else {
+        delete_selected(text, &CursorRange::two(min, max))
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Returns `Some(new_cursor)` if we did mutate `text`.
+fn on_key_press(
+    cursor_range: &mut CursorRange,
+    text: &mut dyn TextBuffer,
+    galley: &Galley,
+    key: Key,
+    modifiers: &Modifiers,
+) -> Option<CCursorRange> {
+    match key {
+        Key::Backspace => {
+            let ccursor = if modifiers.mac_cmd {
+                delete_paragraph_before_cursor(text, galley, cursor_range)
+            } else if let Some(cursor) = cursor_range.single() {
+                if modifiers.alt || modifiers.ctrl {
+                    // alt on mac, ctrl on windows
+                    delete_previous_word(text, cursor.ccursor)
+                } else {
+                    delete_previous_char(text, cursor.ccursor)
+                }
+            } else {
+                delete_selected(text, cursor_range)
+            };
+            Some(CCursorRange::one(ccursor))
+        }
+        Key::Delete if !modifiers.shift || !cfg!(target_os = "windows") => {
+            let ccursor = if modifiers.mac_cmd {
+                delete_paragraph_after_cursor(text, galley, cursor_range)
+            } else if let Some(cursor) = cursor_range.single() {
+                if modifiers.alt || modifiers.ctrl {
+                    // alt on mac, ctrl on windows
+                    delete_next_word(text, cursor.ccursor)
+                } else {
+                    delete_next_char(text, cursor.ccursor)
+                }
+            } else {
+                delete_selected(text, cursor_range)
+            };
+            let ccursor = CCursor {
+                prefer_next_row: true,
+                ..ccursor
+            };
+            Some(CCursorRange::one(ccursor))
+        }
+
+        Key::A if modifiers.command => {
+            // select all
+            *cursor_range = CursorRange::two(Cursor::default(), galley.end());
+            None
+        }
+
+        Key::H if modifiers.ctrl => {
+            let ccursor = delete_previous_char(text, cursor_range.primary.ccursor);
+            Some(CCursorRange::one(ccursor))
+        }
+
+        Key::K if modifiers.ctrl => {
+            let ccursor = delete_paragraph_after_cursor(text, galley, cursor_range);
+            Some(CCursorRange::one(ccursor))
+        }
+
+        Key::U if modifiers.ctrl => {
+            let ccursor = delete_paragraph_before_cursor(text, galley, cursor_range);
+            Some(CCursorRange::one(ccursor))
+        }
+
+        Key::W if modifiers.ctrl => {
+            let ccursor = if let Some(cursor) = cursor_range.single() {
+                delete_previous_word(text, cursor.ccursor)
+            } else {
+                delete_selected(text, cursor_range)
+            };
+            Some(CCursorRange::one(ccursor))
+        }
+
+        Key::ArrowLeft | Key::ArrowRight if modifiers.is_none() && !cursor_range.is_empty() => {
+            if key == Key::ArrowLeft {
+                *cursor_range = CursorRange::one(cursor_range.sorted_cursors()[0]);
+            } else {
+                *cursor_range = CursorRange::one(cursor_range.sorted_cursors()[1]);
+            }
+            None
+        }
+
+        Key::ArrowLeft | Key::ArrowRight | Key::ArrowUp | Key::ArrowDown | Key::Home | Key::End => {
+            move_single_cursor(&mut cursor_range.primary, galley, key, modifiers);
+            if !modifiers.shift {
+                cursor_range.secondary = cursor_range.primary;
+            }
+            None
+        }
+
+        Key::P | Key::N | Key::B | Key::F | Key::A | Key::E
+            if cfg!(target_os = "macos") && modifiers.ctrl && !modifiers.shift =>
+        {
+            move_single_cursor(&mut cursor_range.primary, galley, key, modifiers);
+            cursor_range.secondary = cursor_range.primary;
+            None
+        }
+
+        _ => None,
+    }
+}
+
+fn move_single_cursor(cursor: &mut Cursor, galley: &Galley, key: Key, modifiers: &Modifiers) {
+    if cfg!(target_os = "macos") && modifiers.ctrl && !modifiers.shift {
+        match key {
+            Key::A => *cursor = galley.cursor_begin_of_row(cursor),
+            Key::E => *cursor = galley.cursor_end_of_row(cursor),
+            Key::P => *cursor = galley.cursor_up_one_row(cursor),
+            Key::N => *cursor = galley.cursor_down_one_row(cursor),
+            Key::B => *cursor = galley.cursor_left_one_character(cursor),
+            Key::F => *cursor = galley.cursor_right_one_character(cursor),
+            _ => (),
+        }
+        return;
+    }
+    match key {
+        Key::ArrowLeft => {
+            if modifiers.alt || modifiers.ctrl {
+                // alt on mac, ctrl on windows
+                *cursor = galley.from_ccursor(ccursor_previous_word(galley.text(), cursor.ccursor));
+            } else if modifiers.mac_cmd {
+                *cursor = galley.cursor_begin_of_row(cursor);
+            } else {
+                *cursor = galley.cursor_left_one_character(cursor);
+            }
+        }
+        Key::ArrowRight => {
+            if modifiers.alt || modifiers.ctrl {
+                // alt on mac, ctrl on windows
+                *cursor = galley.from_ccursor(ccursor_next_word(galley.text(), cursor.ccursor));
+            } else if modifiers.mac_cmd {
+                *cursor = galley.cursor_end_of_row(cursor);
+            } else {
+                *cursor = galley.cursor_right_one_character(cursor);
+            }
+        }
+        Key::ArrowUp => {
+            if modifiers.command {
+                // mac and windows behavior
+                *cursor = Cursor::default();
+            } else {
+                *cursor = galley.cursor_up_one_row(cursor);
+            }
+        }
+        Key::ArrowDown => {
+            if modifiers.command {
+                // mac and windows behavior
+                *cursor = galley.end();
+            } else {
+                *cursor = galley.cursor_down_one_row(cursor);
+            }
+        }
+
+        Key::Home => {
+            if modifiers.ctrl {
+                // windows behavior
+                *cursor = Cursor::default();
+            } else {
+                *cursor = galley.cursor_begin_of_row(cursor);
+            }
+        }
+        Key::End => {
+            if modifiers.ctrl {
+                // windows behavior
+                *cursor = galley.end();
+            } else {
+                *cursor = galley.cursor_end_of_row(cursor);
+            }
+        }
+
+        _ => unreachable!(),
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn select_word_at(text: &str, ccursor: CCursor) -> CCursorRange {
+    if ccursor.index == 0 {
+        CCursorRange::two(ccursor, ccursor_next_word(text, ccursor))
+    } else {
+        let it = text.chars();
+        let mut it = it.skip(ccursor.index - 1);
+        if let Some(char_before_cursor) = it.next() {
+            if let Some(char_after_cursor) = it.next() {
+                if is_word_char(char_before_cursor) && is_word_char(char_after_cursor) {
+                    let min = ccursor_previous_word(text, ccursor + 1);
+                    let max = ccursor_next_word(text, min);
+                    CCursorRange::two(min, max)
+                } else if is_word_char(char_before_cursor) {
+                    let min = ccursor_previous_word(text, ccursor);
+                    let max = ccursor_next_word(text, min);
+                    CCursorRange::two(min, max)
+                } else if is_word_char(char_after_cursor) {
+                    let max = ccursor_next_word(text, ccursor);
+                    CCursorRange::two(ccursor, max)
+                } else {
+                    let min = ccursor_previous_word(text, ccursor);
+                    let max = ccursor_next_word(text, ccursor);
+                    CCursorRange::two(min, max)
+                }
+            } else {
+                let min = ccursor_previous_word(text, ccursor);
+                CCursorRange::two(min, ccursor)
+            }
+        } else {
+            let max = ccursor_next_word(text, ccursor);
+            CCursorRange::two(ccursor, max)
+        }
+    }
+}
+
+fn select_line_at(text: &str, ccursor: CCursor) -> CCursorRange {
+    if ccursor.index == 0 {
+        CCursorRange::two(ccursor, ccursor_next_line(text, ccursor))
+    } else {
+        let it = text.chars();
+        let mut it = it.skip(ccursor.index - 1);
+        if let Some(char_before_cursor) = it.next() {
+            if let Some(char_after_cursor) = it.next() {
+                if (!is_linebreak(char_before_cursor)) && (!is_linebreak(char_after_cursor)) {
+                    let min = ccursor_previous_line(text, ccursor + 1);
+                    let max = ccursor_next_line(text, min);
+                    CCursorRange::two(min, max)
+                } else if !is_linebreak(char_before_cursor) {
+                    let min = ccursor_previous_line(text, ccursor);
+                    let max = ccursor_next_line(text, min);
+                    CCursorRange::two(min, max)
+                } else if !is_linebreak(char_after_cursor) {
+                    let max = ccursor_next_line(text, ccursor);
+                    CCursorRange::two(ccursor, max)
+                } else {
+                    let min = ccursor_previous_line(text, ccursor);
+                    let max = ccursor_next_line(text, ccursor);
+                    CCursorRange::two(min, max)
+                }
+            } else {
+                let min = ccursor_previous_line(text, ccursor);
+                CCursorRange::two(min, ccursor)
+            }
+        } else {
+            let max = ccursor_next_line(text, ccursor);
+            CCursorRange::two(ccursor, max)
+        }
+    }
+}
+
+fn ccursor_next_word(text: &str, ccursor: CCursor) -> CCursor {
+    CCursor {
+        index: next_word_boundary_char_index(text.chars(), ccursor.index),
+        prefer_next_row: false,
+    }
+}
+
+fn ccursor_next_line(text: &str, ccursor: CCursor) -> CCursor {
+    CCursor {
+        index: next_line_boundary_char_index(text.chars(), ccursor.index),
+        prefer_next_row: false,
+    }
+}
+
+fn ccursor_previous_word(text: &str, ccursor: CCursor) -> CCursor {
+    let num_chars = text.chars().count();
+    CCursor {
+        index: num_chars
+            - next_word_boundary_char_index(text.chars().rev(), num_chars - ccursor.index),
+        prefer_next_row: true,
+    }
+}
+
+fn ccursor_previous_line(text: &str, ccursor: CCursor) -> CCursor {
+    let num_chars = text.chars().count();
+    CCursor {
+        index: num_chars
+            - next_line_boundary_char_index(text.chars().rev(), num_chars - ccursor.index),
+        prefer_next_row: true,
+    }
+}
+
+fn next_word_boundary_char_index(it: impl Iterator<Item = char>, mut index: usize) -> usize {
+    let mut it = it.skip(index);
+    if let Some(_first) = it.next() {
+        index += 1;
+
+        if let Some(second) = it.next() {
+            index += 1;
+            for next in it {
+                if is_word_char(next) != is_word_char(second) {
+                    break;
+                }
+                index += 1;
+            }
+        }
+    }
+    index
+}
+
+fn next_line_boundary_char_index(it: impl Iterator<Item = char>, mut index: usize) -> usize {
+    let mut it = it.skip(index);
+    if let Some(_first) = it.next() {
+        index += 1;
+
+        if let Some(second) = it.next() {
+            index += 1;
+            for next in it {
+                if is_linebreak(next) != is_linebreak(second) {
+                    break;
+                }
+                index += 1;
+            }
+        }
+    }
+    index
+}
+
+fn is_word_char(c: char) -> bool {
+    c.is_ascii_alphanumeric() || c == '_'
+}
+
+fn is_linebreak(c: char) -> bool {
+    c == '\r' || c == '\n'
+}
+
+/// Accepts and returns character offset (NOT byte offset!).
+fn find_line_start(text: &str, current_index: CCursor) -> CCursor {
+    // We know that new lines, '\n', are a single byte char, but we have to
+    // work with char offsets because before the new line there may be any
+    // number of multi byte chars.
+    // We need to know the char index to be able to correctly set the cursor
+    // later.
+    let chars_count = text.chars().count();
+
+    let position = text
+        .chars()
+        .rev()
+        .skip(chars_count - current_index.index)
+        .position(|x| x == '\n');
+
+    match position {
+        Some(pos) => CCursor::new(current_index.index - pos),
+        None => CCursor::new(0),
+    }
+}
+
+fn decrease_indentation(ccursor: &mut CCursor, text: &mut dyn TextBuffer) {
+    let line_start = find_line_start(text.as_str(), *ccursor);
+
+    let remove_len = if text.as_str()[line_start.index..].starts_with('\t') {
+        Some(1)
+    } else if text.as_str()[line_start.index..]
+        .chars()
+        .take(text::TAB_SIZE)
+        .all(|c| c == ' ')
+    {
+        Some(text::TAB_SIZE)
+    } else {
+        None
+    };
+
+    if let Some(len) = remove_len {
+        text.delete_char_range(line_start.index..(line_start.index + len));
+        if *ccursor != line_start {
+            *ccursor -= len;
+        }
+    }
+}
diff --git a/egui/crates/egui/src/widgets/text_edit/cursor_range.rs b/egui/crates/egui/src/widgets/text_edit/cursor_range.rs
new file mode 100644
index 0000000..10668a5
--- /dev/null
+++ b/egui/crates/egui/src/widgets/text_edit/cursor_range.rs
@@ -0,0 +1,150 @@
+use epaint::text::cursor::*;
+
+/// A selected text range (could be a range of length zero).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct CursorRange {
+    /// When selecting with a mouse, this is where the mouse was released.
+    /// When moving with e.g. shift+arrows, this is what moves.
+    /// Note that the two ends can come in any order, and also be equal (no selection).
+    pub primary: Cursor,
+
+    /// When selecting with a mouse, this is where the mouse was first pressed.
+    /// This part of the cursor does not move when shift is down.
+    pub secondary: Cursor,
+}
+
+impl CursorRange {
+    /// The empty range.
+    pub fn one(cursor: Cursor) -> Self {
+        Self {
+            primary: cursor,
+            secondary: cursor,
+        }
+    }
+
+    pub fn two(min: Cursor, max: Cursor) -> Self {
+        Self {
+            primary: max,
+            secondary: min,
+        }
+    }
+
+    pub fn as_ccursor_range(&self) -> CCursorRange {
+        CCursorRange {
+            primary: self.primary.ccursor,
+            secondary: self.secondary.ccursor,
+        }
+    }
+
+    /// The range of selected character indices.
+    pub fn as_sorted_char_range(&self) -> std::ops::Range<usize> {
+        let [start, end] = self.sorted_cursors();
+        std::ops::Range {
+            start: start.ccursor.index,
+            end: end.ccursor.index,
+        }
+    }
+
+    /// True if the selected range contains no characters.
+    pub fn is_empty(&self) -> bool {
+        self.primary.ccursor == self.secondary.ccursor
+    }
+
+    /// If there is a selection, None is returned.
+    /// If the two ends is the same, that is returned.
+    pub fn single(&self) -> Option<Cursor> {
+        if self.is_empty() {
+            Some(self.primary)
+        } else {
+            None
+        }
+    }
+
+    pub fn is_sorted(&self) -> bool {
+        let p = self.primary.ccursor;
+        let s = self.secondary.ccursor;
+        (p.index, p.prefer_next_row) <= (s.index, s.prefer_next_row)
+    }
+
+    pub fn sorted(self) -> Self {
+        if self.is_sorted() {
+            self
+        } else {
+            Self {
+                primary: self.secondary,
+                secondary: self.primary,
+            }
+        }
+    }
+
+    /// returns the two ends ordered
+    pub fn sorted_cursors(&self) -> [Cursor; 2] {
+        if self.is_sorted() {
+            [self.primary, self.secondary]
+        } else {
+            [self.secondary, self.primary]
+        }
+    }
+}
+
+/// A selected text range (could be a range of length zero).
+///
+/// The selection is based on character count (NOT byte count!).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct CCursorRange {
+    /// When selecting with a mouse, this is where the mouse was released.
+    /// When moving with e.g. shift+arrows, this is what moves.
+    /// Note that the two ends can come in any order, and also be equal (no selection).
+    pub primary: CCursor,
+
+    /// When selecting with a mouse, this is where the mouse was first pressed.
+    /// This part of the cursor does not move when shift is down.
+    pub secondary: CCursor,
+}
+
+impl CCursorRange {
+    /// The empty range.
+    pub fn one(ccursor: CCursor) -> Self {
+        Self {
+            primary: ccursor,
+            secondary: ccursor,
+        }
+    }
+
+    pub fn two(min: CCursor, max: CCursor) -> Self {
+        Self {
+            primary: max,
+            secondary: min,
+        }
+    }
+
+    pub fn is_sorted(&self) -> bool {
+        let p = self.primary;
+        let s = self.secondary;
+        (p.index, p.prefer_next_row) <= (s.index, s.prefer_next_row)
+    }
+
+    /// returns the two ends ordered
+    pub fn sorted(&self) -> [CCursor; 2] {
+        if self.is_sorted() {
+            [self.primary, self.secondary]
+        } else {
+            [self.secondary, self.primary]
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PCursorRange {
+    /// When selecting with a mouse, this is where the mouse was released.
+    /// When moving with e.g. shift+arrows, this is what moves.
+    /// Note that the two ends can come in any order, and also be equal (no selection).
+    pub primary: PCursor,
+
+    /// When selecting with a mouse, this is where the mouse was first pressed.
+    /// This part of the cursor does not move when shift is down.
+    pub secondary: PCursor,
+}
diff --git a/egui/crates/egui/src/widgets/text_edit/mod.rs b/egui/crates/egui/src/widgets/text_edit/mod.rs
new file mode 100644
index 0000000..3db990a
--- /dev/null
+++ b/egui/crates/egui/src/widgets/text_edit/mod.rs
@@ -0,0 +1,10 @@
+mod builder;
+mod cursor_range;
+mod output;
+mod state;
+mod text_buffer;
+
+pub use {
+    builder::TextEdit, cursor_range::*, output::TextEditOutput, state::TextEditState,
+    text_buffer::TextBuffer,
+};
diff --git a/egui/crates/egui/src/widgets/text_edit/output.rs b/egui/crates/egui/src/widgets/text_edit/output.rs
new file mode 100644
index 0000000..0ff45d0
--- /dev/null
+++ b/egui/crates/egui/src/widgets/text_edit/output.rs
@@ -0,0 +1,24 @@
+use std::sync::Arc;
+
+/// The output from a [`TextEdit`](crate::TextEdit).
+pub struct TextEditOutput {
+    /// The interaction response.
+    pub response: crate::Response,
+
+    /// How the text was displayed.
+    pub galley: Arc<crate::Galley>,
+
+    /// Where the text in [`Self::galley`] ended up on the screen.
+    pub text_draw_pos: crate::Pos2,
+
+    /// The text was clipped to this rectangle when painted.
+    pub text_clip_rect: crate::Rect,
+
+    /// The state we stored after the run.
+    pub state: super::TextEditState,
+
+    /// Where the text cursor is.
+    pub cursor_range: Option<super::CursorRange>,
+}
+
+// TODO(emilk): add `output.paint` and `output.store` and split out that code from `TextEdit::show`.
diff --git a/egui/crates/egui/src/widgets/text_edit/state.rs b/egui/crates/egui/src/widgets/text_edit/state.rs
new file mode 100644
index 0000000..8a63809
--- /dev/null
+++ b/egui/crates/egui/src/widgets/text_edit/state.rs
@@ -0,0 +1,85 @@
+use std::sync::Arc;
+
+use crate::mutex::Mutex;
+
+use crate::*;
+
+use super::{CCursorRange, CursorRange};
+
+type Undoer = crate::util::undoer::Undoer<(CCursorRange, String)>;
+
+/// The text edit state stored between frames.
+#[derive(Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct TextEditState {
+    cursor_range: Option<CursorRange>,
+
+    /// This is what is easiest to work with when editing text,
+    /// so users are more likely to read/write this.
+    ccursor_range: Option<CCursorRange>,
+
+    /// Wrapped in Arc for cheaper clones.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pub(crate) undoer: Arc<Mutex<Undoer>>,
+
+    // If IME candidate window is shown on this text edit.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pub(crate) has_ime: bool,
+
+    // Visual offset when editing singleline text bigger than the width.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pub(crate) singleline_offset: f32,
+}
+
+impl TextEditState {
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        ctx.data_mut(|d| d.get_persisted(id))
+    }
+
+    pub fn store(self, ctx: &Context, id: Id) {
+        ctx.data_mut(|d| d.insert_persisted(id, self));
+    }
+
+    /// The the currently selected range of characters.
+    pub fn ccursor_range(&self) -> Option<CCursorRange> {
+        self.ccursor_range.or_else(|| {
+            self.cursor_range
+                .map(|cursor_range| cursor_range.as_ccursor_range())
+        })
+    }
+
+    /// Sets the currently selected range of characters.
+    pub fn set_ccursor_range(&mut self, ccursor_range: Option<CCursorRange>) {
+        self.cursor_range = None;
+        self.ccursor_range = ccursor_range;
+    }
+
+    pub fn set_cursor_range(&mut self, cursor_range: Option<CursorRange>) {
+        self.cursor_range = cursor_range;
+        self.ccursor_range = None;
+    }
+
+    pub fn cursor_range(&mut self, galley: &Galley) -> Option<CursorRange> {
+        self.cursor_range
+            .map(|cursor_range| {
+                // We only use the PCursor (paragraph number, and character offset within that paragraph).
+                // This is so that if we resize the [`TextEdit`] region, and text wrapping changes,
+                // we keep the same byte character offset from the beginning of the text,
+                // even though the number of rows changes
+                // (each paragraph can be several rows, due to word wrapping).
+                // The column (character offset) should be able to extend beyond the last word so that we can
+                // go down and still end up on the same column when we return.
+                CursorRange {
+                    primary: galley.from_pcursor(cursor_range.primary.pcursor),
+                    secondary: galley.from_pcursor(cursor_range.secondary.pcursor),
+                }
+            })
+            .or_else(|| {
+                self.ccursor_range.map(|ccursor_range| CursorRange {
+                    primary: galley.from_ccursor(ccursor_range.primary),
+                    secondary: galley.from_ccursor(ccursor_range.secondary),
+                })
+            })
+    }
+}
diff --git a/egui/crates/egui/src/widgets/text_edit/text_buffer.rs b/egui/crates/egui/src/widgets/text_edit/text_buffer.rs
new file mode 100644
index 0000000..e29a07a
--- /dev/null
+++ b/egui/crates/egui/src/widgets/text_edit/text_buffer.rs
@@ -0,0 +1,127 @@
+use std::ops::Range;
+
+/// Trait constraining what types [`crate::TextEdit`] may use as
+/// an underlying buffer.
+///
+/// Most likely you will use a [`String`] which implements [`TextBuffer`].
+pub trait TextBuffer {
+    /// Can this text be edited?
+    fn is_mutable(&self) -> bool;
+
+    /// Returns this buffer as a `str`.
+    fn as_str(&self) -> &str;
+
+    /// Reads the given character range.
+    fn char_range(&self, char_range: Range<usize>) -> &str {
+        assert!(char_range.start <= char_range.end);
+        let start_byte = self.byte_index_from_char_index(char_range.start);
+        let end_byte = self.byte_index_from_char_index(char_range.end);
+        &self.as_str()[start_byte..end_byte]
+    }
+
+    fn byte_index_from_char_index(&self, char_index: usize) -> usize {
+        byte_index_from_char_index(self.as_str(), char_index)
+    }
+
+    /// Inserts text `text` into this buffer at character index `char_index`.
+    ///
+    /// # Notes
+    /// `char_index` is a *character index*, not a byte index.
+    ///
+    /// # Return
+    /// Returns how many *characters* were successfully inserted
+    fn insert_text(&mut self, text: &str, char_index: usize) -> usize;
+
+    /// Deletes a range of text `char_range` from this buffer.
+    ///
+    /// # Notes
+    /// `char_range` is a *character range*, not a byte range.
+    fn delete_char_range(&mut self, char_range: Range<usize>);
+
+    /// Clears all characters in this buffer
+    fn clear(&mut self) {
+        self.delete_char_range(0..self.as_str().len());
+    }
+
+    /// Replaces all contents of this string with `text`
+    fn replace(&mut self, text: &str) {
+        self.clear();
+        self.insert_text(text, 0);
+    }
+
+    /// Clears all characters in this buffer and returns a string of the contents.
+    fn take(&mut self) -> String {
+        let s = self.as_str().to_owned();
+        self.clear();
+        s
+    }
+}
+
+impl TextBuffer for String {
+    fn is_mutable(&self) -> bool {
+        true
+    }
+
+    fn as_str(&self) -> &str {
+        self.as_ref()
+    }
+
+    fn insert_text(&mut self, text: &str, char_index: usize) -> usize {
+        // Get the byte index from the character index
+        let byte_idx = self.byte_index_from_char_index(char_index);
+
+        // Then insert the string
+        self.insert_str(byte_idx, text);
+
+        text.chars().count()
+    }
+
+    fn delete_char_range(&mut self, char_range: Range<usize>) {
+        assert!(char_range.start <= char_range.end);
+
+        // Get both byte indices
+        let byte_start = self.byte_index_from_char_index(char_range.start);
+        let byte_end = self.byte_index_from_char_index(char_range.end);
+
+        // Then drain all characters within this range
+        self.drain(byte_start..byte_end);
+    }
+
+    fn clear(&mut self) {
+        self.clear();
+    }
+
+    fn replace(&mut self, text: &str) {
+        *self = text.to_owned();
+    }
+
+    fn take(&mut self) -> String {
+        std::mem::take(self)
+    }
+}
+
+/// Immutable view of a `&str`!
+impl<'a> TextBuffer for &'a str {
+    fn is_mutable(&self) -> bool {
+        false
+    }
+
+    fn as_str(&self) -> &str {
+        self
+    }
+
+    fn insert_text(&mut self, _text: &str, _ch_idx: usize) -> usize {
+        0
+    }
+
+    fn delete_char_range(&mut self, _ch_range: Range<usize>) {}
+}
+
+fn byte_index_from_char_index(s: &str, char_index: usize) -> usize {
+    for (ci, (bi, _)) in s.char_indices().enumerate() {
+        if ci == char_index {
+            return bi;
+        }
+    }
+    s.len()
+}
diff --git a/egui/crates/egui_demo_app/Cargo.toml b/egui/crates/egui_demo_app/Cargo.toml
new file mode 100644
index 0000000..4239717
--- /dev/null
+++ b/egui/crates/egui_demo_app/Cargo.toml
@@ -0,0 +1,67 @@
+[package]
+name = "egui_demo_app"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+default-run = "egui_demo_app"
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+
+[features]
+default = ["glow", "persistence"]
+
+http = ["ehttp", "image", "poll-promise", "egui_extras/image"]
+persistence = ["eframe/persistence", "egui/persistence", "serde"]
+web_screen_reader = ["eframe/web_screen_reader"]                  # experimental
+serde = ["dep:serde", "egui_demo_lib/serde", "egui/serde"]
+syntax_highlighting = ["egui_demo_lib/syntax_highlighting"]
+
+glow = ["eframe/glow"]
+wgpu = ["eframe/wgpu", "bytemuck"]
+
+
+[dependencies]
+chrono = { version = "0.4", features = ["js-sys", "wasmbind"] }
+eframe = { version = "0.21.0", path = "../eframe", default-features = false }
+egui = { version = "0.21.0", path = "../egui", features = [
+  "extra_debug_asserts",
+] }
+egui_demo_lib = { version = "0.21.0", path = "../egui_demo_lib", features = [
+  "chrono",
+] }
+tracing = "0.1"
+
+# Optional dependencies:
+
+bytemuck = { version = "1.7.1", optional = true }
+egui_extras = { version = "0.21.0", optional = true, path = "../egui_extras" }
+
+# feature "http":
+ehttp = { version = "0.2.0", optional = true }
+image = { version = "0.24", optional = true, default-features = false, features = [
+  "jpeg",
+  "png",
+] }
+poll-promise = { version = "0.2", optional = true, default-features = false }
+
+# feature "persistence":
+serde = { version = "1", optional = true, features = ["derive"] }
+
+
+# native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tracing-subscriber = "0.3"
+
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+console_error_panic_hook = "0.1.6"
+tracing-wasm = "0.2"
+wasm-bindgen-futures = "0.4"
diff --git a/egui/crates/egui_demo_app/README.md b/egui/crates/egui_demo_app/README.md
new file mode 100644
index 0000000..8182b48
--- /dev/null
+++ b/egui/crates/egui_demo_app/README.md
@@ -0,0 +1,19 @@
+# egui demo app
+This app demonstrates [`egui`](https://github.com/emilk/egui/) and [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+
+View the demo app online at <https://egui.rs>.
+
+Run it locally with `cargo run --release -p egui_demo_app`.
+
+`egui_demo_app` can be compiled to WASM and viewed in a browser locally with:
+
+```sh
+./scripts/start_server.sh &
+./scripts/build_demo_web.sh --open
+```
+
+`egui_demo_app` uses [`egui_demo_lib`](https://github.com/emilk/egui/tree/master/crates/egui_demo_lib).
+
+
+## Running with `wgpu` backend
+`(cd egui_demo_app && cargo r --features wgpu)`
diff --git a/egui/crates/egui_demo_app/src/apps/custom3d_glow.rs b/egui/crates/egui_demo_app/src/apps/custom3d_glow.rs
new file mode 100644
index 0000000..84d61d3
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/apps/custom3d_glow.rs
@@ -0,0 +1,201 @@
+use std::sync::Arc;
+
+use eframe::egui_glow;
+use egui::mutex::Mutex;
+use egui_glow::glow;
+
+pub struct Custom3d {
+    /// Behind an `Arc<Mutex<…>>` so we can pass it to [`egui::PaintCallback`] and paint later.
+    rotating_triangle: Arc<Mutex<RotatingTriangle>>,
+    angle: f32,
+}
+
+impl Custom3d {
+    pub fn new<'a>(cc: &'a eframe::CreationContext<'a>) -> Option<Self> {
+        let gl = cc.gl.as_ref()?;
+        Some(Self {
+            rotating_triangle: Arc::new(Mutex::new(RotatingTriangle::new(gl)?)),
+            angle: 0.0,
+        })
+    }
+}
+
+impl eframe::App for Custom3d {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            egui::ScrollArea::both()
+                .auto_shrink([false; 2])
+                .show(ui, |ui| {
+                    ui.horizontal(|ui| {
+                        ui.spacing_mut().item_spacing.x = 0.0;
+                        ui.label("The triangle is being painted using ");
+                        ui.hyperlink_to("glow", "https://github.com/grovesNL/glow");
+                        ui.label(" (OpenGL).");
+                    });
+                    ui.label("It's not a very impressive demo, but it shows you can embed 3D inside of egui.");
+
+                    egui::Frame::canvas(ui.style()).show(ui, |ui| {
+                        self.custom_painting(ui);
+                    });
+                    ui.label("Drag to rotate!");
+                    ui.add(egui_demo_lib::egui_github_link_file!());
+                });
+        });
+    }
+
+    fn on_exit(&mut self, gl: Option<&glow::Context>) {
+        if let Some(gl) = gl {
+            self.rotating_triangle.lock().destroy(gl);
+        }
+    }
+}
+
+impl Custom3d {
+    fn custom_painting(&mut self, ui: &mut egui::Ui) {
+        let (rect, response) =
+            ui.allocate_exact_size(egui::Vec2::splat(300.0), egui::Sense::drag());
+
+        self.angle += response.drag_delta().x * 0.01;
+
+        // Clone locals so we can move them into the paint callback:
+        let angle = self.angle;
+        let rotating_triangle = self.rotating_triangle.clone();
+
+        let cb = egui_glow::CallbackFn::new(move |_info, painter| {
+            rotating_triangle.lock().paint(painter.gl(), angle);
+        });
+
+        let callback = egui::PaintCallback {
+            rect,
+            callback: Arc::new(cb),
+        };
+        ui.painter().add(callback);
+    }
+}
+
+struct RotatingTriangle {
+    program: glow::Program,
+    vertex_array: glow::VertexArray,
+}
+
+#[allow(unsafe_code)] // we need unsafe code to use glow
+impl RotatingTriangle {
+    fn new(gl: &glow::Context) -> Option<Self> {
+        use glow::HasContext as _;
+
+        let shader_version = egui_glow::ShaderVersion::get(gl);
+
+        unsafe {
+            let program = gl.create_program().expect("Cannot create program");
+
+            if !shader_version.is_new_shader_interface() {
+                tracing::warn!(
+                    "Custom 3D painting hasn't been ported to {:?}",
+                    shader_version
+                );
+                return None;
+            }
+
+            let (vertex_shader_source, fragment_shader_source) = (
+                r#"
+                    const vec2 verts[3] = vec2[3](
+                        vec2(0.0, 1.0),
+                        vec2(-1.0, -1.0),
+                        vec2(1.0, -1.0)
+                    );
+                    const vec4 colors[3] = vec4[3](
+                        vec4(1.0, 0.0, 0.0, 1.0),
+                        vec4(0.0, 1.0, 0.0, 1.0),
+                        vec4(0.0, 0.0, 1.0, 1.0)
+                    );
+                    out vec4 v_color;
+                    uniform float u_angle;
+                    void main() {
+                        v_color = colors[gl_VertexID];
+                        gl_Position = vec4(verts[gl_VertexID], 0.0, 1.0);
+                        gl_Position.x *= cos(u_angle);
+                    }
+                "#,
+                r#"
+                    precision mediump float;
+                    in vec4 v_color;
+                    out vec4 out_color;
+                    void main() {
+                        out_color = v_color;
+                    }
+                "#,
+            );
+
+            let shader_sources = [
+                (glow::VERTEX_SHADER, vertex_shader_source),
+                (glow::FRAGMENT_SHADER, fragment_shader_source),
+            ];
+
+            let shaders: Vec<_> = shader_sources
+                .iter()
+                .map(|(shader_type, shader_source)| {
+                    let shader = gl
+                        .create_shader(*shader_type)
+                        .expect("Cannot create shader");
+                    gl.shader_source(
+                        shader,
+                        &format!(
+                            "{}\n{}",
+                            shader_version.version_declaration(),
+                            shader_source
+                        ),
+                    );
+                    gl.compile_shader(shader);
+                    assert!(
+                        gl.get_shader_compile_status(shader),
+                        "Failed to compile custom_3d_glow {shader_type}: {}",
+                        gl.get_shader_info_log(shader)
+                    );
+
+                    gl.attach_shader(program, shader);
+                    shader
+                })
+                .collect();
+
+            gl.link_program(program);
+            if !gl.get_program_link_status(program) {
+                panic!("{}", gl.get_program_info_log(program));
+            }
+
+            for shader in shaders {
+                gl.detach_shader(program, shader);
+                gl.delete_shader(shader);
+            }
+
+            let vertex_array = gl
+                .create_vertex_array()
+                .expect("Cannot create vertex array");
+
+            Some(Self {
+                program,
+                vertex_array,
+            })
+        }
+    }
+
+    fn destroy(&self, gl: &glow::Context) {
+        use glow::HasContext as _;
+        unsafe {
+            gl.delete_program(self.program);
+            gl.delete_vertex_array(self.vertex_array);
+        }
+    }
+
+    fn paint(&self, gl: &glow::Context, angle: f32) {
+        use glow::HasContext as _;
+        unsafe {
+            gl.use_program(Some(self.program));
+            gl.uniform_1_f32(
+                gl.get_uniform_location(self.program, "u_angle").as_ref(),
+                angle,
+            );
+            gl.bind_vertex_array(Some(self.vertex_array));
+            gl.draw_arrays(glow::TRIANGLES, 0, 3);
+        }
+    }
+}
diff --git a/egui/crates/egui_demo_app/src/apps/custom3d_wgpu.rs b/egui/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
new file mode 100644
index 0000000..1a519f6
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
@@ -0,0 +1,187 @@
+use std::{num::NonZeroU64, sync::Arc};
+
+use eframe::{
+    egui_wgpu::wgpu::util::DeviceExt,
+    egui_wgpu::{self, wgpu},
+};
+
+pub struct Custom3d {
+    angle: f32,
+}
+
+impl Custom3d {
+    pub fn new<'a>(cc: &'a eframe::CreationContext<'a>) -> Option<Self> {
+        // Get the WGPU render state from the eframe creation context. This can also be retrieved
+        // from `eframe::Frame` when you don't have a `CreationContext` available.
+        let wgpu_render_state = cc.wgpu_render_state.as_ref()?;
+
+        let device = &wgpu_render_state.device;
+
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("custom3d"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("./custom3d_wgpu_shader.wgsl").into()),
+        });
+
+        let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("custom3d"),
+            entries: &[wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::VERTEX,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: NonZeroU64::new(16),
+                },
+                count: None,
+            }],
+        });
+
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("custom3d"),
+            bind_group_layouts: &[&bind_group_layout],
+            push_constant_ranges: &[],
+        });
+
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("custom3d"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: "vs_main",
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: "fs_main",
+                targets: &[Some(wgpu_render_state.target_format.into())],
+            }),
+            primitive: wgpu::PrimitiveState::default(),
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+            multiview: None,
+        });
+
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("custom3d"),
+            contents: bytemuck::cast_slice(&[0.0_f32; 4]), // 16 bytes aligned!
+            // Mapping at creation (as done by the create_buffer_init utility) doesn't require us to to add the MAP_WRITE usage
+            // (this *happens* to workaround this bug )
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::UNIFORM,
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("custom3d"),
+            layout: &bind_group_layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: uniform_buffer.as_entire_binding(),
+            }],
+        });
+
+        // Because the graphics pipeline must have the same lifetime as the egui render pass,
+        // instead of storing the pipeline in our `Custom3D` struct, we insert it into the
+        // `paint_callback_resources` type map, which is stored alongside the render pass.
+        wgpu_render_state
+            .renderer
+            .write()
+            .paint_callback_resources
+            .insert(TriangleRenderResources {
+                pipeline,
+                bind_group,
+                uniform_buffer,
+            });
+
+        Some(Self { angle: 0.0 })
+    }
+}
+
+impl eframe::App for Custom3d {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            egui::ScrollArea::both()
+                .auto_shrink([false; 2])
+                .show(ui, |ui| {
+                    ui.horizontal(|ui| {
+                        ui.spacing_mut().item_spacing.x = 0.0;
+                        ui.label("The triangle is being painted using ");
+                        ui.hyperlink_to("WGPU", "https://wgpu.rs");
+                        ui.label(" (Portable Rust graphics API awesomeness)");
+                    });
+                    ui.label("It's not a very impressive demo, but it shows you can embed 3D inside of egui.");
+
+                    egui::Frame::canvas(ui.style()).show(ui, |ui| {
+                        self.custom_painting(ui);
+                    });
+                    ui.label("Drag to rotate!");
+                    ui.add(egui_demo_lib::egui_github_link_file!());
+                });
+        });
+    }
+}
+
+impl Custom3d {
+    fn custom_painting(&mut self, ui: &mut egui::Ui) {
+        let (rect, response) =
+            ui.allocate_exact_size(egui::Vec2::splat(300.0), egui::Sense::drag());
+
+        self.angle += response.drag_delta().x * 0.01;
+
+        // Clone locals so we can move them into the paint callback:
+        let angle = self.angle;
+
+        // The callback function for WGPU is in two stages: prepare, and paint.
+        //
+        // The prepare callback is called every frame before paint and is given access to the wgpu
+        // Device and Queue, which can be used, for instance, to update buffers and uniforms before
+        // rendering.
+        //
+        // You can use the main `CommandEncoder` that is passed-in, return an arbitrary number
+        // of user-defined `CommandBuffer`s, or both.
+        // The main command buffer, as well as all user-defined ones, will be submitted together
+        // to the GPU in a single call.
+        //
+        // The paint callback is called after prepare and is given access to the render pass, which
+        // can be used to issue draw commands.
+        let cb = egui_wgpu::CallbackFn::new()
+            .prepare(move |device, queue, _encoder, paint_callback_resources| {
+                let resources: &TriangleRenderResources = paint_callback_resources.get().unwrap();
+                resources.prepare(device, queue, angle);
+                Vec::new()
+            })
+            .paint(move |_info, render_pass, paint_callback_resources| {
+                let resources: &TriangleRenderResources = paint_callback_resources.get().unwrap();
+                resources.paint(render_pass);
+            });
+
+        let callback = egui::PaintCallback {
+            rect,
+            callback: Arc::new(cb),
+        };
+
+        ui.painter().add(callback);
+    }
+}
+
+struct TriangleRenderResources {
+    pipeline: wgpu::RenderPipeline,
+    bind_group: wgpu::BindGroup,
+    uniform_buffer: wgpu::Buffer,
+}
+
+impl TriangleRenderResources {
+    fn prepare(&self, _device: &wgpu::Device, queue: &wgpu::Queue, angle: f32) {
+        // Update our uniform buffer with the angle from the UI
+        queue.write_buffer(
+            &self.uniform_buffer,
+            0,
+            bytemuck::cast_slice(&[angle, 0.0, 0.0, 0.0]),
+        );
+    }
+
+    fn paint<'rp>(&'rp self, render_pass: &mut wgpu::RenderPass<'rp>) {
+        // Draw our triangle!
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.draw(0..3, 0..1);
+    }
+}
diff --git a/egui/crates/egui_demo_app/src/apps/custom3d_wgpu_shader.wgsl b/egui/crates/egui_demo_app/src/apps/custom3d_wgpu_shader.wgsl
new file mode 100644
index 0000000..d8d7ad1
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/apps/custom3d_wgpu_shader.wgsl
@@ -0,0 +1,39 @@
+struct VertexOut {
+    @location(0) color: vec4<f32>,
+    @builtin(position) position: vec4<f32>,
+};
+
+struct Uniforms {
+    @size(16) angle: f32, // pad to 16 bytes
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+var<private> v_positions: array<vec2<f32>, 3> = array<vec2<f32>, 3>(
+    vec2<f32>(0.0, 1.0),
+    vec2<f32>(1.0, -1.0),
+    vec2<f32>(-1.0, -1.0),
+);
+
+var<private> v_colors: array<vec4<f32>, 3> = array<vec4<f32>, 3>(
+    vec4<f32>(1.0, 0.0, 0.0, 1.0),
+    vec4<f32>(0.0, 1.0, 0.0, 1.0),
+    vec4<f32>(0.0, 0.0, 1.0, 1.0),
+);
+
+@vertex
+fn vs_main(@builtin(vertex_index) v_idx: u32) -> VertexOut {
+    var out: VertexOut;
+
+    out.position = vec4<f32>(v_positions[v_idx], 0.0, 1.0);
+    out.position.x = out.position.x * cos(uniforms.angle);
+    out.color = v_colors[v_idx];
+
+    return out;
+}
+
+@fragment
+fn fs_main(in: VertexOut) -> @location(0) vec4<f32> {
+    return in.color;
+}
diff --git a/egui/crates/egui_demo_app/src/apps/fractal_clock.rs b/egui/crates/egui_demo_app/src/apps/fractal_clock.rs
new file mode 100644
index 0000000..6afe6f0
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/apps/fractal_clock.rs
@@ -0,0 +1,205 @@
+use egui::{containers::*, widgets::*, *};
+use std::f32::consts::TAU;
+
+#[derive(PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct FractalClock {
+    paused: bool,
+    time: f64,
+    zoom: f32,
+    start_line_width: f32,
+    depth: usize,
+    length_factor: f32,
+    luminance_factor: f32,
+    width_factor: f32,
+    line_count: usize,
+}
+
+impl Default for FractalClock {
+    fn default() -> Self {
+        Self {
+            paused: false,
+            time: 0.0,
+            zoom: 0.25,
+            start_line_width: 2.5,
+            depth: 9,
+            length_factor: 0.8,
+            luminance_factor: 0.8,
+            width_factor: 0.9,
+            line_count: 0,
+        }
+    }
+}
+
+impl FractalClock {
+    pub fn ui(&mut self, ui: &mut Ui, seconds_since_midnight: Option<f64>) {
+        if !self.paused {
+            self.time = seconds_since_midnight.unwrap_or_else(|| ui.input(|i| i.time));
+            ui.ctx().request_repaint();
+        }
+
+        let painter = Painter::new(
+            ui.ctx().clone(),
+            ui.layer_id(),
+            ui.available_rect_before_wrap(),
+        );
+        self.paint(&painter);
+        // Make sure we allocate what we used (everything)
+        ui.expand_to_include_rect(painter.clip_rect());
+
+        Frame::popup(ui.style())
+            .stroke(Stroke::NONE)
+            .show(ui, |ui| {
+                ui.set_max_width(270.0);
+                CollapsingHeader::new("Settings")
+                    .show(ui, |ui| self.options_ui(ui, seconds_since_midnight));
+            });
+    }
+
+    fn options_ui(&mut self, ui: &mut Ui, seconds_since_midnight: Option<f64>) {
+        if seconds_since_midnight.is_some() {
+            ui.label(format!(
+                "Local time: {:02}:{:02}:{:02}.{:03}",
+                (self.time % (24.0 * 60.0 * 60.0) / 3600.0).floor(),
+                (self.time % (60.0 * 60.0) / 60.0).floor(),
+                (self.time % 60.0).floor(),
+                (self.time % 1.0 * 100.0).floor()
+            ));
+        } else {
+            ui.label("The fractal_clock clock is not showing the correct time");
+        };
+        ui.label(format!("Painted line count: {}", self.line_count));
+
+        ui.checkbox(&mut self.paused, "Paused");
+        ui.add(Slider::new(&mut self.zoom, 0.0..=1.0).text("zoom"));
+        ui.add(Slider::new(&mut self.start_line_width, 0.0..=5.0).text("Start line width"));
+        ui.add(Slider::new(&mut self.depth, 0..=14).text("depth"));
+        ui.add(Slider::new(&mut self.length_factor, 0.0..=1.0).text("length factor"));
+        ui.add(Slider::new(&mut self.luminance_factor, 0.0..=1.0).text("luminance factor"));
+        ui.add(Slider::new(&mut self.width_factor, 0.0..=1.0).text("width factor"));
+
+        egui::reset_button(ui, self);
+
+        ui.hyperlink_to(
+            "Inspired by a screensaver by Rob Mayoff",
+            "http://www.dqd.com/~mayoff/programs/FractalClock/",
+        );
+        ui.add(egui_demo_lib::egui_github_link_file!());
+    }
+
+    fn paint(&mut self, painter: &Painter) {
+        struct Hand {
+            length: f32,
+            angle: f32,
+            vec: Vec2,
+        }
+
+        impl Hand {
+            fn from_length_angle(length: f32, angle: f32) -> Self {
+                Self {
+                    length,
+                    angle,
+                    vec: length * Vec2::angled(angle),
+                }
+            }
+        }
+
+        let angle_from_period =
+            |period| TAU * (self.time.rem_euclid(period) / period) as f32 - TAU / 4.0;
+
+        let hands = [
+            // Second hand:
+            Hand::from_length_angle(self.length_factor, angle_from_period(60.0)),
+            // Minute hand:
+            Hand::from_length_angle(self.length_factor, angle_from_period(60.0 * 60.0)),
+            // Hour hand:
+            Hand::from_length_angle(0.5, angle_from_period(12.0 * 60.0 * 60.0)),
+        ];
+
+        let mut shapes: Vec<Shape> = Vec::new();
+
+        let rect = painter.clip_rect();
+        let to_screen = emath::RectTransform::from_to(
+            Rect::from_center_size(Pos2::ZERO, rect.square_proportions() / self.zoom),
+            rect,
+        );
+
+        let mut paint_line = |points: [Pos2; 2], color: Color32, width: f32| {
+            let line = [to_screen * points[0], to_screen * points[1]];
+
+            // culling
+            if rect.intersects(Rect::from_two_pos(line[0], line[1])) {
+                shapes.push(Shape::line_segment(line, (width, color)));
+            }
+        };
+
+        let hand_rotations = [
+            hands[0].angle - hands[2].angle + TAU / 2.0,
+            hands[1].angle - hands[2].angle + TAU / 2.0,
+        ];
+
+        let hand_rotors = [
+            hands[0].length * emath::Rot2::from_angle(hand_rotations[0]),
+            hands[1].length * emath::Rot2::from_angle(hand_rotations[1]),
+        ];
+
+        #[derive(Clone, Copy)]
+        struct Node {
+            pos: Pos2,
+            dir: Vec2,
+        }
+
+        let mut nodes = Vec::new();
+
+        let mut width = self.start_line_width;
+
+        for (i, hand) in hands.iter().enumerate() {
+            let center = pos2(0.0, 0.0);
+            let end = center + hand.vec;
+            paint_line([center, end], Color32::from_additive_luminance(255), width);
+            if i < 2 {
+                nodes.push(Node {
+                    pos: end,
+                    dir: hand.vec,
+                });
+            }
+        }
+
+        let mut luminance = 0.7; // Start dimmer than main hands
+
+        let mut new_nodes = Vec::new();
+        for _ in 0..self.depth {
+            new_nodes.clear();
+            new_nodes.reserve(nodes.len() * 2);
+
+            luminance *= self.luminance_factor;
+            width *= self.width_factor;
+
+            let luminance_u8 = (255.0 * luminance).round() as u8;
+            if luminance_u8 == 0 {
+                break;
+            }
+
+            for &rotor in &hand_rotors {
+                for a in &nodes {
+                    let new_dir = rotor * a.dir;
+                    let b = Node {
+                        pos: a.pos + new_dir,
+                        dir: new_dir,
+                    };
+                    paint_line(
+                        [a.pos, b.pos],
+                        Color32::from_additive_luminance(luminance_u8),
+                        width,
+                    );
+                    new_nodes.push(b);
+                }
+            }
+
+            std::mem::swap(&mut nodes, &mut new_nodes);
+        }
+        self.line_count = shapes.len();
+        painter.extend(shapes);
+    }
+}
diff --git a/egui/crates/egui_demo_app/src/apps/http_app.rs b/egui/crates/egui_demo_app/src/apps/http_app.rs
new file mode 100644
index 0000000..4d87a3e
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/apps/http_app.rs
@@ -0,0 +1,266 @@
+use egui_extras::RetainedImage;
+use poll_promise::Promise;
+
+struct Resource {
+    /// HTTP response
+    response: ehttp::Response,
+
+    text: Option<String>,
+
+    /// If set, the response was an image.
+    image: Option<RetainedImage>,
+
+    /// If set, the response was text with some supported syntax highlighting (e.g. ".rs" or ".md").
+    colored_text: Option<ColoredText>,
+}
+
+impl Resource {
+    fn from_response(ctx: &egui::Context, response: ehttp::Response) -> Self {
+        let content_type = response.content_type().unwrap_or_default();
+        let image = if content_type.starts_with("image/") {
+            RetainedImage::from_image_bytes(&response.url, &response.bytes).ok()
+        } else {
+            None
+        };
+
+        let text = response.text();
+        let colored_text = text.and_then(|text| syntax_highlighting(ctx, &response, text));
+        let text = text.map(|text| text.to_owned());
+
+        Self {
+            response,
+            text,
+            image,
+            colored_text,
+        }
+    }
+}
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct HttpApp {
+    url: String,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    promise: Option<Promise<ehttp::Result<Resource>>>,
+}
+
+impl Default for HttpApp {
+    fn default() -> Self {
+        Self {
+            url: "https://raw.githubusercontent.com/emilk/egui/master/README.md".to_owned(),
+            promise: Default::default(),
+        }
+    }
+}
+
+impl eframe::App for HttpApp {
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        egui::TopBottomPanel::bottom("http_bottom").show(ctx, |ui| {
+            let layout = egui::Layout::top_down(egui::Align::Center).with_main_justify(true);
+            ui.allocate_ui_with_layout(ui.available_size(), layout, |ui| {
+                ui.add(egui_demo_lib::egui_github_link_file!())
+            })
+        });
+
+        egui::CentralPanel::default().show(ctx, |ui| {
+            let trigger_fetch = ui_url(ui, frame, &mut self.url);
+
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("HTTP requests made using ");
+                ui.hyperlink_to("ehttp", "https://www.github.com/emilk/ehttp");
+                ui.label(".");
+            });
+
+            if trigger_fetch {
+                let ctx = ctx.clone();
+                let (sender, promise) = Promise::new();
+                let request = ehttp::Request::get(&self.url);
+                ehttp::fetch(request, move |response| {
+                    ctx.request_repaint(); // wake up UI thread
+                    let resource = response.map(|response| Resource::from_response(&ctx, response));
+                    sender.send(resource);
+                });
+                self.promise = Some(promise);
+            }
+
+            ui.separator();
+
+            if let Some(promise) = &self.promise {
+                if let Some(result) = promise.ready() {
+                    match result {
+                        Ok(resource) => {
+                            ui_resource(ui, resource);
+                        }
+                        Err(error) => {
+                            // This should only happen if the fetch API isn't available or something similar.
+                            ui.colored_label(
+                                ui.visuals().error_fg_color,
+                                if error.is_empty() { "Error" } else { error },
+                            );
+                        }
+                    }
+                } else {
+                    ui.spinner();
+                }
+            }
+        });
+    }
+}
+
+fn ui_url(ui: &mut egui::Ui, frame: &mut eframe::Frame, url: &mut String) -> bool {
+    let mut trigger_fetch = false;
+
+    ui.horizontal(|ui| {
+        ui.label("URL:");
+        trigger_fetch |= ui
+            .add(egui::TextEdit::singleline(url).desired_width(f32::INFINITY))
+            .lost_focus();
+    });
+
+    if frame.is_web() {
+        ui.label("HINT: paste the url of this page into the field above!");
+    }
+
+    ui.horizontal(|ui| {
+        if ui.button("Source code for this example").clicked() {
+            *url = format!(
+                "https://raw.githubusercontent.com/emilk/egui/master/{}",
+                file!()
+            );
+            trigger_fetch = true;
+        }
+        if ui.button("Random image").clicked() {
+            let seed = ui.input(|i| i.time);
+            let side = 640;
+            *url = format!("https://picsum.photos/seed/{}/{}", seed, side);
+            trigger_fetch = true;
+        }
+    });
+
+    trigger_fetch
+}
+
+fn ui_resource(ui: &mut egui::Ui, resource: &Resource) {
+    let Resource {
+        response,
+        text,
+        image,
+        colored_text,
+    } = resource;
+
+    ui.monospace(format!("url:          {}", response.url));
+    ui.monospace(format!(
+        "status:       {} ({})",
+        response.status, response.status_text
+    ));
+    ui.monospace(format!(
+        "content-type: {}",
+        response.content_type().unwrap_or_default()
+    ));
+    ui.monospace(format!(
+        "size:         {:.1} kB",
+        response.bytes.len() as f32 / 1000.0
+    ));
+
+    ui.separator();
+
+    egui::ScrollArea::vertical()
+        .auto_shrink([false; 2])
+        .show(ui, |ui| {
+            egui::CollapsingHeader::new("Response headers")
+                .default_open(false)
+                .show(ui, |ui| {
+                    egui::Grid::new("response_headers")
+                        .spacing(egui::vec2(ui.spacing().item_spacing.x * 2.0, 0.0))
+                        .show(ui, |ui| {
+                            for header in &response.headers {
+                                ui.label(header.0);
+                                ui.label(header.1);
+                                ui.end_row();
+                            }
+                        })
+                });
+
+            ui.separator();
+
+            if let Some(text) = &text {
+                let tooltip = "Click to copy the response body";
+                if ui.button("📋").on_hover_text(tooltip).clicked() {
+                    ui.output_mut(|o| o.copied_text = text.clone());
+                }
+                ui.separator();
+            }
+
+            if let Some(image) = image {
+                let mut size = image.size_vec2();
+                size *= (ui.available_width() / size.x).min(1.0);
+                image.show_size(ui, size);
+            } else if let Some(colored_text) = colored_text {
+                colored_text.ui(ui);
+            } else if let Some(text) = &text {
+                selectable_text(ui, text);
+            } else {
+                ui.monospace("[binary]");
+            }
+        });
+}
+
+fn selectable_text(ui: &mut egui::Ui, mut text: &str) {
+    ui.add(
+        egui::TextEdit::multiline(&mut text)
+            .desired_width(f32::INFINITY)
+            .font(egui::TextStyle::Monospace),
+    );
+}
+
+// ----------------------------------------------------------------------------
+// Syntax highlighting:
+
+#[cfg(feature = "syntect")]
+fn syntax_highlighting(
+    ctx: &egui::Context,
+    response: &ehttp::Response,
+    text: &str,
+) -> Option<ColoredText> {
+    let extension_and_rest: Vec<&str> = response.url.rsplitn(2, '.').collect();
+    let extension = extension_and_rest.get(0)?;
+    let theme = crate::syntax_highlighting::CodeTheme::from_style(&ctx.style());
+    Some(ColoredText(crate::syntax_highlighting::highlight(
+        ctx, &theme, text, extension,
+    )))
+}
+
+#[cfg(not(feature = "syntect"))]
+fn syntax_highlighting(_ctx: &egui::Context, _: &ehttp::Response, _: &str) -> Option<ColoredText> {
+    None
+}
+
+struct ColoredText(egui::text::LayoutJob);
+
+impl ColoredText {
+    pub fn ui(&self, ui: &mut egui::Ui) {
+        if true {
+            // Selectable text:
+            let mut layouter = |ui: &egui::Ui, _string: &str, wrap_width: f32| {
+                let mut layout_job = self.0.clone();
+                layout_job.wrap.max_width = wrap_width;
+                ui.fonts(|f| f.layout_job(layout_job))
+            };
+
+            let mut text = self.0.text.as_str();
+            ui.add(
+                egui::TextEdit::multiline(&mut text)
+                    .font(egui::TextStyle::Monospace)
+                    .desired_width(f32::INFINITY)
+                    .layouter(&mut layouter),
+            );
+        } else {
+            let mut job = self.0.clone();
+            job.wrap.max_width = ui.available_width();
+            let galley = ui.fonts(|f| f.layout_job(job));
+            let (response, painter) = ui.allocate_painter(galley.size(), egui::Sense::hover());
+            painter.add(egui::Shape::galley(response.rect.min, galley));
+        }
+    }
+}
diff --git a/egui/crates/egui_demo_app/src/apps/mod.rs b/egui/crates/egui_demo_app/src/apps/mod.rs
new file mode 100644
index 0000000..1e28bbd
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/apps/mod.rs
@@ -0,0 +1,21 @@
+#[cfg(all(feature = "glow", not(feature = "wgpu")))]
+mod custom3d_glow;
+
+#[cfg(feature = "wgpu")]
+mod custom3d_wgpu;
+
+mod fractal_clock;
+
+#[cfg(feature = "http")]
+mod http_app;
+
+#[cfg(all(feature = "glow", not(feature = "wgpu")))]
+pub use custom3d_glow::Custom3d;
+
+#[cfg(feature = "wgpu")]
+pub use custom3d_wgpu::Custom3d;
+
+pub use fractal_clock::FractalClock;
+
+#[cfg(feature = "http")]
+pub use http_app::HttpApp;
diff --git a/egui/crates/egui_demo_app/src/backend_panel.rs b/egui/crates/egui_demo_app/src/backend_panel.rs
new file mode 100644
index 0000000..d71538c
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/backend_panel.rs
@@ -0,0 +1,396 @@
+use egui::Widget;
+
+/// How often we repaint the demo app by default
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum RunMode {
+    /// This is the default for the demo.
+    ///
+    /// If this is selected, egui is only updated if are input events
+    /// (like mouse movements) or there are some animations in the GUI.
+    ///
+    /// Reactive mode saves CPU.
+    ///
+    /// The downside is that the UI can become out-of-date if something it is supposed to monitor changes.
+    /// For instance, a GUI for a thermostat need to repaint each time the temperature changes.
+    /// To ensure the UI is up to date you need to call `egui::Context::request_repaint()` each
+    /// time such an event happens. You can also chose to call `request_repaint()` once every second
+    /// or after every single frame - this is called [`Continuous`](RunMode::Continuous) mode,
+    /// and for games and interactive tools that need repainting every frame anyway, this should be the default.
+    Reactive,
+
+    /// This will call `egui::Context::request_repaint()` at the end of each frame
+    /// to request the backend to repaint as soon as possible.
+    ///
+    /// On most platforms this will mean that egui will run at the display refresh rate of e.g. 60 Hz.
+    ///
+    /// For this demo it is not any reason to do so except to
+    /// demonstrate how quickly egui runs.
+    ///
+    /// For games or other interactive apps, this is probably what you want to do.
+    /// It will guarantee that egui is always up-to-date.
+    Continuous,
+}
+
+/// Default for demo is Reactive since
+/// 1) We want to use minimal CPU
+/// 2) There are no external events that could invalidate the UI
+///    so there are no events to miss.
+impl Default for RunMode {
+    fn default() -> Self {
+        RunMode::Reactive
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct BackendPanel {
+    pub open: bool,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    // go back to [`RunMode::Reactive`] mode each time we start
+    run_mode: RunMode,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    repaint_after_seconds: f32,
+
+    /// current slider value for current gui scale
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pixels_per_point: Option<f32>,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    frame_history: crate::frame_history::FrameHistory,
+
+    egui_windows: EguiWindows,
+}
+
+impl Default for BackendPanel {
+    fn default() -> Self {
+        Self {
+            open: false,
+            run_mode: Default::default(),
+            repaint_after_seconds: 1.0,
+            pixels_per_point: None,
+            frame_history: Default::default(),
+            egui_windows: Default::default(),
+        }
+    }
+}
+
+impl BackendPanel {
+    pub fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        self.frame_history
+            .on_new_frame(ctx.input(|i| i.time), frame.info().cpu_usage);
+
+        match self.run_mode {
+            RunMode::Continuous => {
+                // Tell the backend to repaint as soon as possible
+                ctx.request_repaint();
+            }
+            RunMode::Reactive => {
+                // let the computer rest for a bit
+                ctx.request_repaint_after(std::time::Duration::from_secs_f32(
+                    self.repaint_after_seconds,
+                ));
+            }
+        }
+    }
+
+    pub fn end_of_frame(&mut self, ctx: &egui::Context) {
+        self.egui_windows.windows(ctx);
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
+        egui::trace!(ui);
+
+        self.integration_ui(ui, frame);
+
+        ui.separator();
+
+        self.run_mode_ui(ui);
+
+        ui.separator();
+
+        self.frame_history.ui(ui);
+
+        ui.separator();
+
+        ui.label("egui windows:");
+        self.egui_windows.checkboxes(ui);
+
+        ui.separator();
+
+        {
+            let mut debug_on_hover = ui.ctx().debug_on_hover();
+            ui.checkbox(&mut debug_on_hover, "🐛 Debug on hover")
+                .on_hover_text("Show structure of the ui when you hover with the mouse");
+            ui.ctx().set_debug_on_hover(debug_on_hover);
+        }
+
+        ui.separator();
+
+        #[cfg(target_arch = "wasm32")]
+        #[cfg(feature = "web_screen-reader")]
+        {
+            let mut screen_reader = ui.ctx().options(|o| o.screen_reader);
+            ui.checkbox(&mut screen_reader, "🔈 Screen reader").on_hover_text("Experimental feature: checking this will turn on the screen reader on supported platforms");
+            ui.ctx().options_mut(|o| o.screen_reader = screen_reader);
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            ui.separator();
+            if ui.button("Quit").clicked() {
+                frame.close();
+            }
+        }
+    }
+
+    fn integration_ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
+        ui.horizontal(|ui| {
+            ui.spacing_mut().item_spacing.x = 0.0;
+            ui.label("egui running inside ");
+            ui.hyperlink_to(
+                "eframe",
+                "https://github.com/emilk/egui/tree/master/crates/eframe",
+            );
+            ui.label(".");
+        });
+
+        #[cfg(target_arch = "wasm32")]
+        ui.collapsing("Web info (location)", |ui| {
+            ui.monospace(format!("{:#?}", frame.info().web_info.location));
+        });
+
+        // On web, the browser controls `pixels_per_point`.
+        let integration_controls_pixels_per_point = frame.is_web();
+        if !integration_controls_pixels_per_point {
+            self.pixels_per_point_ui(ui, &frame.info());
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            ui.horizontal(|ui| {
+                {
+                    let mut fullscreen = frame.info().window_info.fullscreen;
+                    if ui
+                        .checkbox(&mut fullscreen, "🗖 Fullscreen (F11)")
+                        .on_hover_text("Fullscreen the window")
+                        .changed()
+                    {
+                        frame.set_fullscreen(fullscreen);
+                    }
+                }
+
+                if ui
+                    .button("📱 Phone Size")
+                    .on_hover_text("Resize the window to be small like a phone.")
+                    .clicked()
+                {
+                    // frame.set_window_size(egui::vec2(375.0, 812.0)); // iPhone 12 mini
+                    frame.set_window_size(egui::vec2(375.0, 667.0)); //  iPhone SE 2nd gen
+                    frame.set_fullscreen(false);
+                    ui.close_menu();
+                }
+            });
+
+            if !frame.info().window_info.fullscreen
+                && ui
+                    .button("Drag me to drag window")
+                    .is_pointer_button_down_on()
+            {
+                frame.drag_window();
+            }
+        }
+    }
+
+    fn pixels_per_point_ui(&mut self, ui: &mut egui::Ui, info: &eframe::IntegrationInfo) {
+        let pixels_per_point = self
+            .pixels_per_point
+            .get_or_insert_with(|| ui.ctx().pixels_per_point());
+
+        let mut reset = false;
+
+        ui.horizontal(|ui| {
+            ui.spacing_mut().slider_width = 90.0;
+
+            let response = ui
+                .add(
+                    egui::Slider::new(pixels_per_point, 0.5..=5.0)
+                        .logarithmic(true)
+                        .clamp_to_range(true)
+                        .text("Scale"),
+                )
+                .on_hover_text("Physical pixels per point.");
+
+            if response.drag_released() {
+                // We wait until mouse release to activate:
+                ui.ctx().set_pixels_per_point(*pixels_per_point);
+                reset = true;
+            } else if !response.is_pointer_button_down_on() {
+                // When not dragging, show the current pixels_per_point so others can change it.
+                reset = true;
+            }
+
+            if let Some(native_pixels_per_point) = info.native_pixels_per_point {
+                let enabled = ui.ctx().pixels_per_point() != native_pixels_per_point;
+                if ui
+                    .add_enabled(enabled, egui::Button::new("Reset"))
+                    .on_hover_text(format!(
+                        "Reset scale to native value ({:.1})",
+                        native_pixels_per_point
+                    ))
+                    .clicked()
+                {
+                    ui.ctx().set_pixels_per_point(native_pixels_per_point);
+                }
+            }
+        });
+
+        if reset {
+            self.pixels_per_point = None;
+        }
+    }
+
+    fn run_mode_ui(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            let run_mode = &mut self.run_mode;
+            ui.label("Mode:");
+            ui.radio_value(run_mode, RunMode::Reactive, "Reactive")
+                .on_hover_text("Repaint when there are animations or input (e.g. mouse movement)");
+            ui.radio_value(run_mode, RunMode::Continuous, "Continuous")
+                .on_hover_text("Repaint everything each frame");
+        });
+
+        if self.run_mode == RunMode::Continuous {
+            ui.label(format!(
+                "Repainting the UI each frame. FPS: {:.1}",
+                self.frame_history.fps()
+            ));
+        } else {
+            ui.label("Only running UI code when there are animations or input.");
+
+            ui.horizontal(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("(but at least every ");
+                egui::DragValue::new(&mut self.repaint_after_seconds)
+                    .clamp_range(0.1..=10.0)
+                    .speed(0.1)
+                    .suffix(" s")
+                    .ui(ui)
+                    .on_hover_text("Repaint this often, even if there is no input.");
+                ui.label(")");
+            });
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+struct EguiWindows {
+    // egui stuff:
+    settings: bool,
+    inspection: bool,
+    memory: bool,
+    output_events: bool,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    output_event_history: std::collections::VecDeque<egui::output::OutputEvent>,
+}
+
+impl Default for EguiWindows {
+    fn default() -> Self {
+        EguiWindows::none()
+    }
+}
+
+impl EguiWindows {
+    fn none() -> Self {
+        Self {
+            settings: false,
+            inspection: false,
+            memory: false,
+            output_events: false,
+            output_event_history: Default::default(),
+        }
+    }
+
+    fn checkboxes(&mut self, ui: &mut egui::Ui) {
+        let Self {
+            settings,
+            inspection,
+            memory,
+            output_events,
+            output_event_history: _,
+        } = self;
+
+        ui.checkbox(settings, "🔧 Settings");
+        ui.checkbox(inspection, "🔍 Inspection");
+        ui.checkbox(memory, "📝 Memory");
+        ui.checkbox(output_events, "📤 Output Events");
+    }
+
+    fn windows(&mut self, ctx: &egui::Context) {
+        let Self {
+            settings,
+            inspection,
+            memory,
+            output_events,
+            output_event_history,
+        } = self;
+
+        ctx.output(|o| {
+            for event in &o.events {
+                output_event_history.push_back(event.clone());
+            }
+        });
+        while output_event_history.len() > 1000 {
+            output_event_history.pop_front();
+        }
+
+        egui::Window::new("🔧 Settings")
+            .open(settings)
+            .vscroll(true)
+            .show(ctx, |ui| {
+                ctx.settings_ui(ui);
+            });
+
+        egui::Window::new("🔍 Inspection")
+            .open(inspection)
+            .vscroll(true)
+            .show(ctx, |ui| {
+                ctx.inspection_ui(ui);
+            });
+
+        egui::Window::new("📝 Memory")
+            .open(memory)
+            .resizable(false)
+            .show(ctx, |ui| {
+                ctx.memory_ui(ui);
+            });
+
+        egui::Window::new("📤 Output Events")
+            .open(output_events)
+            .resizable(true)
+            .default_width(520.0)
+            .show(ctx, |ui| {
+                ui.label(
+                    "Recent output events from egui. \
+            These are emitted when you interact with widgets, or move focus between them with TAB. \
+            They can be hooked up to a screen reader on supported platforms.",
+                );
+
+                ui.separator();
+
+                egui::ScrollArea::vertical()
+                    .stick_to_bottom(true)
+                    .show(ui, |ui| {
+                        for event in output_event_history {
+                            ui.label(format!("{:?}", event));
+                        }
+                    });
+            });
+    }
+}
diff --git a/egui/crates/egui_demo_app/src/frame_history.rs b/egui/crates/egui_demo_app/src/frame_history.rs
new file mode 100644
index 0000000..c2672a0
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/frame_history.rs
@@ -0,0 +1,132 @@
+use egui::util::History;
+
+pub struct FrameHistory {
+    frame_times: History<f32>,
+}
+
+impl Default for FrameHistory {
+    fn default() -> Self {
+        let max_age: f32 = 1.0;
+        let max_len = (max_age * 300.0).round() as usize;
+        Self {
+            frame_times: History::new(0..max_len, max_age),
+        }
+    }
+}
+
+impl FrameHistory {
+    // Called first
+    pub fn on_new_frame(&mut self, now: f64, previous_frame_time: Option<f32>) {
+        let previous_frame_time = previous_frame_time.unwrap_or_default();
+        if let Some(latest) = self.frame_times.latest_mut() {
+            *latest = previous_frame_time; // rewrite history now that we know
+        }
+        self.frame_times.add(now, previous_frame_time); // projected
+    }
+
+    pub fn mean_frame_time(&self) -> f32 {
+        self.frame_times.average().unwrap_or_default()
+    }
+
+    pub fn fps(&self) -> f32 {
+        1.0 / self.frame_times.mean_time_interval().unwrap_or_default()
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.label(format!(
+            "Total frames painted: {}",
+            self.frame_times.total_count()
+        ))
+        .on_hover_text("Includes this frame.");
+
+        ui.label(format!(
+            "Mean CPU usage: {:.2} ms / frame",
+            1e3 * self.mean_frame_time()
+        ))
+        .on_hover_text(
+            "Includes egui layout and tessellation time.\n\
+            Does not include GPU usage, nor overhead for sending data to GPU.",
+        );
+        egui::warn_if_debug_build(ui);
+
+        if !cfg!(target_arch = "wasm32") {
+            egui::CollapsingHeader::new("📊 CPU usage history")
+                .default_open(false)
+                .show(ui, |ui| {
+                    self.graph(ui);
+                });
+        }
+    }
+
+    fn graph(&mut self, ui: &mut egui::Ui) -> egui::Response {
+        use egui::*;
+
+        ui.label("egui CPU usage history");
+
+        let history = &self.frame_times;
+
+        // TODO(emilk): we should not use `slider_width` as default graph width.
+        let height = ui.spacing().slider_width;
+        let size = vec2(ui.available_size_before_wrap().x, height);
+        let (rect, response) = ui.allocate_at_least(size, Sense::hover());
+        let style = ui.style().noninteractive();
+
+        let graph_top_cpu_usage = 0.010;
+        let graph_rect = Rect::from_x_y_ranges(history.max_age()..=0.0, graph_top_cpu_usage..=0.0);
+        let to_screen = emath::RectTransform::from_to(graph_rect, rect);
+
+        let mut shapes = Vec::with_capacity(3 + 2 * history.len());
+        shapes.push(Shape::Rect(epaint::RectShape {
+            rect,
+            rounding: style.rounding,
+            fill: ui.visuals().extreme_bg_color,
+            stroke: ui.style().noninteractive().bg_stroke,
+        }));
+
+        let rect = rect.shrink(4.0);
+        let color = ui.visuals().text_color();
+        let line_stroke = Stroke::new(1.0, color);
+
+        if let Some(pointer_pos) = response.hover_pos() {
+            let y = pointer_pos.y;
+            shapes.push(Shape::line_segment(
+                [pos2(rect.left(), y), pos2(rect.right(), y)],
+                line_stroke,
+            ));
+            let cpu_usage = to_screen.inverse().transform_pos(pointer_pos).y;
+            let text = format!("{:.1} ms", 1e3 * cpu_usage);
+            shapes.push(ui.fonts(|f| {
+                Shape::text(
+                    f,
+                    pos2(rect.left(), y),
+                    egui::Align2::LEFT_BOTTOM,
+                    text,
+                    TextStyle::Monospace.resolve(ui.style()),
+                    color,
+                )
+            }));
+        }
+
+        let circle_color = color;
+        let radius = 2.0;
+        let right_side_time = ui.input(|i| i.time); // Time at right side of screen
+
+        for (time, cpu_usage) in history.iter() {
+            let age = (right_side_time - time) as f32;
+            let pos = to_screen.transform_pos_clamped(Pos2::new(age, cpu_usage));
+
+            shapes.push(Shape::line_segment(
+                [pos2(pos.x, rect.bottom()), pos],
+                line_stroke,
+            ));
+
+            if cpu_usage < graph_top_cpu_usage {
+                shapes.push(Shape::circle_filled(pos, radius, circle_color));
+            }
+        }
+
+        ui.painter().extend(shapes);
+
+        response
+    }
+}
diff --git a/egui/crates/egui_demo_app/src/lib.rs b/egui/crates/egui_demo_app/src/lib.rs
new file mode 100644
index 0000000..af32cf8
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/lib.rs
@@ -0,0 +1,80 @@
+//! Demo app for egui
+#![allow(clippy::missing_errors_doc)]
+
+mod apps;
+mod backend_panel;
+pub(crate) mod frame_history;
+mod wrap_app;
+
+#[cfg(target_arch = "wasm32")]
+use eframe::web::AppRunnerRef;
+
+pub use wrap_app::WrapApp;
+
+/// Time of day as seconds since midnight. Used for clock in demo app.
+pub(crate) fn seconds_since_midnight() -> f64 {
+    use chrono::Timelike;
+    let time = chrono::Local::now().time();
+    time.num_seconds_from_midnight() as f64 + 1e-9 * (time.nanosecond() as f64)
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(target_arch = "wasm32")]
+use eframe::wasm_bindgen::{self, prelude::*};
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub struct WebHandle {
+    handle: AppRunnerRef,
+}
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+impl WebHandle {
+    #[wasm_bindgen]
+    pub fn stop_web(&self) -> Result<(), wasm_bindgen::JsValue> {
+        let mut app = self.handle.lock();
+        app.destroy()
+    }
+
+    #[wasm_bindgen]
+    pub fn set_some_content_from_javascript(&mut self, _some_data: &str) {
+        let _app = self.handle.lock().app_mut::<WrapApp>();
+        // _app.data = some_data;
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub fn init_wasm_hooks() {
+    // Make sure panics are logged using `console.error`.
+    console_error_panic_hook::set_once();
+
+    // Redirect tracing to console.log and friends:
+    tracing_wasm::set_as_global_default();
+}
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub async fn start_separate(canvas_id: &str) -> Result<WebHandle, wasm_bindgen::JsValue> {
+    let web_options = eframe::WebOptions::default();
+    eframe::start_web(
+        canvas_id,
+        web_options,
+        Box::new(|cc| Box::new(WrapApp::new(cc))),
+    )
+    .await
+    .map(|handle| WebHandle { handle })
+}
+
+/// This is the entry-point for all the web-assembly.
+/// This is called once from the HTML.
+/// It loads the app, installs some callbacks, then returns.
+/// You can add more callbacks like this if you want to call in to your code.
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub async fn start(canvas_id: &str) -> Result<WebHandle, wasm_bindgen::JsValue> {
+    init_wasm_hooks();
+    start_separate(canvas_id).await
+}
diff --git a/egui/crates/egui_demo_app/src/main.rs b/egui/crates/egui_demo_app/src/main.rs
new file mode 100644
index 0000000..d87b10c
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/main.rs
@@ -0,0 +1,36 @@
+//! Demo app for egui
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+// When compiling natively:
+fn main() -> Result<(), eframe::Error> {
+    {
+        // Silence wgpu log spam (https://github.com/gfx-rs/wgpu/issues/3206)
+        let mut rust_log = std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_owned());
+        for loud_crate in ["naga", "wgpu_core", "wgpu_hal"] {
+            if !rust_log.contains(&format!("{loud_crate}=")) {
+                rust_log += &format!(",{loud_crate}=warn");
+            }
+        }
+        std::env::set_var("RUST_LOG", rust_log);
+    }
+
+    // Log to stdout (if you run with `RUST_LOG=debug`).
+    tracing_subscriber::fmt::init();
+
+    let options = eframe::NativeOptions {
+        drag_and_drop_support: true,
+
+        initial_window_size: Some([1280.0, 1024.0].into()),
+
+        #[cfg(feature = "wgpu")]
+        renderer: eframe::Renderer::Wgpu,
+
+        ..Default::default()
+    };
+    eframe::run_native(
+        "egui demo app",
+        options,
+        Box::new(|cc| Box::new(egui_demo_app::WrapApp::new(cc))),
+    )
+}
diff --git a/egui/crates/egui_demo_app/src/wrap_app.rs b/egui/crates/egui_demo_app/src/wrap_app.rs
new file mode 100644
index 0000000..3b2c09a
--- /dev/null
+++ b/egui/crates/egui_demo_app/src/wrap_app.rs
@@ -0,0 +1,457 @@
+use egui_demo_lib::is_mobile;
+
+#[cfg(feature = "glow")]
+use eframe::glow;
+
+#[cfg(target_arch = "wasm32")]
+use core::any::Any;
+
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+struct EasyMarkApp {
+    editor: egui_demo_lib::easy_mark::EasyMarkEditor,
+}
+
+impl eframe::App for EasyMarkApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        self.editor.panels(ctx);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct DemoApp {
+    demo_windows: egui_demo_lib::DemoWindows,
+}
+
+impl eframe::App for DemoApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        self.demo_windows.ui(ctx);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct FractalClockApp {
+    fractal_clock: crate::apps::FractalClock,
+}
+
+impl eframe::App for FractalClockApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default()
+            .frame(egui::Frame::dark_canvas(&ctx.style()))
+            .show(ctx, |ui| {
+                self.fractal_clock
+                    .ui(ui, Some(crate::seconds_since_midnight()));
+            });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ColorTestApp {
+    color_test: egui_demo_lib::ColorTest,
+}
+
+impl eframe::App for ColorTestApp {
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            if frame.is_web() {
+                ui.label(
+                    "NOTE: Some old browsers stuck on WebGL1 without sRGB support will not pass the color test.",
+                );
+                ui.separator();
+            }
+            egui::ScrollArea::both().auto_shrink([false; 2]).show(ui, |ui| {
+                self.color_test.ui(ui);
+            });
+        });
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+enum Anchor {
+    Demo,
+    EasyMarkEditor,
+    #[cfg(feature = "http")]
+    Http,
+    Clock,
+    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    Custom3d,
+    Colors,
+}
+
+impl Anchor {
+    #[cfg(target_arch = "wasm32")]
+    fn all() -> Vec<Self> {
+        vec![
+            Anchor::Demo,
+            Anchor::EasyMarkEditor,
+            #[cfg(feature = "http")]
+            Anchor::Http,
+            Anchor::Clock,
+            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            Anchor::Custom3d,
+            Anchor::Colors,
+        ]
+    }
+}
+
+impl std::fmt::Display for Anchor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
+impl From<Anchor> for egui::WidgetText {
+    fn from(value: Anchor) -> Self {
+        Self::RichText(egui::RichText::new(value.to_string()))
+    }
+}
+
+impl Default for Anchor {
+    fn default() -> Self {
+        Self::Demo
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// The state that we persist (serialize).
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct State {
+    demo: DemoApp,
+    easy_mark_editor: EasyMarkApp,
+    #[cfg(feature = "http")]
+    http: crate::apps::HttpApp,
+    clock: FractalClockApp,
+    color_test: ColorTestApp,
+
+    selected_anchor: Anchor,
+    backend_panel: super::backend_panel::BackendPanel,
+}
+
+/// Wraps many demo/test apps into one.
+pub struct WrapApp {
+    state: State,
+
+    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    custom3d: Option<crate::apps::Custom3d>,
+
+    dropped_files: Vec<egui::DroppedFile>,
+}
+
+impl WrapApp {
+    pub fn new(_cc: &eframe::CreationContext<'_>) -> Self {
+        #[allow(unused_mut)]
+        let mut slf = Self {
+            state: State::default(),
+
+            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            custom3d: crate::apps::Custom3d::new(_cc),
+
+            dropped_files: Default::default(),
+        };
+
+        #[cfg(feature = "persistence")]
+        if let Some(storage) = _cc.storage {
+            if let Some(state) = eframe::get_value(storage, eframe::APP_KEY) {
+                slf.state = state;
+            }
+        }
+
+        slf
+    }
+
+    fn apps_iter_mut(&mut self) -> impl Iterator<Item = (&str, Anchor, &mut dyn eframe::App)> {
+        let mut vec = vec![
+            (
+                "✨ Demos",
+                Anchor::Demo,
+                &mut self.state.demo as &mut dyn eframe::App,
+            ),
+            (
+                "🖹 EasyMark editor",
+                Anchor::EasyMarkEditor,
+                &mut self.state.easy_mark_editor as &mut dyn eframe::App,
+            ),
+            #[cfg(feature = "http")]
+            (
+                "⬇ HTTP",
+                Anchor::Http,
+                &mut self.state.http as &mut dyn eframe::App,
+            ),
+            (
+                "🕑 Fractal Clock",
+                Anchor::Clock,
+                &mut self.state.clock as &mut dyn eframe::App,
+            ),
+        ];
+
+        #[cfg(any(feature = "glow", feature = "wgpu"))]
+        if let Some(custom3d) = &mut self.custom3d {
+            vec.push((
+                "🔺 3D painting",
+                Anchor::Custom3d,
+                custom3d as &mut dyn eframe::App,
+            ));
+        }
+
+        vec.push((
+            "🎨 Color test",
+            Anchor::Colors,
+            &mut self.state.color_test as &mut dyn eframe::App,
+        ));
+
+        vec.into_iter()
+    }
+}
+
+impl eframe::App for WrapApp {
+    #[cfg(feature = "persistence")]
+    fn save(&mut self, storage: &mut dyn eframe::Storage) {
+        eframe::set_value(storage, eframe::APP_KEY, &self.state);
+    }
+
+    fn clear_color(&self, visuals: &egui::Visuals) -> [f32; 4] {
+        visuals.panel_fill.to_normalized_gamma_f32()
+    }
+
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        #[cfg(target_arch = "wasm32")]
+        if let Some(anchor) = frame.info().web_info.location.hash.strip_prefix('#') {
+            let anchor = Anchor::all().into_iter().find(|x| x.to_string() == anchor);
+            if let Some(v) = anchor {
+                self.state.selected_anchor = v;
+            }
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::F11)) {
+            frame.set_fullscreen(!frame.info().window_info.fullscreen);
+        }
+
+        egui::TopBottomPanel::top("wrap_app_top_bar").show(ctx, |ui| {
+            egui::trace!(ui);
+            ui.horizontal_wrapped(|ui| {
+                ui.visuals_mut().button_frame = false;
+                self.bar_contents(ui, frame);
+            });
+        });
+
+        self.state.backend_panel.update(ctx, frame);
+
+        if !is_mobile(ctx) {
+            self.backend_panel(ctx, frame);
+        }
+
+        self.show_selected_app(ctx, frame);
+
+        self.state.backend_panel.end_of_frame(ctx);
+
+        self.ui_file_drag_and_drop(ctx);
+
+        // On web, the browser controls `pixels_per_point`.
+        if !frame.is_web() {
+            egui::gui_zoom::zoom_with_keyboard_shortcuts(ctx, frame.info().native_pixels_per_point);
+        }
+    }
+
+    #[cfg(feature = "glow")]
+    fn on_exit(&mut self, gl: Option<&glow::Context>) {
+        if let Some(custom3d) = &mut self.custom3d {
+            custom3d.on_exit(gl);
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    fn as_any_mut(&mut self) -> Option<&mut dyn Any> {
+        Some(&mut *self)
+    }
+}
+
+impl WrapApp {
+    fn backend_panel(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        // The backend-panel can be toggled on/off.
+        // We show a little animation when the user switches it.
+        let is_open =
+            self.state.backend_panel.open || ctx.memory(|mem| mem.everything_is_visible());
+
+        egui::SidePanel::left("backend_panel")
+            .resizable(false)
+            .show_animated(ctx, is_open, |ui| {
+                ui.vertical_centered(|ui| {
+                    ui.heading("💻 Backend");
+                });
+
+                ui.separator();
+                self.backend_panel_contents(ui, frame);
+            });
+    }
+
+    fn backend_panel_contents(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
+        self.state.backend_panel.ui(ui, frame);
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            if ui
+                .button("Reset egui")
+                .on_hover_text("Forget scroll, positions, sizes etc")
+                .clicked()
+            {
+                ui.ctx().memory_mut(|mem| *mem = Default::default());
+                ui.close_menu();
+            }
+
+            if ui.button("Reset everything").clicked() {
+                self.state = Default::default();
+                ui.ctx().memory_mut(|mem| *mem = Default::default());
+                ui.close_menu();
+            }
+        });
+    }
+
+    fn show_selected_app(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        let selected_anchor = self.state.selected_anchor;
+        for (_name, anchor, app) in self.apps_iter_mut() {
+            if anchor == selected_anchor || ctx.memory(|mem| mem.everything_is_visible()) {
+                app.update(ctx, frame);
+            }
+        }
+    }
+
+    fn bar_contents(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
+        egui::widgets::global_dark_light_mode_switch(ui);
+
+        ui.separator();
+
+        if is_mobile(ui.ctx()) {
+            ui.menu_button("💻 Backend", |ui| {
+                ui.set_style(ui.ctx().style()); // ignore the "menu" style set by `menu_button`.
+                self.backend_panel_contents(ui, frame);
+            });
+        } else {
+            ui.toggle_value(&mut self.state.backend_panel.open, "💻 Backend");
+        }
+
+        ui.separator();
+
+        let mut selected_anchor = self.state.selected_anchor;
+        for (name, anchor, _app) in self.apps_iter_mut() {
+            if ui
+                .selectable_label(selected_anchor == anchor, name)
+                .clicked()
+            {
+                selected_anchor = anchor;
+                if frame.is_web() {
+                    ui.output_mut(|o| o.open_url(format!("#{}", anchor)));
+                }
+            }
+        }
+        self.state.selected_anchor = selected_anchor;
+
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if false {
+                // TODO(emilk): fix the overlap on small screens
+                if clock_button(ui, crate::seconds_since_midnight()).clicked() {
+                    self.state.selected_anchor = Anchor::Clock;
+                    if frame.is_web() {
+                        ui.output_mut(|o| o.open_url("#clock"));
+                    }
+                }
+            }
+
+            egui::warn_if_debug_build(ui);
+        });
+    }
+
+    fn ui_file_drag_and_drop(&mut self, ctx: &egui::Context) {
+        use egui::*;
+        use std::fmt::Write as _;
+
+        // Preview hovering files:
+        if !ctx.input(|i| i.raw.hovered_files.is_empty()) {
+            let text = ctx.input(|i| {
+                let mut text = "Dropping files:\n".to_owned();
+                for file in &i.raw.hovered_files {
+                    if let Some(path) = &file.path {
+                        write!(text, "\n{}", path.display()).ok();
+                    } else if !file.mime.is_empty() {
+                        write!(text, "\n{}", file.mime).ok();
+                    } else {
+                        text += "\n???";
+                    }
+                }
+                text
+            });
+
+            let painter =
+                ctx.layer_painter(LayerId::new(Order::Foreground, Id::new("file_drop_target")));
+
+            let screen_rect = ctx.screen_rect();
+            painter.rect_filled(screen_rect, 0.0, Color32::from_black_alpha(192));
+            painter.text(
+                screen_rect.center(),
+                Align2::CENTER_CENTER,
+                text,
+                TextStyle::Heading.resolve(&ctx.style()),
+                Color32::WHITE,
+            );
+        }
+
+        // Collect dropped files:
+        ctx.input(|i| {
+            if !i.raw.dropped_files.is_empty() {
+                self.dropped_files = i.raw.dropped_files.clone();
+            }
+        });
+
+        // Show dropped files (if any):
+        if !self.dropped_files.is_empty() {
+            let mut open = true;
+            egui::Window::new("Dropped files")
+                .open(&mut open)
+                .show(ctx, |ui| {
+                    for file in &self.dropped_files {
+                        let mut info = if let Some(path) = &file.path {
+                            path.display().to_string()
+                        } else if !file.name.is_empty() {
+                            file.name.clone()
+                        } else {
+                            "???".to_owned()
+                        };
+                        if let Some(bytes) = &file.bytes {
+                            write!(info, " ({} bytes)", bytes.len()).ok();
+                        }
+                        ui.label(info);
+                    }
+                });
+            if !open {
+                self.dropped_files.clear();
+            }
+        }
+    }
+}
+
+fn clock_button(ui: &mut egui::Ui, seconds_since_midnight: f64) -> egui::Response {
+    let time = seconds_since_midnight;
+    let time = format!(
+        "{:02}:{:02}:{:02}.{:02}",
+        (time % (24.0 * 60.0 * 60.0) / 3600.0).floor(),
+        (time % (60.0 * 60.0) / 60.0).floor(),
+        (time % 60.0).floor(),
+        (time % 1.0 * 100.0).floor()
+    );
+
+    ui.button(egui::RichText::new(time).monospace())
+}
diff --git a/egui/crates/egui_demo_lib/Cargo.toml b/egui/crates/egui_demo_lib/Cargo.toml
new file mode 100644
index 0000000..49be701
--- /dev/null
+++ b/egui/crates/egui_demo_lib/Cargo.toml
@@ -0,0 +1,55 @@
+[package]
+name = "egui_demo_lib"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "Example library for egui"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/egui_demo_lib"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/egui_demo_lib"
+categories = ["gui", "graphics"]
+keywords = ["glium", "egui", "gui", "gamedev"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = []
+
+chrono = ["egui_extras/datepicker", "dep:chrono"]
+## Allow serialization using [`serde`](https://docs.rs/serde).
+serde = ["egui/serde", "dep:serde"]
+## Enable better syntax highlighting using [`syntect`](https://docs.rs/syntect).
+syntax_highlighting = ["syntect"]
+
+
+[dependencies]
+egui = { version = "0.21.0", path = "../egui", default-features = false }
+egui_extras = { version = "0.21.0", path = "../egui_extras" }
+enum-map = { version = "2", features = ["serde"] }
+tracing = { version = "0.1", default-features = false, features = ["std"] }
+unicode_names2 = { version = "0.6.0", default-features = false }
+
+#! ### Optional dependencies
+chrono = { version = "0.4", optional = true, features = ["js-sys", "wasmbind"] }
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+serde = { version = "1", optional = true, features = ["derive"] }
+syntect = { version = "5", optional = true, default-features = false, features = [
+    "default-fancy",
+] }
+
+
+[dev-dependencies]
+criterion = { version = "0.4", default-features = false }
+
+
+[[bench]]
+name = "benchmark"
+harness = false
diff --git a/egui/crates/egui_demo_lib/README.md b/egui/crates/egui_demo_lib/README.md
new file mode 100644
index 0000000..43ca0a0
--- /dev/null
+++ b/egui/crates/egui_demo_lib/README.md
@@ -0,0 +1,16 @@
+# [`egui`](https://github.com/emilk/egui) demo library
+
+[![Latest version](https://img.shields.io/crates/v/egui_demo_lib.svg)](https://crates.io/crates/egui_demo_lib)
+[![Documentation](https://docs.rs/egui_demo_lib/badge.svg)](https://docs.rs/egui_demo_lib)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+This crate contains example code for [`egui`](https://github.com/emilk/egui).
+
+The demo library is a separate crate for three reasons:
+
+* To ensure it only uses the public `egui` api.
+* To remove the amount of code in `egui` proper.
+* To make it easy for 3rd party egui integrations to use it for tests.
+  - See for instance https://github.com/not-fl3/egui-miniquad/blob/master/examples/demo.rs
diff --git a/egui/crates/egui_demo_lib/benches/benchmark.rs b/egui/crates/egui_demo_lib/benches/benchmark.rs
new file mode 100644
index 0000000..dcc55ea
--- /dev/null
+++ b/egui/crates/egui_demo_lib/benches/benchmark.rs
@@ -0,0 +1,146 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+use egui::epaint::TextShape;
+use egui_demo_lib::LOREM_IPSUM_LONG;
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    use egui::RawInput;
+
+    {
+        let ctx = egui::Context::default();
+        let mut demo_windows = egui_demo_lib::DemoWindows::default();
+
+        // The most end-to-end benchmark.
+        c.bench_function("demo_with_tessellate__realistic", |b| {
+            b.iter(|| {
+                let full_output = ctx.run(RawInput::default(), |ctx| {
+                    demo_windows.ui(ctx);
+                });
+                ctx.tessellate(full_output.shapes)
+            });
+        });
+
+        c.bench_function("demo_no_tessellate", |b| {
+            b.iter(|| {
+                ctx.run(RawInput::default(), |ctx| {
+                    demo_windows.ui(ctx);
+                })
+            });
+        });
+
+        let full_output = ctx.run(RawInput::default(), |ctx| {
+            demo_windows.ui(ctx);
+        });
+        c.bench_function("demo_only_tessellate", |b| {
+            b.iter(|| ctx.tessellate(full_output.shapes.clone()));
+        });
+    }
+
+    if false {
+        let ctx = egui::Context::default();
+        ctx.memory_mut(|m| m.set_everything_is_visible(true)); // give us everything
+        let mut demo_windows = egui_demo_lib::DemoWindows::default();
+        c.bench_function("demo_full_no_tessellate", |b| {
+            b.iter(|| {
+                ctx.run(RawInput::default(), |ctx| {
+                    demo_windows.ui(ctx);
+                })
+            });
+        });
+    }
+
+    {
+        let ctx = egui::Context::default();
+        let _ = ctx.run(RawInput::default(), |ctx| {
+            egui::CentralPanel::default().show(ctx, |ui| {
+                c.bench_function("label &str", |b| {
+                    b.iter(|| {
+                        ui.label("the quick brown fox jumps over the lazy dog");
+                    });
+                });
+                c.bench_function("label format!", |b| {
+                    b.iter(|| {
+                        ui.label("the quick brown fox jumps over the lazy dog".to_owned());
+                    });
+                });
+            });
+        });
+    }
+
+    {
+        let ctx = egui::Context::default();
+        ctx.begin_frame(RawInput::default());
+
+        egui::CentralPanel::default().show(&ctx, |ui| {
+            c.bench_function("Painter::rect", |b| {
+                let painter = ui.painter();
+                let rect = ui.max_rect();
+                b.iter(|| {
+                    painter.rect(rect, 2.0, egui::Color32::RED, (1.0, egui::Color32::WHITE));
+                });
+            });
+        });
+
+        // Don't call `end_frame` to not have to drain the huge paint list
+    }
+
+    {
+        let pixels_per_point = 1.0;
+        let max_texture_side = 8 * 1024;
+        let wrap_width = 512.0;
+        let font_id = egui::FontId::default();
+        let color = egui::Color32::WHITE;
+        let fonts = egui::epaint::text::Fonts::new(
+            pixels_per_point,
+            max_texture_side,
+            egui::FontDefinitions::default(),
+        );
+        {
+            let mut locked_fonts = fonts.lock();
+            c.bench_function("text_layout_uncached", |b| {
+                b.iter(|| {
+                    use egui::epaint::text::{layout, LayoutJob};
+
+                    let job = LayoutJob::simple(
+                        LOREM_IPSUM_LONG.to_owned(),
+                        font_id.clone(),
+                        color,
+                        wrap_width,
+                    );
+                    layout(&mut locked_fonts.fonts, job.into())
+                });
+            });
+        }
+        c.bench_function("text_layout_cached", |b| {
+            b.iter(|| {
+                fonts.layout(
+                    LOREM_IPSUM_LONG.to_owned(),
+                    font_id.clone(),
+                    color,
+                    wrap_width,
+                )
+            });
+        });
+
+        let galley = fonts.layout(LOREM_IPSUM_LONG.to_owned(), font_id, color, wrap_width);
+        let font_image_size = fonts.font_image_size();
+        let prepared_discs = fonts.texture_atlas().lock().prepared_discs();
+        let mut tessellator = egui::epaint::Tessellator::new(
+            1.0,
+            Default::default(),
+            font_image_size,
+            prepared_discs,
+        );
+        let mut mesh = egui::epaint::Mesh::default();
+        let text_shape = TextShape::new(egui::Pos2::ZERO, galley);
+        c.bench_function("tessellate_text", |b| {
+            b.iter(|| {
+                tessellator.tessellate_text(&text_shape, &mut mesh);
+                mesh.clear();
+            });
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/egui/crates/egui_demo_lib/src/color_test.rs b/egui/crates/egui_demo_lib/src/color_test.rs
new file mode 100644
index 0000000..9f209f9
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/color_test.rs
@@ -0,0 +1,559 @@
+use std::collections::HashMap;
+
+use egui::{widgets::color_picker::show_color, TextureOptions, *};
+
+const GRADIENT_SIZE: Vec2 = vec2(256.0, 18.0);
+
+const BLACK: Color32 = Color32::BLACK;
+const GREEN: Color32 = Color32::GREEN;
+const RED: Color32 = Color32::RED;
+const TRANSPARENT: Color32 = Color32::TRANSPARENT;
+const WHITE: Color32 = Color32::WHITE;
+
+/// A test for sanity-checking and diagnosing egui rendering backends.
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ColorTest {
+    #[cfg_attr(feature = "serde", serde(skip))]
+    tex_mngr: TextureManager,
+    vertex_gradients: bool,
+    texture_gradients: bool,
+}
+
+impl Default for ColorTest {
+    fn default() -> Self {
+        Self {
+            tex_mngr: Default::default(),
+            vertex_gradients: true,
+            texture_gradients: true,
+        }
+    }
+}
+
+impl ColorTest {
+    pub fn ui(&mut self, ui: &mut Ui) {
+        ui.set_max_width(680.0);
+
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+
+        ui.horizontal_wrapped(|ui|{
+            ui.label("This is made to test that the egui painter backend is set up correctly.");
+            ui.add(egui::Label::new("❓").sense(egui::Sense::click()))
+                .on_hover_text("The texture sampling should be sRGB-aware, and every other color operation should be done in gamma-space (sRGB). All colors should use pre-multiplied alpha");
+        });
+        ui.label("If the rendering is done right, all groups of gradients will look uniform.");
+
+        ui.horizontal(|ui| {
+            ui.checkbox(&mut self.vertex_gradients, "Vertex gradients");
+            ui.checkbox(&mut self.texture_gradients, "Texture gradients");
+        });
+
+        ui.heading("sRGB color test");
+        ui.label("Use a color picker to ensure this color is (255, 165, 0) / #ffa500");
+        ui.scope(|ui| {
+            ui.spacing_mut().item_spacing.y = 0.0; // No spacing between gradients
+            let g = Gradient::one_color(Color32::from_rgb(255, 165, 0));
+            self.vertex_gradient(ui, "orange rgb(255, 165, 0) - vertex", WHITE, &g);
+            self.tex_gradient(ui, "orange rgb(255, 165, 0) - texture", WHITE, &g);
+        });
+
+        ui.separator();
+
+        ui.label("Test that vertex color times texture color is done in gamma space:");
+        ui.scope(|ui| {
+            ui.spacing_mut().item_spacing.y = 0.0; // No spacing between gradients
+
+            let tex_color = Color32::from_rgb(64, 128, 255);
+            let vertex_color = Color32::from_rgb(128, 196, 196);
+            let ground_truth = mul_color_gamma(tex_color, vertex_color);
+
+            ui.horizontal(|ui| {
+                let color_size = ui.spacing().interact_size;
+                ui.label("texture");
+                show_color(ui, tex_color, color_size);
+                ui.label(" * ");
+                show_color(ui, vertex_color, color_size);
+                ui.label(" vertex color =");
+            });
+            {
+                let g = Gradient::one_color(ground_truth);
+                self.vertex_gradient(ui, "Ground truth (vertices)", WHITE, &g);
+                self.tex_gradient(ui, "Ground truth (texture)", WHITE, &g);
+            }
+
+            ui.horizontal(|ui| {
+                let g = Gradient::one_color(tex_color);
+                let tex = self.tex_mngr.get(ui.ctx(), &g);
+                let texel_offset = 0.5 / (g.0.len() as f32);
+                let uv = Rect::from_min_max(pos2(texel_offset, 0.0), pos2(1.0 - texel_offset, 1.0));
+                ui.add(Image::new(tex, GRADIENT_SIZE).tint(vertex_color).uv(uv))
+                    .on_hover_text(format!("A texture that is {} texels wide", g.0.len()));
+                ui.label("GPU result");
+            });
+        });
+
+        ui.separator();
+
+        // TODO(emilk): test color multiplication (image tint),
+        // to make sure vertex and texture color multiplication is done in linear space.
+
+        ui.label("Gamma interpolation:");
+        self.show_gradients(ui, WHITE, (RED, GREEN), Interpolation::Gamma);
+
+        ui.separator();
+
+        self.show_gradients(ui, RED, (TRANSPARENT, GREEN), Interpolation::Gamma);
+
+        ui.separator();
+
+        self.show_gradients(ui, WHITE, (TRANSPARENT, GREEN), Interpolation::Gamma);
+
+        ui.separator();
+
+        self.show_gradients(ui, BLACK, (BLACK, WHITE), Interpolation::Gamma);
+        ui.separator();
+        self.show_gradients(ui, WHITE, (BLACK, TRANSPARENT), Interpolation::Gamma);
+        ui.separator();
+        self.show_gradients(ui, BLACK, (TRANSPARENT, WHITE), Interpolation::Gamma);
+        ui.separator();
+
+        ui.label("Additive blending: add more and more blue to the red background:");
+        self.show_gradients(
+            ui,
+            RED,
+            (TRANSPARENT, Color32::from_rgb_additive(0, 0, 255)),
+            Interpolation::Gamma,
+        );
+
+        ui.separator();
+
+        ui.label("Linear interpolation (texture sampling):");
+        self.show_gradients(ui, WHITE, (RED, GREEN), Interpolation::Linear);
+
+        ui.separator();
+
+        pixel_test(ui);
+
+        ui.separator();
+        ui.label("Testing text rendering:");
+
+        text_on_bg(ui, Color32::from_gray(200), Color32::from_gray(230)); // gray on gray
+        text_on_bg(ui, Color32::from_gray(140), Color32::from_gray(28)); // dark mode normal text
+
+        // Matches Mac Font book (useful for testing):
+        text_on_bg(ui, Color32::from_gray(39), Color32::from_gray(255));
+        text_on_bg(ui, Color32::from_gray(220), Color32::from_gray(30));
+
+        ui.separator();
+
+        blending_and_feathering_test(ui);
+    }
+
+    fn show_gradients(
+        &mut self,
+        ui: &mut Ui,
+        bg_fill: Color32,
+        (left, right): (Color32, Color32),
+        interpolation: Interpolation,
+    ) {
+        let is_opaque = left.is_opaque() && right.is_opaque();
+
+        ui.horizontal(|ui| {
+            let color_size = ui.spacing().interact_size;
+            if !is_opaque {
+                ui.label("Background:");
+                show_color(ui, bg_fill, color_size);
+            }
+            ui.label("gradient");
+            show_color(ui, left, color_size);
+            ui.label("-");
+            show_color(ui, right, color_size);
+        });
+
+        ui.scope(|ui| {
+            ui.spacing_mut().item_spacing.y = 0.0; // No spacing between gradients
+            if is_opaque {
+                let g = Gradient::ground_truth_gradient(left, right, interpolation);
+                self.vertex_gradient(ui, "Ground Truth (CPU gradient) - vertices", bg_fill, &g);
+                self.tex_gradient(ui, "Ground Truth (CPU gradient) - texture", bg_fill, &g);
+            } else {
+                let g = Gradient::ground_truth_gradient(left, right, interpolation)
+                    .with_bg_fill(bg_fill);
+                self.vertex_gradient(
+                    ui,
+                    "Ground Truth (CPU gradient, CPU blending) - vertices",
+                    bg_fill,
+                    &g,
+                );
+                self.tex_gradient(
+                    ui,
+                    "Ground Truth (CPU gradient, CPU blending) - texture",
+                    bg_fill,
+                    &g,
+                );
+                let g = Gradient::ground_truth_gradient(left, right, interpolation);
+                self.vertex_gradient(ui, "CPU gradient, GPU blending - vertices", bg_fill, &g);
+                self.tex_gradient(ui, "CPU gradient, GPU blending - texture", bg_fill, &g);
+            }
+
+            let g = Gradient::endpoints(left, right);
+
+            match interpolation {
+                Interpolation::Linear => {
+                    // texture sampler is sRGBA aware, and should therefore be linear
+                    self.tex_gradient(ui, "Texture of width 2 (test texture sampler)", bg_fill, &g);
+                }
+                Interpolation::Gamma => {
+                    // vertex shader uses gamma
+                    self.vertex_gradient(
+                        ui,
+                        "Triangle mesh of width 2 (test vertex decode and interpolation)",
+                        bg_fill,
+                        &g,
+                    );
+                }
+            }
+        });
+    }
+
+    fn tex_gradient(&mut self, ui: &mut Ui, label: &str, bg_fill: Color32, gradient: &Gradient) {
+        if !self.texture_gradients {
+            return;
+        }
+        ui.horizontal(|ui| {
+            let tex = self.tex_mngr.get(ui.ctx(), gradient);
+            let texel_offset = 0.5 / (gradient.0.len() as f32);
+            let uv = Rect::from_min_max(pos2(texel_offset, 0.0), pos2(1.0 - texel_offset, 1.0));
+            ui.add(Image::new(tex, GRADIENT_SIZE).bg_fill(bg_fill).uv(uv))
+                .on_hover_text(format!(
+                    "A texture that is {} texels wide",
+                    gradient.0.len()
+                ));
+            ui.label(label);
+        });
+    }
+
+    fn vertex_gradient(&mut self, ui: &mut Ui, label: &str, bg_fill: Color32, gradient: &Gradient) {
+        if !self.vertex_gradients {
+            return;
+        }
+        ui.horizontal(|ui| {
+            vertex_gradient(ui, bg_fill, gradient).on_hover_text(format!(
+                "A triangle mesh that is {} vertices wide",
+                gradient.0.len()
+            ));
+            ui.label(label);
+        });
+    }
+}
+
+fn vertex_gradient(ui: &mut Ui, bg_fill: Color32, gradient: &Gradient) -> Response {
+    use egui::epaint::*;
+    let (rect, response) = ui.allocate_at_least(GRADIENT_SIZE, Sense::hover());
+    if bg_fill != Default::default() {
+        let mut mesh = Mesh::default();
+        mesh.add_colored_rect(rect, bg_fill);
+        ui.painter().add(Shape::mesh(mesh));
+    }
+    {
+        let n = gradient.0.len();
+        assert!(n >= 2);
+        let mut mesh = Mesh::default();
+        for (i, &color) in gradient.0.iter().enumerate() {
+            let t = i as f32 / (n as f32 - 1.0);
+            let x = lerp(rect.x_range(), t);
+            mesh.colored_vertex(pos2(x, rect.top()), color);
+            mesh.colored_vertex(pos2(x, rect.bottom()), color);
+            if i < n - 1 {
+                let i = i as u32;
+                mesh.add_triangle(2 * i, 2 * i + 1, 2 * i + 2);
+                mesh.add_triangle(2 * i + 1, 2 * i + 2, 2 * i + 3);
+            }
+        }
+        ui.painter().add(Shape::mesh(mesh));
+    }
+    response
+}
+
+#[derive(Clone, Copy)]
+enum Interpolation {
+    Linear,
+    Gamma,
+}
+
+#[derive(Clone, Hash, PartialEq, Eq)]
+struct Gradient(pub Vec<Color32>);
+
+impl Gradient {
+    pub fn one_color(srgba: Color32) -> Self {
+        Self(vec![srgba, srgba])
+    }
+
+    pub fn endpoints(left: Color32, right: Color32) -> Self {
+        Self(vec![left, right])
+    }
+
+    pub fn ground_truth_gradient(
+        left: Color32,
+        right: Color32,
+        interpolation: Interpolation,
+    ) -> Self {
+        match interpolation {
+            Interpolation::Linear => Self::ground_truth_linear_gradient(left, right),
+            Interpolation::Gamma => Self::ground_truth_gamma_gradient(left, right),
+        }
+    }
+
+    pub fn ground_truth_linear_gradient(left: Color32, right: Color32) -> Self {
+        let left = Rgba::from(left);
+        let right = Rgba::from(right);
+
+        let n = 255;
+        Self(
+            (0..=n)
+                .map(|i| {
+                    let t = i as f32 / n as f32;
+                    Color32::from(lerp(left..=right, t))
+                })
+                .collect(),
+        )
+    }
+
+    pub fn ground_truth_gamma_gradient(left: Color32, right: Color32) -> Self {
+        let n = 255;
+        Self(
+            (0..=n)
+                .map(|i| {
+                    let t = i as f32 / n as f32;
+                    lerp_color_gamma(left, right, t)
+                })
+                .collect(),
+        )
+    }
+
+    /// Do premultiplied alpha-aware blending of the gradient on top of the fill color
+    /// in gamma-space.
+    pub fn with_bg_fill(self, bg: Color32) -> Self {
+        Self(
+            self.0
+                .into_iter()
+                .map(|fg| {
+                    let a = fg.a() as f32 / 255.0;
+                    Color32::from_rgba_premultiplied(
+                        (bg[0] as f32 * (1.0 - a) + fg[0] as f32).round() as u8,
+                        (bg[1] as f32 * (1.0 - a) + fg[1] as f32).round() as u8,
+                        (bg[2] as f32 * (1.0 - a) + fg[2] as f32).round() as u8,
+                        (bg[3] as f32 * (1.0 - a) + fg[3] as f32).round() as u8,
+                    )
+                })
+                .collect(),
+        )
+    }
+
+    pub fn to_pixel_row(&self) -> Vec<Color32> {
+        self.0.clone()
+    }
+}
+
+#[derive(Default)]
+struct TextureManager(HashMap<Gradient, TextureHandle>);
+
+impl TextureManager {
+    fn get(&mut self, ctx: &egui::Context, gradient: &Gradient) -> &TextureHandle {
+        self.0.entry(gradient.clone()).or_insert_with(|| {
+            let pixels = gradient.to_pixel_row();
+            let width = pixels.len();
+            let height = 1;
+            ctx.load_texture(
+                "color_test_gradient",
+                epaint::ColorImage {
+                    size: [width, height],
+                    pixels,
+                },
+                TextureOptions::LINEAR,
+            )
+        })
+    }
+}
+
+fn pixel_test(ui: &mut Ui) {
+    ui.label("Each subsequent square should be one physical pixel larger than the previous. They should be exactly one physical pixel apart. They should be perfectly aligned to the pixel grid.");
+
+    let color = if ui.style().visuals.dark_mode {
+        egui::Color32::WHITE
+    } else {
+        egui::Color32::BLACK
+    };
+
+    let pixels_per_point = ui.ctx().pixels_per_point();
+    let num_squares: u32 = 8;
+    let size_pixels = vec2(
+        ((num_squares + 1) * (num_squares + 2) / 2) as f32,
+        num_squares as f32,
+    );
+    let size_points = size_pixels / pixels_per_point + Vec2::splat(2.0);
+    let (response, painter) = ui.allocate_painter(size_points, Sense::hover());
+
+    let mut cursor_pixel = Pos2::new(
+        response.rect.min.x * pixels_per_point,
+        response.rect.min.y * pixels_per_point,
+    )
+    .ceil();
+    for size in 1..=num_squares {
+        let rect_points = Rect::from_min_size(
+            Pos2::new(
+                cursor_pixel.x / pixels_per_point,
+                cursor_pixel.y / pixels_per_point,
+            ),
+            Vec2::splat(size as f32) / pixels_per_point,
+        );
+        painter.rect_filled(rect_points, 0.0, color);
+        cursor_pixel.x += (1 + size) as f32;
+    }
+}
+
+fn blending_and_feathering_test(ui: &mut Ui) {
+    let size = vec2(512.0, 512.0);
+    let (response, painter) = ui.allocate_painter(size, Sense::hover());
+    let rect = response.rect;
+
+    let mut top_half = rect;
+    top_half.set_bottom(top_half.center().y);
+    painter.rect_filled(top_half, 0.0, Color32::BLACK);
+    paint_fine_lines_and_text(&painter, top_half, Color32::WHITE);
+
+    let mut bottom_half = rect;
+    bottom_half.set_top(bottom_half.center().y);
+    painter.rect_filled(bottom_half, 0.0, Color32::WHITE);
+    paint_fine_lines_and_text(&painter, bottom_half, Color32::BLACK);
+}
+
+fn text_on_bg(ui: &mut egui::Ui, fg: Color32, bg: Color32) {
+    assert!(fg.is_opaque());
+    assert!(bg.is_opaque());
+
+    ui.horizontal(|ui| {
+        ui.label(
+            RichText::from("▣ The quick brown fox jumps over the lazy dog and runs away.")
+                .background_color(bg)
+                .color(fg),
+        );
+        ui.label(format!(
+            "({} {} {}) on ({} {} {})",
+            fg.r(),
+            fg.g(),
+            fg.b(),
+            bg.r(),
+            bg.g(),
+            bg.b(),
+        ));
+    });
+}
+
+fn paint_fine_lines_and_text(painter: &egui::Painter, mut rect: Rect, color: Color32) {
+    {
+        let mut y = 0.0;
+        for opacity in [1.00, 0.50, 0.25, 0.10, 0.05, 0.02, 0.01, 0.00] {
+            painter.text(
+                rect.center_top() + vec2(0.0, y),
+                Align2::LEFT_TOP,
+                format!("{:.0}% white", 100.0 * opacity),
+                FontId::proportional(14.0),
+                Color32::WHITE.gamma_multiply(opacity),
+            );
+            painter.text(
+                rect.center_top() + vec2(80.0, y),
+                Align2::LEFT_TOP,
+                format!("{:.0}% gray", 100.0 * opacity),
+                FontId::proportional(14.0),
+                Color32::GRAY.gamma_multiply(opacity),
+            );
+            painter.text(
+                rect.center_top() + vec2(160.0, y),
+                Align2::LEFT_TOP,
+                format!("{:.0}% black", 100.0 * opacity),
+                FontId::proportional(14.0),
+                Color32::BLACK.gamma_multiply(opacity),
+            );
+            y += 20.0;
+        }
+
+        for font_size in [6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 14.0] {
+            painter.text(
+                rect.center_top() + vec2(0.0, y),
+                Align2::LEFT_TOP,
+                format!(
+                    "{font_size}px - The quick brown fox jumps over the lazy dog and runs away."
+                ),
+                FontId::proportional(font_size),
+                color,
+            );
+            y += font_size + 1.0;
+        }
+    }
+
+    rect.max.x = rect.center().x;
+
+    rect = rect.shrink(16.0);
+    for width in [0.05, 0.1, 0.25, 0.5, 1.0, 2.0, 4.0] {
+        painter.text(
+            rect.left_top(),
+            Align2::CENTER_CENTER,
+            width.to_string(),
+            FontId::monospace(12.0),
+            color,
+        );
+
+        painter.add(egui::epaint::CubicBezierShape::from_points_stroke(
+            [
+                rect.left_top() + vec2(16.0, 0.0),
+                rect.right_top(),
+                rect.right_center(),
+                rect.right_bottom(),
+            ],
+            false,
+            Color32::TRANSPARENT,
+            Stroke::new(width, color),
+        ));
+
+        rect.min.y += 24.0;
+        rect.max.x -= 24.0;
+    }
+
+    rect.min.y += 16.0;
+    painter.text(
+        rect.left_top(),
+        Align2::LEFT_CENTER,
+        "transparent --> opaque",
+        FontId::monospace(10.0),
+        color,
+    );
+    rect.min.y += 12.0;
+    let mut mesh = Mesh::default();
+    mesh.colored_vertex(rect.left_bottom(), Color32::TRANSPARENT);
+    mesh.colored_vertex(rect.left_top(), Color32::TRANSPARENT);
+    mesh.colored_vertex(rect.right_bottom(), color);
+    mesh.colored_vertex(rect.right_top(), color);
+    mesh.add_triangle(0, 1, 2);
+    mesh.add_triangle(1, 2, 3);
+    painter.add(mesh);
+}
+
+fn mul_color_gamma(left: Color32, right: Color32) -> Color32 {
+    Color32::from_rgba_premultiplied(
+        (left.r() as f32 * right.r() as f32 / 255.0).round() as u8,
+        (left.g() as f32 * right.g() as f32 / 255.0).round() as u8,
+        (left.b() as f32 * right.b() as f32 / 255.0).round() as u8,
+        (left.a() as f32 * right.a() as f32 / 255.0).round() as u8,
+    )
+}
+
+fn lerp_color_gamma(left: Color32, right: Color32, t: f32) -> Color32 {
+    Color32::from_rgba_premultiplied(
+        lerp((left[0] as f32)..=(right[0] as f32), t).round() as u8,
+        lerp((left[1] as f32)..=(right[1] as f32), t).round() as u8,
+        lerp((left[2] as f32)..=(right[2] as f32), t).round() as u8,
+        lerp((left[3] as f32)..=(right[3] as f32), t).round() as u8,
+    )
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/about.rs b/egui/crates/egui_demo_lib/src/demo/about.rs
new file mode 100644
index 0000000..0fbb976
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/about.rs
@@ -0,0 +1,94 @@
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct About {}
+
+impl super::Demo for About {
+    fn name(&self) -> &'static str {
+        "About egui"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .default_width(320.0)
+            .open(open)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for About {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        use egui::special_emojis::{OS_APPLE, OS_LINUX, OS_WINDOWS};
+
+        ui.heading("egui");
+        ui.label(format!(
+            "egui is an immediate mode GUI library written in Rust. egui runs both on the web and natively on {}{}{}. \
+            On the web it is compiled to WebAssembly and rendered with WebGL.{}",
+            OS_APPLE, OS_LINUX, OS_WINDOWS,
+            if cfg!(target_arch = "wasm32") {
+                " Everything you see is rendered as textured triangles. There is no DOM, HTML, JS or CSS. Just Rust."
+            } else {""}
+        ));
+        ui.label("egui is designed to be easy to use, portable, and fast.");
+
+        ui.add_space(12.0); // ui.separator();
+        ui.heading("Immediate mode");
+        about_immediate_mode(ui);
+
+        ui.add_space(12.0); // ui.separator();
+        ui.heading("Links");
+        links(ui);
+    }
+}
+
+fn about_immediate_mode(ui: &mut egui::Ui) {
+    use crate::syntax_highlighting::code_view_ui;
+    ui.style_mut().spacing.interact_size.y = 0.0; // hack to make `horizontal_wrapped` work better with text.
+
+    ui.horizontal_wrapped(|ui| {
+            ui.spacing_mut().item_spacing.x = 0.0;
+            ui.label("Immediate mode is a GUI paradigm that lets you create a GUI with less code and simpler control flow. For example, this is how you create a ");
+            let _ = ui.small_button("button");
+            ui.label(" in egui:");
+        });
+
+    ui.add_space(8.0);
+    code_view_ui(
+        ui,
+        r#"
+  if ui.button("Save").clicked() {
+      my_state.save();
+  }"#
+        .trim_start_matches('\n'),
+    );
+    ui.add_space(8.0);
+
+    ui.label("Note how there are no callbacks or messages, and no button state to store.");
+
+    ui.label("Immediate mode has its roots in gaming, where everything on the screen is painted at the display refresh rate, i.e. at 60+ frames per second. \
+        In immediate mode GUIs, the entire interface is laid out and painted at the same high rate. \
+        This makes immediate mode GUIs especially well suited for highly interactive applications.");
+
+    ui.horizontal_wrapped(|ui| {
+        ui.spacing_mut().item_spacing.x = 0.0;
+        ui.label("More about immediate mode ");
+        ui.hyperlink_to("here", "https://github.com/emilk/egui#why-immediate-mode");
+        ui.label(".");
+    });
+}
+
+fn links(ui: &mut egui::Ui) {
+    use egui::special_emojis::{GITHUB, TWITTER};
+    ui.hyperlink_to(
+        format!("{} egui on GitHub", GITHUB),
+        "https://github.com/emilk/egui",
+    );
+    ui.hyperlink_to(
+        format!("{} @ernerfeldt", TWITTER),
+        "https://twitter.com/ernerfeldt",
+    );
+    ui.hyperlink_to("egui documentation", "https://docs.rs/egui/");
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/code_editor.rs b/egui/crates/egui_demo_lib/src/demo/code_editor.rs
new file mode 100644
index 0000000..e9632a2
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/code_editor.rs
@@ -0,0 +1,97 @@
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct CodeEditor {
+    language: String,
+    code: String,
+}
+
+impl Default for CodeEditor {
+    fn default() -> Self {
+        Self {
+            language: "rs".into(),
+            code: "// A very simple example\n\
+fn main() {\n\
+\tprintln!(\"Hello world!\");\n\
+}\n\
+"
+            .into(),
+        }
+    }
+}
+
+impl super::Demo for CodeEditor {
+    fn name(&self) -> &'static str {
+        "🖮 Code Editor"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        use super::View as _;
+        egui::Window::new(self.name())
+            .open(open)
+            .default_height(500.0)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for CodeEditor {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        let Self { language, code } = self;
+
+        ui.horizontal(|ui| {
+            ui.set_height(0.0);
+            ui.label("An example of syntax highlighting in a TextEdit.");
+            ui.add(crate::egui_github_link_file!());
+        });
+
+        if cfg!(feature = "syntect") {
+            ui.horizontal(|ui| {
+                ui.label("Language:");
+                ui.text_edit_singleline(language);
+            });
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("Syntax highlighting powered by ");
+                ui.hyperlink_to("syntect", "https://github.com/trishume/syntect");
+                ui.label(".");
+            });
+        } else {
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("Compile the demo with the ");
+                ui.code("syntax_highlighting");
+                ui.label(" feature to enable more accurate syntax highlighting using ");
+                ui.hyperlink_to("syntect", "https://github.com/trishume/syntect");
+                ui.label(".");
+            });
+        }
+
+        let mut theme = crate::syntax_highlighting::CodeTheme::from_memory(ui.ctx());
+        ui.collapsing("Theme", |ui| {
+            ui.group(|ui| {
+                theme.ui(ui);
+                theme.clone().store_in_memory(ui.ctx());
+            });
+        });
+
+        let mut layouter = |ui: &egui::Ui, string: &str, wrap_width: f32| {
+            let mut layout_job =
+                crate::syntax_highlighting::highlight(ui.ctx(), &theme, string, language);
+            layout_job.wrap.max_width = wrap_width;
+            ui.fonts(|f| f.layout_job(layout_job))
+        };
+
+        egui::ScrollArea::vertical().show(ui, |ui| {
+            ui.add(
+                egui::TextEdit::multiline(code)
+                    .font(egui::TextStyle::Monospace) // for cursor height
+                    .code_editor()
+                    .desired_rows(10)
+                    .lock_focus(true)
+                    .desired_width(f32::INFINITY)
+                    .layouter(&mut layouter),
+            );
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/code_example.rs b/egui/crates/egui_demo_lib/src/demo/code_example.rs
new file mode 100644
index 0000000..c72fde2
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/code_example.rs
@@ -0,0 +1,161 @@
+#[derive(Debug)]
+pub struct CodeExample {
+    name: String,
+    age: u32,
+}
+
+impl Default for CodeExample {
+    fn default() -> Self {
+        Self {
+            name: "Arthur".to_owned(),
+            age: 42,
+        }
+    }
+}
+
+impl CodeExample {
+    fn samples_in_grid(&mut self, ui: &mut egui::Ui) {
+        show_code(ui, r#"ui.heading("Code samples");"#);
+        ui.heading("Code samples");
+        ui.end_row();
+
+        show_code(
+            ui,
+            r#"
+            // Putting things on the same line using ui.horizontal:
+            ui.horizontal(|ui| {
+                ui.label("Your name: ");
+                ui.text_edit_singleline(&mut self.name);
+            });"#,
+        );
+        // Putting things on the same line using ui.horizontal:
+        ui.horizontal(|ui| {
+            ui.label("Your name: ");
+            ui.text_edit_singleline(&mut self.name);
+        });
+        ui.end_row();
+
+        show_code(
+            ui,
+            r#"egui::Slider::new(&mut self.age, 0..=120).text("age")"#,
+        );
+        ui.add(egui::Slider::new(&mut self.age, 0..=120).text("age"));
+        ui.end_row();
+
+        show_code(
+            ui,
+            r#"
+            if ui.button("Click each year").clicked() {
+                self.age += 1;
+            }"#,
+        );
+        if ui.button("Click each year").clicked() {
+            self.age += 1;
+        }
+        ui.end_row();
+
+        show_code(
+            ui,
+            r#"ui.label(format!("Hello '{}', age {}", self.name, self.age));"#,
+        );
+        ui.label(format!("Hello '{}', age {}", self.name, self.age));
+        ui.end_row();
+    }
+}
+
+impl super::Demo for CodeExample {
+    fn name(&self) -> &'static str {
+        "🖮 Code Example"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        use super::View;
+        egui::Window::new(self.name())
+            .open(open)
+            .default_size([800.0, 400.0])
+            .vscroll(false)
+            .hscroll(true)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for CodeExample {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        use crate::syntax_highlighting::code_view_ui;
+
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+
+        code_view_ui(
+            ui,
+            r"
+pub struct CodeExample {
+    name: String,
+    age: u32,
+}
+
+impl CodeExample {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+"
+            .trim(),
+        );
+
+        ui.horizontal(|ui| {
+            let font_id = egui::TextStyle::Monospace.resolve(ui.style());
+            let indentation = 8.0 * ui.fonts(|f| f.glyph_width(&font_id, ' '));
+            let item_spacing = ui.spacing_mut().item_spacing;
+            ui.add_space(indentation - item_spacing.x);
+
+            egui::Grid::new("code_samples")
+                .striped(true)
+                .num_columns(2)
+                .min_col_width(16.0)
+                .spacing([16.0, 8.0])
+                .show(ui, |ui| {
+                    self.samples_in_grid(ui);
+                });
+        });
+
+        code_view_ui(ui, "    }\n}");
+
+        ui.separator();
+
+        code_view_ui(ui, &format!("{:#?}", self));
+
+        ui.separator();
+
+        let mut theme = crate::syntax_highlighting::CodeTheme::from_memory(ui.ctx());
+        ui.collapsing("Theme", |ui| {
+            theme.ui(ui);
+            theme.store_in_memory(ui.ctx());
+        });
+    }
+}
+
+fn show_code(ui: &mut egui::Ui, code: &str) {
+    let code = remove_leading_indentation(code.trim_start_matches('\n'));
+    crate::syntax_highlighting::code_view_ui(ui, &code);
+}
+
+fn remove_leading_indentation(code: &str) -> String {
+    fn is_indent(c: &u8) -> bool {
+        matches!(*c, b' ' | b'\t')
+    }
+
+    let first_line_indent = code.bytes().take_while(is_indent).count();
+
+    let mut out = String::new();
+
+    let mut code = code;
+    while !code.is_empty() {
+        let indent = code.bytes().take_while(is_indent).count();
+        let start = first_line_indent.min(indent);
+        let end = code
+            .find('\n')
+            .map_or_else(|| code.len(), |endline| endline + 1);
+        out += &code[start..end];
+        code = &code[end..];
+    }
+    out
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/context_menu.rs b/egui/crates/egui_demo_lib/src/demo/context_menu.rs
new file mode 100644
index 0000000..f8b6bc5
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/context_menu.rs
@@ -0,0 +1,182 @@
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+enum Plot {
+    Sin,
+    Bell,
+    Sigmoid,
+}
+
+fn gaussian(x: f64) -> f64 {
+    let var: f64 = 2.0;
+    f64::exp(-(x / var).powi(2)) / (var * f64::sqrt(std::f64::consts::TAU))
+}
+
+fn sigmoid(x: f64) -> f64 {
+    -1.0 + 2.0 / (1.0 + f64::exp(-x))
+}
+
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ContextMenus {
+    plot: Plot,
+    show_axes: [bool; 2],
+    allow_drag: bool,
+    allow_zoom: bool,
+    allow_scroll: bool,
+    center_x_axis: bool,
+    center_y_axis: bool,
+    width: f32,
+    height: f32,
+}
+
+impl Default for ContextMenus {
+    fn default() -> Self {
+        Self {
+            plot: Plot::Sin,
+            show_axes: [true, true],
+            allow_drag: true,
+            allow_zoom: true,
+            allow_scroll: true,
+            center_x_axis: false,
+            center_y_axis: false,
+            width: 400.0,
+            height: 200.0,
+        }
+    }
+}
+
+impl super::Demo for ContextMenus {
+    fn name(&self) -> &'static str {
+        "☰ Context Menus"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        use super::View;
+        egui::Window::new(self.name())
+            .vscroll(false)
+            .resizable(false)
+            .open(open)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for ContextMenus {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.menu_button("Click for menu", Self::nested_menus);
+            ui.button("Right-click for menu")
+                .context_menu(Self::nested_menus);
+        });
+
+        ui.separator();
+
+        ui.label("Right-click plot to edit it!");
+        ui.horizontal(|ui| {
+            self.example_plot(ui).context_menu(|ui| {
+                ui.menu_button("Plot", |ui| {
+                    if ui.radio_value(&mut self.plot, Plot::Sin, "Sin").clicked()
+                        || ui
+                            .radio_value(&mut self.plot, Plot::Bell, "Gaussian")
+                            .clicked()
+                        || ui
+                            .radio_value(&mut self.plot, Plot::Sigmoid, "Sigmoid")
+                            .clicked()
+                    {
+                        ui.close_menu();
+                    }
+                });
+                egui::Grid::new("button_grid").show(ui, |ui| {
+                    ui.add(
+                        egui::DragValue::new(&mut self.width)
+                            .speed(1.0)
+                            .prefix("Width:"),
+                    );
+                    ui.add(
+                        egui::DragValue::new(&mut self.height)
+                            .speed(1.0)
+                            .prefix("Height:"),
+                    );
+                    ui.end_row();
+                    ui.checkbox(&mut self.show_axes[0], "x-Axis");
+                    ui.checkbox(&mut self.show_axes[1], "y-Axis");
+                    ui.end_row();
+                    if ui.checkbox(&mut self.allow_drag, "Drag").changed()
+                        || ui.checkbox(&mut self.allow_zoom, "Zoom").changed()
+                        || ui.checkbox(&mut self.allow_scroll, "Scroll").changed()
+                    {
+                        ui.close_menu();
+                    }
+                });
+            });
+        });
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
+
+impl ContextMenus {
+    fn example_plot(&self, ui: &mut egui::Ui) -> egui::Response {
+        use egui::plot::{Line, PlotPoints};
+        let n = 128;
+        let line = Line::new(
+            (0..=n)
+                .map(|i| {
+                    use std::f64::consts::TAU;
+                    let x = egui::remap(i as f64, 0.0..=n as f64, -TAU..=TAU);
+                    match self.plot {
+                        Plot::Sin => [x, x.sin()],
+                        Plot::Bell => [x, 10.0 * gaussian(x)],
+                        Plot::Sigmoid => [x, sigmoid(x)],
+                    }
+                })
+                .collect::<PlotPoints>(),
+        );
+        egui::plot::Plot::new("example_plot")
+            .show_axes(self.show_axes)
+            .allow_drag(self.allow_drag)
+            .allow_zoom(self.allow_zoom)
+            .allow_scroll(self.allow_scroll)
+            .center_x_axis(self.center_x_axis)
+            .center_x_axis(self.center_y_axis)
+            .width(self.width)
+            .height(self.height)
+            .data_aspect(1.0)
+            .show(ui, |plot_ui| plot_ui.line(line))
+            .response
+    }
+
+    fn nested_menus(ui: &mut egui::Ui) {
+        if ui.button("Open...").clicked() {
+            ui.close_menu();
+        }
+        ui.menu_button("SubMenu", |ui| {
+            ui.menu_button("SubMenu", |ui| {
+                if ui.button("Open...").clicked() {
+                    ui.close_menu();
+                }
+                let _ = ui.button("Item");
+            });
+            ui.menu_button("SubMenu", |ui| {
+                if ui.button("Open...").clicked() {
+                    ui.close_menu();
+                }
+                let _ = ui.button("Item");
+            });
+            let _ = ui.button("Item");
+            if ui.button("Open...").clicked() {
+                ui.close_menu();
+            }
+        });
+        ui.menu_button("SubMenu", |ui| {
+            let _ = ui.button("Item1");
+            let _ = ui.button("Item2");
+            let _ = ui.button("Item3");
+            let _ = ui.button("Item4");
+            if ui.button("Open...").clicked() {
+                ui.close_menu();
+            }
+        });
+        let _ = ui.button("Very long text for this item");
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/dancing_strings.rs b/egui/crates/egui_demo_lib/src/demo/dancing_strings.rs
new file mode 100644
index 0000000..3beb323
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/dancing_strings.rs
@@ -0,0 +1,67 @@
+use egui::{containers::*, *};
+
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct DancingStrings {}
+
+impl super::Demo for DancingStrings {
+    fn name(&self) -> &'static str {
+        "♫ Dancing Strings"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .default_size(vec2(512.0, 256.0))
+            .vscroll(false)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for DancingStrings {
+    fn ui(&mut self, ui: &mut Ui) {
+        let color = if ui.visuals().dark_mode {
+            Color32::from_additive_luminance(196)
+        } else {
+            Color32::from_black_alpha(240)
+        };
+
+        Frame::canvas(ui.style()).show(ui, |ui| {
+            ui.ctx().request_repaint();
+            let time = ui.input(|i| i.time);
+
+            let desired_size = ui.available_width() * vec2(1.0, 0.35);
+            let (_id, rect) = ui.allocate_space(desired_size);
+
+            let to_screen =
+                emath::RectTransform::from_to(Rect::from_x_y_ranges(0.0..=1.0, -1.0..=1.0), rect);
+
+            let mut shapes = vec![];
+
+            for &mode in &[2, 3, 5] {
+                let mode = mode as f64;
+                let n = 120;
+                let speed = 1.5;
+
+                let points: Vec<Pos2> = (0..=n)
+                    .map(|i| {
+                        let t = i as f64 / (n as f64);
+                        let amp = (time * speed * mode).sin() / mode;
+                        let y = amp * (t * std::f64::consts::TAU / 2.0 * mode).sin();
+                        to_screen * pos2(t as f32, y as f32)
+                    })
+                    .collect();
+
+                let thickness = 10.0 / mode as f32;
+                shapes.push(epaint::Shape::line(points, Stroke::new(thickness, color)));
+            }
+
+            ui.painter().extend(shapes);
+        });
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/demo_app_windows.rs b/egui/crates/egui_demo_lib/src/demo/demo_app_windows.rs
new file mode 100644
index 0000000..31a28ae
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/demo_app_windows.rs
@@ -0,0 +1,355 @@
+use egui::{Context, Modifiers, ScrollArea, Ui};
+use std::collections::BTreeSet;
+
+use super::About;
+use super::Demo;
+use super::View;
+use crate::is_mobile;
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+struct Demos {
+    #[cfg_attr(feature = "serde", serde(skip))]
+    demos: Vec<Box<dyn Demo>>,
+
+    open: BTreeSet<String>,
+}
+
+impl Default for Demos {
+    fn default() -> Self {
+        Self::from_demos(vec![
+            Box::new(super::paint_bezier::PaintBezier::default()),
+            Box::new(super::code_editor::CodeEditor::default()),
+            Box::new(super::code_example::CodeExample::default()),
+            Box::new(super::context_menu::ContextMenus::default()),
+            Box::new(super::dancing_strings::DancingStrings::default()),
+            Box::new(super::drag_and_drop::DragAndDropDemo::default()),
+            Box::new(super::font_book::FontBook::default()),
+            Box::new(super::MiscDemoWindow::default()),
+            Box::new(super::multi_touch::MultiTouch::default()),
+            Box::new(super::painting::Painting::default()),
+            Box::new(super::plot_demo::PlotDemo::default()),
+            Box::new(super::scrolling::Scrolling::default()),
+            Box::new(super::sliders::Sliders::default()),
+            Box::new(super::strip_demo::StripDemo::default()),
+            Box::new(super::table_demo::TableDemo::default()),
+            Box::new(super::text_edit::TextEdit::default()),
+            Box::new(super::widget_gallery::WidgetGallery::default()),
+            Box::new(super::window_options::WindowOptions::default()),
+            Box::new(super::tests::WindowResizeTest::default()),
+            Box::new(super::window_with_panels::WindowWithPanels::default()),
+        ])
+    }
+}
+
+impl Demos {
+    pub fn from_demos(demos: Vec<Box<dyn Demo>>) -> Self {
+        let mut open = BTreeSet::new();
+        open.insert(
+            super::widget_gallery::WidgetGallery::default()
+                .name()
+                .to_owned(),
+        );
+
+        Self { demos, open }
+    }
+
+    pub fn checkboxes(&mut self, ui: &mut Ui) {
+        let Self { demos, open } = self;
+        for demo in demos {
+            let mut is_open = open.contains(demo.name());
+            ui.toggle_value(&mut is_open, demo.name());
+            set_open(open, demo.name(), is_open);
+        }
+    }
+
+    pub fn windows(&mut self, ctx: &Context) {
+        let Self { demos, open } = self;
+        for demo in demos {
+            let mut is_open = open.contains(demo.name());
+            demo.show(ctx, &mut is_open);
+            set_open(open, demo.name(), is_open);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+struct Tests {
+    #[cfg_attr(feature = "serde", serde(skip))]
+    demos: Vec<Box<dyn Demo>>,
+
+    open: BTreeSet<String>,
+}
+
+impl Default for Tests {
+    fn default() -> Self {
+        Self::from_demos(vec![
+            Box::new(super::tests::CursorTest::default()),
+            Box::new(super::highlighting::Highlighting::default()),
+            Box::new(super::tests::IdTest::default()),
+            Box::new(super::tests::InputTest::default()),
+            Box::new(super::layout_test::LayoutTest::default()),
+            Box::new(super::tests::ManualLayoutTest::default()),
+            Box::new(super::tests::TableTest::default()),
+        ])
+    }
+}
+
+impl Tests {
+    pub fn from_demos(demos: Vec<Box<dyn Demo>>) -> Self {
+        let mut open = BTreeSet::new();
+        open.insert(
+            super::widget_gallery::WidgetGallery::default()
+                .name()
+                .to_owned(),
+        );
+
+        Self { demos, open }
+    }
+
+    pub fn checkboxes(&mut self, ui: &mut Ui) {
+        let Self { demos, open } = self;
+        for demo in demos {
+            let mut is_open = open.contains(demo.name());
+            ui.toggle_value(&mut is_open, demo.name());
+            set_open(open, demo.name(), is_open);
+        }
+    }
+
+    pub fn windows(&mut self, ctx: &Context) {
+        let Self { demos, open } = self;
+        for demo in demos {
+            let mut is_open = open.contains(demo.name());
+            demo.show(ctx, &mut is_open);
+            set_open(open, demo.name(), is_open);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn set_open(open: &mut BTreeSet<String>, key: &'static str, is_open: bool) {
+    if is_open {
+        if !open.contains(key) {
+            open.insert(key.to_owned());
+        }
+    } else {
+        open.remove(key);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A menu bar in which you can select different demo windows to show.
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct DemoWindows {
+    about_is_open: bool,
+    about: About,
+    demos: Demos,
+    tests: Tests,
+}
+
+impl Default for DemoWindows {
+    fn default() -> Self {
+        Self {
+            about_is_open: true,
+            about: Default::default(),
+            demos: Default::default(),
+            tests: Default::default(),
+        }
+    }
+}
+
+impl DemoWindows {
+    /// Show the app ui (menu bar and windows).
+    pub fn ui(&mut self, ctx: &Context) {
+        if is_mobile(ctx) {
+            self.mobile_ui(ctx);
+        } else {
+            self.desktop_ui(ctx);
+        }
+    }
+
+    fn mobile_ui(&mut self, ctx: &Context) {
+        if self.about_is_open {
+            let screen_size = ctx.input(|i| i.screen_rect.size());
+            let default_width = (screen_size.x - 20.0).min(400.0);
+
+            let mut close = false;
+            egui::Window::new(self.about.name())
+                .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
+                .default_width(default_width)
+                .default_height(ctx.available_rect().height() - 46.0)
+                .vscroll(true)
+                .open(&mut self.about_is_open)
+                .resizable(false)
+                .collapsible(false)
+                .show(ctx, |ui| {
+                    self.about.ui(ui);
+                    ui.add_space(12.0);
+                    ui.vertical_centered_justified(|ui| {
+                        if ui
+                            .button(egui::RichText::new("Continue to the demo!").size(20.0))
+                            .clicked()
+                        {
+                            close = true;
+                        }
+                    });
+                });
+            self.about_is_open &= !close;
+        } else {
+            self.mobile_top_bar(ctx);
+            self.show_windows(ctx);
+        }
+    }
+
+    fn mobile_top_bar(&mut self, ctx: &Context) {
+        egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
+            egui::menu::bar(ui, |ui| {
+                let font_size = 16.5;
+
+                ui.menu_button(egui::RichText::new("⏷ demos").size(font_size), |ui| {
+                    ui.set_style(ui.ctx().style()); // ignore the "menu" style set by `menu_button`.
+                    self.demo_list_ui(ui);
+                    if ui.ui_contains_pointer() && ui.input(|i| i.pointer.any_click()) {
+                        ui.close_menu();
+                    }
+                });
+
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    use egui::special_emojis::{GITHUB, TWITTER};
+                    ui.hyperlink_to(
+                        egui::RichText::new(TWITTER).size(font_size),
+                        "https://twitter.com/ernerfeldt",
+                    );
+                    ui.hyperlink_to(
+                        egui::RichText::new(GITHUB).size(font_size),
+                        "https://github.com/emilk/egui",
+                    );
+                });
+            });
+        });
+    }
+
+    fn desktop_ui(&mut self, ctx: &Context) {
+        egui::SidePanel::right("egui_demo_panel")
+            .resizable(false)
+            .default_width(150.0)
+            .show(ctx, |ui| {
+                egui::trace!(ui);
+                ui.vertical_centered(|ui| {
+                    ui.heading("✒ egui demos");
+                });
+
+                ui.separator();
+
+                use egui::special_emojis::{GITHUB, TWITTER};
+                ui.hyperlink_to(
+                    format!("{} egui on GitHub", GITHUB),
+                    "https://github.com/emilk/egui",
+                );
+                ui.hyperlink_to(
+                    format!("{} @ernerfeldt", TWITTER),
+                    "https://twitter.com/ernerfeldt",
+                );
+
+                ui.separator();
+
+                self.demo_list_ui(ui);
+            });
+
+        egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
+            egui::menu::bar(ui, |ui| {
+                file_menu_button(ui);
+            });
+        });
+
+        self.show_windows(ctx);
+    }
+
+    /// Show the open windows.
+    fn show_windows(&mut self, ctx: &Context) {
+        self.about.show(ctx, &mut self.about_is_open);
+        self.demos.windows(ctx);
+        self.tests.windows(ctx);
+    }
+
+    fn demo_list_ui(&mut self, ui: &mut egui::Ui) {
+        ScrollArea::vertical().show(ui, |ui| {
+            ui.with_layout(egui::Layout::top_down_justified(egui::Align::LEFT), |ui| {
+                ui.toggle_value(&mut self.about_is_open, self.about.name());
+
+                ui.separator();
+                self.demos.checkboxes(ui);
+                ui.separator();
+                self.tests.checkboxes(ui);
+                ui.separator();
+
+                if ui.button("Organize windows").clicked() {
+                    ui.ctx().memory_mut(|mem| mem.reset_areas());
+                }
+            });
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn file_menu_button(ui: &mut Ui) {
+    let organize_shortcut =
+        egui::KeyboardShortcut::new(Modifiers::CTRL | Modifiers::SHIFT, egui::Key::O);
+    let reset_shortcut =
+        egui::KeyboardShortcut::new(Modifiers::CTRL | Modifiers::SHIFT, egui::Key::R);
+
+    // NOTE: we must check the shortcuts OUTSIDE of the actual "File" menu,
+    // or else they would only be checked if the "File" menu was actually open!
+
+    if ui.input_mut(|i| i.consume_shortcut(&organize_shortcut)) {
+        ui.ctx().memory_mut(|mem| mem.reset_areas());
+    }
+
+    if ui.input_mut(|i| i.consume_shortcut(&reset_shortcut)) {
+        ui.ctx().memory_mut(|mem| *mem = Default::default());
+    }
+
+    ui.menu_button("File", |ui| {
+        ui.set_min_width(220.0);
+        ui.style_mut().wrap = Some(false);
+
+        // On the web the browser controls the zoom
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            egui::gui_zoom::zoom_menu_buttons(ui, None);
+            ui.separator();
+        }
+
+        if ui
+            .add(
+                egui::Button::new("Organize Windows")
+                    .shortcut_text(ui.ctx().format_shortcut(&organize_shortcut)),
+            )
+            .clicked()
+        {
+            ui.ctx().memory_mut(|mem| mem.reset_areas());
+            ui.close_menu();
+        }
+
+        if ui
+            .add(
+                egui::Button::new("Reset egui memory")
+                    .shortcut_text(ui.ctx().format_shortcut(&reset_shortcut)),
+            )
+            .on_hover_text("Forget scroll, positions, sizes etc")
+            .clicked()
+        {
+            ui.ctx().memory_mut(|mem| *mem = Default::default());
+            ui.close_menu();
+        }
+    });
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/drag_and_drop.rs b/egui/crates/egui_demo_lib/src/demo/drag_and_drop.rs
new file mode 100644
index 0000000..23d3daa
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/drag_and_drop.rs
@@ -0,0 +1,177 @@
+use egui::*;
+
+pub fn drag_source(ui: &mut Ui, id: Id, body: impl FnOnce(&mut Ui)) {
+    let is_being_dragged = ui.memory(|mem| mem.is_being_dragged(id));
+
+    if !is_being_dragged {
+        let response = ui.scope(body).response;
+
+        // Check for drags:
+        let response = ui.interact(response.rect, id, Sense::drag());
+        if response.hovered() {
+            ui.ctx().set_cursor_icon(CursorIcon::Grab);
+        }
+    } else {
+        ui.ctx().set_cursor_icon(CursorIcon::Grabbing);
+
+        // Paint the body to a new layer:
+        let layer_id = LayerId::new(Order::Tooltip, id);
+        let response = ui.with_layer_id(layer_id, body).response;
+
+        // Now we move the visuals of the body to where the mouse is.
+        // Normally you need to decide a location for a widget first,
+        // because otherwise that widget cannot interact with the mouse.
+        // However, a dragged component cannot be interacted with anyway
+        // (anything with `Order::Tooltip` always gets an empty [`Response`])
+        // So this is fine!
+
+        if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
+            let delta = pointer_pos - response.rect.center();
+            ui.ctx().translate_layer(layer_id, delta);
+        }
+    }
+}
+
+pub fn drop_target<R>(
+    ui: &mut Ui,
+    can_accept_what_is_being_dragged: bool,
+    body: impl FnOnce(&mut Ui) -> R,
+) -> InnerResponse<R> {
+    let is_being_dragged = ui.memory(|mem| mem.is_anything_being_dragged());
+
+    let margin = Vec2::splat(4.0);
+
+    let outer_rect_bounds = ui.available_rect_before_wrap();
+    let inner_rect = outer_rect_bounds.shrink2(margin);
+    let where_to_put_background = ui.painter().add(Shape::Noop);
+    let mut content_ui = ui.child_ui(inner_rect, *ui.layout());
+    let ret = body(&mut content_ui);
+    let outer_rect = Rect::from_min_max(outer_rect_bounds.min, content_ui.min_rect().max + margin);
+    let (rect, response) = ui.allocate_at_least(outer_rect.size(), Sense::hover());
+
+    let style = if is_being_dragged && can_accept_what_is_being_dragged && response.hovered() {
+        ui.visuals().widgets.active
+    } else {
+        ui.visuals().widgets.inactive
+    };
+
+    let mut fill = style.bg_fill;
+    let mut stroke = style.bg_stroke;
+    if is_being_dragged && !can_accept_what_is_being_dragged {
+        fill = ui.visuals().gray_out(fill);
+        stroke.color = ui.visuals().gray_out(stroke.color);
+    }
+
+    ui.painter().set(
+        where_to_put_background,
+        epaint::RectShape {
+            rounding: style.rounding,
+            fill,
+            stroke,
+            rect,
+        },
+    );
+
+    InnerResponse::new(ret, response)
+}
+
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct DragAndDropDemo {
+    /// columns with items
+    columns: Vec<Vec<String>>,
+}
+
+impl Default for DragAndDropDemo {
+    fn default() -> Self {
+        Self {
+            columns: vec![
+                vec!["Item A", "Item B", "Item C"],
+                vec!["Item D", "Item E"],
+                vec!["Item F", "Item G", "Item H"],
+            ]
+            .into_iter()
+            .map(|v| v.into_iter().map(ToString::to_string).collect())
+            .collect(),
+        }
+    }
+}
+
+impl super::Demo for DragAndDropDemo {
+    fn name(&self) -> &'static str {
+        "✋ Drag and Drop"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .default_size(vec2(256.0, 256.0))
+            .vscroll(false)
+            .resizable(false)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for DragAndDropDemo {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.label("This is a proof-of-concept of drag-and-drop in egui.");
+        ui.label("Drag items between columns.");
+
+        let id_source = "my_drag_and_drop_demo";
+        let mut source_col_row = None;
+        let mut drop_col = None;
+        ui.columns(self.columns.len(), |uis| {
+            for (col_idx, column) in self.columns.clone().into_iter().enumerate() {
+                let ui = &mut uis[col_idx];
+                let can_accept_what_is_being_dragged = true; // We accept anything being dragged (for now) ¯\_(ツ)_/¯
+                let response = drop_target(ui, can_accept_what_is_being_dragged, |ui| {
+                    ui.set_min_size(vec2(64.0, 100.0));
+                    for (row_idx, item) in column.iter().enumerate() {
+                        let item_id = Id::new(id_source).with(col_idx).with(row_idx);
+                        drag_source(ui, item_id, |ui| {
+                            let response = ui.add(Label::new(item).sense(Sense::click()));
+                            response.context_menu(|ui| {
+                                if ui.button("Remove").clicked() {
+                                    self.columns[col_idx].remove(row_idx);
+                                    ui.close_menu();
+                                }
+                            });
+                        });
+
+                        if ui.memory(|mem| mem.is_being_dragged(item_id)) {
+                            source_col_row = Some((col_idx, row_idx));
+                        }
+                    }
+                })
+                .response;
+
+                let response = response.context_menu(|ui| {
+                    if ui.button("New Item").clicked() {
+                        self.columns[col_idx].push("New Item".to_owned());
+                        ui.close_menu();
+                    }
+                });
+
+                let is_being_dragged = ui.memory(|mem| mem.is_anything_being_dragged());
+                if is_being_dragged && can_accept_what_is_being_dragged && response.hovered() {
+                    drop_col = Some(col_idx);
+                }
+            }
+        });
+
+        if let Some((source_col, source_row)) = source_col_row {
+            if let Some(drop_col) = drop_col {
+                if ui.input(|i| i.pointer.any_released()) {
+                    // do the drop:
+                    let item = self.columns[source_col].remove(source_row);
+                    self.columns[drop_col].push(item);
+                }
+            }
+        }
+
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/font_book.rs b/egui/crates/egui_demo_lib/src/demo/font_book.rs
new file mode 100644
index 0000000..2b4eeba
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/font_book.rs
@@ -0,0 +1,262 @@
+use std::collections::BTreeMap;
+
+pub struct FontBook {
+    filter: String,
+    font_id: egui::FontId,
+    named_chars: BTreeMap<egui::FontFamily, BTreeMap<char, String>>,
+}
+
+impl Default for FontBook {
+    fn default() -> Self {
+        Self {
+            filter: Default::default(),
+            font_id: egui::FontId::proportional(18.0),
+            named_chars: Default::default(),
+        }
+    }
+}
+
+impl super::Demo for FontBook {
+    fn name(&self) -> &'static str {
+        "🔤 Font Book"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name()).open(open).show(ctx, |ui| {
+            use super::View as _;
+            self.ui(ui);
+        });
+    }
+}
+
+impl super::View for FontBook {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+
+        ui.label(format!(
+            "The selected font supports {} characters.",
+            self.named_chars
+                .get(&self.font_id.family)
+                .map(|map| map.len())
+                .unwrap_or_default()
+        ));
+
+        ui.horizontal_wrapped(|ui| {
+            ui.spacing_mut().item_spacing.x = 0.0;
+            ui.label("You can add more characters by installing additional fonts with ");
+            ui.add(egui::Hyperlink::from_label_and_url(
+                egui::RichText::new("Context::set_fonts").text_style(egui::TextStyle::Monospace),
+                "https://docs.rs/egui/latest/egui/struct.Context.html#method.set_fonts",
+            ));
+            ui.label(".");
+        });
+
+        ui.separator();
+
+        egui::introspection::font_id_ui(ui, &mut self.font_id);
+
+        ui.horizontal(|ui| {
+            ui.label("Filter:");
+            ui.add(egui::TextEdit::singleline(&mut self.filter).desired_width(120.0));
+            self.filter = self.filter.to_lowercase();
+            if ui.button("ｘ").clicked() {
+                self.filter.clear();
+            }
+        });
+
+        let filter = &self.filter;
+        let named_chars = self
+            .named_chars
+            .entry(self.font_id.family.clone())
+            .or_insert_with(|| available_characters(ui, self.font_id.family.clone()));
+
+        ui.separator();
+
+        egui::ScrollArea::vertical().show(ui, |ui| {
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing = egui::Vec2::splat(2.0);
+
+                for (&chr, name) in named_chars {
+                    if filter.is_empty() || name.contains(filter) || *filter == chr.to_string() {
+                        let button = egui::Button::new(
+                            egui::RichText::new(chr.to_string()).font(self.font_id.clone()),
+                        )
+                        .frame(false);
+
+                        let tooltip_ui = |ui: &mut egui::Ui| {
+                            ui.label(
+                                egui::RichText::new(chr.to_string()).font(self.font_id.clone()),
+                            );
+                            ui.label(format!("{}\nU+{:X}\n\nClick to copy", name, chr as u32));
+                        };
+
+                        if ui.add(button).on_hover_ui(tooltip_ui).clicked() {
+                            ui.output_mut(|o| o.copied_text = chr.to_string());
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+
+fn available_characters(ui: &egui::Ui, family: egui::FontFamily) -> BTreeMap<char, String> {
+    ui.fonts(|f| {
+        f.lock()
+            .fonts
+            .font(&egui::FontId::new(10.0, family)) // size is arbitrary for getting the characters
+            .characters()
+            .iter()
+            .filter(|chr| !chr.is_whitespace() && !chr.is_ascii_control())
+            .map(|&chr| (chr, char_name(chr)))
+            .collect()
+    })
+}
+
+fn char_name(chr: char) -> String {
+    special_char_name(chr)
+        .map(|s| s.to_owned())
+        .or_else(|| unicode_names2::name(chr).map(|name| name.to_string().to_lowercase()))
+        .unwrap_or_else(|| "unknown".to_owned())
+}
+
+fn special_char_name(chr: char) -> Option<&'static str> {
+    #[allow(clippy::match_same_arms)] // many "flag"
+    match chr {
+        // Special private-use-area extensions found in `emoji-icon-font.ttf`:
+        // Private use area extensions:
+        '\u{FE4E5}' => Some("flag japan"),
+        '\u{FE4E6}' => Some("flag usa"),
+        '\u{FE4E7}' => Some("flag"),
+        '\u{FE4E8}' => Some("flag"),
+        '\u{FE4E9}' => Some("flag"),
+        '\u{FE4EA}' => Some("flag great britain"),
+        '\u{FE4EB}' => Some("flag"),
+        '\u{FE4EC}' => Some("flag"),
+        '\u{FE4ED}' => Some("flag"),
+        '\u{FE4EE}' => Some("flag south korea"),
+        '\u{FE82C}' => Some("number sign in square"),
+        '\u{FE82E}' => Some("digit one in square"),
+        '\u{FE82F}' => Some("digit two in square"),
+        '\u{FE830}' => Some("digit three in square"),
+        '\u{FE831}' => Some("digit four in square"),
+        '\u{FE832}' => Some("digit five in square"),
+        '\u{FE833}' => Some("digit six in square"),
+        '\u{FE834}' => Some("digit seven in square"),
+        '\u{FE835}' => Some("digit eight in square"),
+        '\u{FE836}' => Some("digit nine in square"),
+        '\u{FE837}' => Some("digit zero in square"),
+
+        // Special private-use-area extensions found in `emoji-icon-font.ttf`:
+        // Web services / operating systems / browsers
+        '\u{E600}' => Some("web-dribbble"),
+        '\u{E601}' => Some("web-stackoverflow"),
+        '\u{E602}' => Some("web-vimeo"),
+        '\u{E603}' => Some("web-twitter"),
+        '\u{E604}' => Some("web-facebook"),
+        '\u{E605}' => Some("web-googleplus"),
+        '\u{E606}' => Some("web-pinterest"),
+        '\u{E607}' => Some("web-tumblr"),
+        '\u{E608}' => Some("web-linkedin"),
+        '\u{E60A}' => Some("web-stumbleupon"),
+        '\u{E60B}' => Some("web-lastfm"),
+        '\u{E60C}' => Some("web-rdio"),
+        '\u{E60D}' => Some("web-spotify"),
+        '\u{E60E}' => Some("web-qq"),
+        '\u{E60F}' => Some("web-instagram"),
+        '\u{E610}' => Some("web-dropbox"),
+        '\u{E611}' => Some("web-evernote"),
+        '\u{E612}' => Some("web-flattr"),
+        '\u{E613}' => Some("web-skype"),
+        '\u{E614}' => Some("web-renren"),
+        '\u{E615}' => Some("web-sina-weibo"),
+        '\u{E616}' => Some("web-paypal"),
+        '\u{E617}' => Some("web-picasa"),
+        '\u{E618}' => Some("os-android"),
+        '\u{E619}' => Some("web-mixi"),
+        '\u{E61A}' => Some("web-behance"),
+        '\u{E61B}' => Some("web-circles"),
+        '\u{E61C}' => Some("web-vk"),
+        '\u{E61D}' => Some("web-smashing"),
+        '\u{E61E}' => Some("web-forrst"),
+        '\u{E61F}' => Some("os-windows"),
+        '\u{E620}' => Some("web-flickr"),
+        '\u{E621}' => Some("web-picassa"),
+        '\u{E622}' => Some("web-deviantart"),
+        '\u{E623}' => Some("web-steam"),
+        '\u{E624}' => Some("web-github"),
+        '\u{E625}' => Some("web-git"),
+        '\u{E626}' => Some("web-blogger"),
+        '\u{E627}' => Some("web-soundcloud"),
+        '\u{E628}' => Some("web-reddit"),
+        '\u{E629}' => Some("web-delicious"),
+        '\u{E62A}' => Some("browser-chrome"),
+        '\u{E62B}' => Some("browser-firefox"),
+        '\u{E62C}' => Some("browser-ie"),
+        '\u{E62D}' => Some("browser-opera"),
+        '\u{E62E}' => Some("browser-safari"),
+        '\u{E62F}' => Some("web-google-drive"),
+        '\u{E630}' => Some("web-wordpress"),
+        '\u{E631}' => Some("web-joomla"),
+        '\u{E632}' => Some("lastfm"),
+        '\u{E633}' => Some("web-foursquare"),
+        '\u{E634}' => Some("web-yelp"),
+        '\u{E635}' => Some("web-drupal"),
+        '\u{E636}' => Some("youtube"),
+        '\u{F189}' => Some("vk"),
+        '\u{F1A6}' => Some("digg"),
+        '\u{F1CA}' => Some("web-vine"),
+        '\u{F8FF}' => Some("os-apple"),
+
+        // Special private-use-area extensions found in `Ubuntu-Light.ttf`
+        '\u{F000}' => Some("uniF000"),
+        '\u{F001}' => Some("fi"),
+        '\u{F002}' => Some("fl"),
+        '\u{F506}' => Some("one seventh"),
+        '\u{F507}' => Some("two sevenths"),
+        '\u{F508}' => Some("three sevenths"),
+        '\u{F509}' => Some("four sevenths"),
+        '\u{F50A}' => Some("five sevenths"),
+        '\u{F50B}' => Some("six sevenths"),
+        '\u{F50C}' => Some("one ninth"),
+        '\u{F50D}' => Some("two ninths"),
+        '\u{F50E}' => Some("four ninths"),
+        '\u{F50F}' => Some("five ninths"),
+        '\u{F510}' => Some("seven ninths"),
+        '\u{F511}' => Some("eight ninths"),
+        '\u{F800}' => Some("zero.alt"),
+        '\u{F801}' => Some("one.alt"),
+        '\u{F802}' => Some("two.alt"),
+        '\u{F803}' => Some("three.alt"),
+        '\u{F804}' => Some("four.alt"),
+        '\u{F805}' => Some("five.alt"),
+        '\u{F806}' => Some("six.alt"),
+        '\u{F807}' => Some("seven.alt"),
+        '\u{F808}' => Some("eight.alt"),
+        '\u{F809}' => Some("nine.alt"),
+        '\u{F80A}' => Some("zero.sups"),
+        '\u{F80B}' => Some("one.sups"),
+        '\u{F80C}' => Some("two.sups"),
+        '\u{F80D}' => Some("three.sups"),
+        '\u{F80E}' => Some("four.sups"),
+        '\u{F80F}' => Some("five.sups"),
+        '\u{F810}' => Some("six.sups"),
+        '\u{F811}' => Some("seven.sups"),
+        '\u{F812}' => Some("eight.sups"),
+        '\u{F813}' => Some("nine.sups"),
+        '\u{F814}' => Some("zero.sinf"),
+        '\u{F815}' => Some("one.sinf"),
+        '\u{F816}' => Some("two.sinf"),
+        '\u{F817}' => Some("three.sinf"),
+        '\u{F818}' => Some("four.sinf"),
+        '\u{F819}' => Some("five.sinf"),
+        '\u{F81A}' => Some("six.sinf"),
+        '\u{F81B}' => Some("seven.sinf"),
+        '\u{F81C}' => Some("eight.sinf"),
+        '\u{F81D}' => Some("nine.sinf"),
+
+        _ => None,
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/highlighting.rs b/egui/crates/egui_demo_lib/src/demo/highlighting.rs
new file mode 100644
index 0000000..24cf21c
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/highlighting.rs
@@ -0,0 +1,37 @@
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Highlighting {}
+
+impl super::Demo for Highlighting {
+    fn name(&self) -> &'static str {
+        "Highlighting"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .default_width(320.0)
+            .open(open)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for Highlighting {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.label("This demo demonstrates highlighting a widget.");
+        ui.add_space(4.0);
+        let label_response = ui.label("Hover me to highlight the button!");
+        ui.add_space(4.0);
+        let mut button_response = ui.button("Hover the button to highlight the label!");
+
+        if label_response.hovered() {
+            button_response = button_response.highlight();
+        }
+        if button_response.hovered() {
+            label_response.highlight();
+        }
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/layout_test.rs b/egui/crates/egui_demo_lib/src/demo/layout_test.rs
new file mode 100644
index 0000000..2d4fa8a
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/layout_test.rs
@@ -0,0 +1,180 @@
+use egui::*;
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct LayoutTest {
+    // Identical to contents of `egui::Layout`
+    layout: LayoutSettings,
+
+    // Extra for testing wrapping:
+    wrap_column_width: f32,
+    wrap_row_height: f32,
+}
+
+impl Default for LayoutTest {
+    fn default() -> Self {
+        Self {
+            layout: LayoutSettings::top_down(),
+            wrap_column_width: 150.0,
+            wrap_row_height: 20.0,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct LayoutSettings {
+    // Similar to the contents of `egui::Layout`
+    main_dir: Direction,
+    main_wrap: bool,
+    cross_align: Align,
+    cross_justify: bool,
+}
+
+impl Default for LayoutSettings {
+    fn default() -> Self {
+        Self::top_down()
+    }
+}
+
+impl LayoutSettings {
+    fn top_down() -> Self {
+        Self {
+            main_dir: Direction::TopDown,
+            main_wrap: false,
+            cross_align: Align::Min,
+            cross_justify: false,
+        }
+    }
+
+    fn top_down_justified_centered() -> Self {
+        Self {
+            main_dir: Direction::TopDown,
+            main_wrap: false,
+            cross_align: Align::Center,
+            cross_justify: true,
+        }
+    }
+
+    fn horizontal_wrapped() -> Self {
+        Self {
+            main_dir: Direction::LeftToRight,
+            main_wrap: true,
+            cross_align: Align::Center,
+            cross_justify: false,
+        }
+    }
+
+    fn layout(&self) -> Layout {
+        Layout::from_main_dir_and_cross_align(self.main_dir, self.cross_align)
+            .with_main_wrap(self.main_wrap)
+            .with_cross_justify(self.cross_justify)
+    }
+}
+
+impl super::Demo for LayoutTest {
+    fn name(&self) -> &'static str {
+        "Layout Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(false)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for LayoutTest {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.label("Tests and demonstrates the limits of the egui layouts");
+        self.content_ui(ui);
+        Resize::default()
+            .default_size([150.0, 200.0])
+            .show(ui, |ui| {
+                if self.layout.main_wrap {
+                    if self.layout.main_dir.is_horizontal() {
+                        ui.allocate_ui(
+                            vec2(ui.available_size_before_wrap().x, self.wrap_row_height),
+                            |ui| ui.with_layout(self.layout.layout(), demo_ui),
+                        );
+                    } else {
+                        ui.allocate_ui(
+                            vec2(self.wrap_column_width, ui.available_size_before_wrap().y),
+                            |ui| ui.with_layout(self.layout.layout(), demo_ui),
+                        );
+                    }
+                } else {
+                    ui.with_layout(self.layout.layout(), demo_ui);
+                }
+            });
+        ui.label("Resize to see effect");
+    }
+}
+
+impl LayoutTest {
+    pub fn content_ui(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            ui.selectable_value(&mut self.layout, LayoutSettings::top_down(), "Top-down");
+            ui.selectable_value(
+                &mut self.layout,
+                LayoutSettings::top_down_justified_centered(),
+                "Top-down, centered and justified",
+            );
+            ui.selectable_value(
+                &mut self.layout,
+                LayoutSettings::horizontal_wrapped(),
+                "Horizontal wrapped",
+            );
+        });
+
+        ui.horizontal(|ui| {
+            ui.label("Main Direction:");
+            for &dir in &[
+                Direction::LeftToRight,
+                Direction::RightToLeft,
+                Direction::TopDown,
+                Direction::BottomUp,
+            ] {
+                ui.radio_value(&mut self.layout.main_dir, dir, format!("{:?}", dir));
+            }
+        });
+
+        ui.horizontal(|ui| {
+            ui.checkbox(&mut self.layout.main_wrap, "Main wrap")
+                .on_hover_text("Wrap when next widget doesn't fit the current row/column");
+
+            if self.layout.main_wrap {
+                if self.layout.main_dir.is_horizontal() {
+                    ui.add(Slider::new(&mut self.wrap_row_height, 0.0..=200.0).text("Row height"));
+                } else {
+                    ui.add(
+                        Slider::new(&mut self.wrap_column_width, 0.0..=200.0).text("Column width"),
+                    );
+                }
+            }
+        });
+
+        ui.horizontal(|ui| {
+            ui.label("Cross Align:");
+            for &align in &[Align::Min, Align::Center, Align::Max] {
+                ui.radio_value(&mut self.layout.cross_align, align, format!("{:?}", align));
+            }
+        });
+
+        ui.checkbox(&mut self.layout.cross_justify, "Cross Justified")
+            .on_hover_text("Try to fill full width/height (e.g. buttons)");
+    }
+}
+
+fn demo_ui(ui: &mut Ui) {
+    ui.add(egui::Label::new("Wrapping text followed by example widgets:").wrap(true));
+    let mut dummy = false;
+    ui.checkbox(&mut dummy, "checkbox");
+    ui.radio_value(&mut dummy, false, "radio");
+    let _ = ui.button("button");
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/misc_demo_window.rs b/egui/crates/egui_demo_lib/src/demo/misc_demo_window.rs
new file mode 100644
index 0000000..61a6091
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/misc_demo_window.rs
@@ -0,0 +1,663 @@
+use super::*;
+use crate::LOREM_IPSUM;
+use egui::{epaint::text::TextWrapping, *};
+
+/// Showcase some ui code
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct MiscDemoWindow {
+    num_columns: usize,
+
+    break_anywhere: bool,
+    max_rows: usize,
+    overflow_character: Option<char>,
+
+    widgets: Widgets,
+    colors: ColorWidgets,
+    custom_collapsing_header: CustomCollapsingHeader,
+    tree: Tree,
+    box_painting: BoxPainting,
+
+    dummy_bool: bool,
+    dummy_usize: usize,
+}
+
+impl Default for MiscDemoWindow {
+    fn default() -> MiscDemoWindow {
+        MiscDemoWindow {
+            num_columns: 2,
+
+            max_rows: 2,
+            break_anywhere: false,
+            overflow_character: Some('…'),
+
+            widgets: Default::default(),
+            colors: Default::default(),
+            custom_collapsing_header: Default::default(),
+            tree: Tree::demo(),
+            box_painting: Default::default(),
+
+            dummy_bool: false,
+            dummy_usize: 0,
+        }
+    }
+}
+
+impl Demo for MiscDemoWindow {
+    fn name(&self) -> &'static str {
+        "✨ Misc Demos"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        Window::new(self.name())
+            .open(open)
+            .vscroll(true)
+            .hscroll(true)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl View for MiscDemoWindow {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.set_min_width(250.0);
+
+        CollapsingHeader::new("Widgets")
+            .default_open(true)
+            .show(ui, |ui| {
+                self.widgets.ui(ui);
+            });
+
+        CollapsingHeader::new("Text layout")
+            .default_open(false)
+            .show(ui, |ui| {
+                text_layout_ui(
+                    ui,
+                    &mut self.max_rows,
+                    &mut self.break_anywhere,
+                    &mut self.overflow_character,
+                );
+            });
+
+        CollapsingHeader::new("Colors")
+            .default_open(false)
+            .show(ui, |ui| {
+                self.colors.ui(ui);
+            });
+
+        CollapsingHeader::new("Custom Collapsing Header")
+            .default_open(false)
+            .show(ui, |ui| self.custom_collapsing_header.ui(ui));
+
+        CollapsingHeader::new("Tree")
+            .default_open(false)
+            .show(ui, |ui| self.tree.ui(ui));
+
+        CollapsingHeader::new("Checkboxes")
+            .default_open(false)
+            .show(ui, |ui| {
+                ui.label("Checkboxes with empty labels take up very little space:");
+                ui.spacing_mut().item_spacing = Vec2::ZERO;
+                ui.horizontal_wrapped(|ui| {
+                    for _ in 0..64 {
+                        ui.checkbox(&mut self.dummy_bool, "");
+                    }
+                });
+                ui.checkbox(&mut self.dummy_bool, "checkbox");
+
+                ui.label("Radiobuttons are similar:");
+                ui.spacing_mut().item_spacing = Vec2::ZERO;
+                ui.horizontal_wrapped(|ui| {
+                    for i in 0..64 {
+                        ui.radio_value(&mut self.dummy_usize, i, "");
+                    }
+                });
+                ui.radio_value(&mut self.dummy_usize, 64, "radio_value");
+            });
+
+        ui.collapsing("Columns", |ui| {
+            ui.add(Slider::new(&mut self.num_columns, 1..=10).text("Columns"));
+            ui.columns(self.num_columns, |cols| {
+                for (i, col) in cols.iter_mut().enumerate() {
+                    col.label(format!("Column {} out of {}", i + 1, self.num_columns));
+                    if i + 1 == self.num_columns && col.button("Delete this").clicked() {
+                        self.num_columns -= 1;
+                    }
+                }
+            });
+        });
+
+        CollapsingHeader::new("Test box rendering")
+            .default_open(false)
+            .show(ui, |ui| self.box_painting.ui(ui));
+
+        CollapsingHeader::new("Resize")
+            .default_open(false)
+            .show(ui, |ui| {
+                Resize::default().default_height(100.0).show(ui, |ui| {
+                    ui.label("This ui can be resized!");
+                    ui.label("Just pull the handle on the bottom right");
+                });
+            });
+
+        CollapsingHeader::new("Misc")
+            .default_open(false)
+            .show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label("You can pretty easily paint your own small icons:");
+                    use std::f32::consts::TAU;
+                    let size = Vec2::splat(16.0);
+                    let (response, painter) = ui.allocate_painter(size, Sense::hover());
+                    let rect = response.rect;
+                    let c = rect.center();
+                    let r = rect.width() / 2.0 - 1.0;
+                    let color = Color32::from_gray(128);
+                    let stroke = Stroke::new(1.0, color);
+                    painter.circle_stroke(c, r, stroke);
+                    painter.line_segment([c - vec2(0.0, r), c + vec2(0.0, r)], stroke);
+                    painter.line_segment([c, c + r * Vec2::angled(TAU * 1.0 / 8.0)], stroke);
+                    painter.line_segment([c, c + r * Vec2::angled(TAU * 3.0 / 8.0)], stroke);
+                });
+            });
+
+        CollapsingHeader::new("Many circles of different sizes")
+            .default_open(false)
+            .show(ui, |ui| {
+                ui.horizontal_wrapped(|ui| {
+                    for i in 0..100 {
+                        let r = i as f32 * 0.5;
+                        let size = Vec2::splat(2.0 * r + 5.0);
+                        let (rect, _response) = ui.allocate_at_least(size, Sense::hover());
+                        ui.painter()
+                            .circle_filled(rect.center(), r, ui.visuals().text_color());
+                    }
+                });
+            });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Widgets {
+    angle: f32,
+    password: String,
+}
+
+impl Default for Widgets {
+    fn default() -> Self {
+        Self {
+            angle: std::f32::consts::TAU / 3.0,
+            password: "hunter2".to_owned(),
+        }
+    }
+}
+
+impl Widgets {
+    pub fn ui(&mut self, ui: &mut Ui) {
+        let Self { angle, password } = self;
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file_line!());
+        });
+
+        ui.horizontal_wrapped(|ui| {
+            // Trick so we don't have to add spaces in the text below:
+            let width = ui.fonts(|f|f.glyph_width(&TextStyle::Body.resolve(ui.style()), ' '));
+            ui.spacing_mut().item_spacing.x = width;
+
+            ui.label(RichText::new("Text can have").color(Color32::from_rgb(110, 255, 110)));
+            ui.colored_label(Color32::from_rgb(128, 140, 255), "color"); // Shortcut version
+            ui.label("and tooltips.").on_hover_text(
+                "This is a multiline tooltip that demonstrates that you can easily add tooltips to any element.\nThis is the second line.\nThis is the third.",
+            );
+
+            ui.label("You can mix in other widgets into text, like");
+            let _ = ui.small_button("this button");
+            ui.label(".");
+
+            ui.label("The default font supports all latin and cyrillic characters (ИÅđ…), common math symbols (∫√∞²⅓…), and many emojis (💓🌟🖩…).")
+                .on_hover_text("There is currently no support for right-to-left languages.");
+            ui.label("See the 🔤 Font Book for more!");
+
+            ui.monospace("There is also a monospace font.");
+        });
+
+        let tooltip_ui = |ui: &mut Ui| {
+            ui.heading("The name of the tooltip");
+            ui.horizontal(|ui| {
+                ui.label("This tooltip was created with");
+                ui.monospace(".on_hover_ui(…)");
+            });
+            let _ = ui.button("A button you can never press");
+        };
+        ui.label("Tooltips can be more than just simple text.")
+            .on_hover_ui(tooltip_ui);
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            ui.label("An angle:");
+            ui.drag_angle(angle);
+            ui.label(format!("≈ {:.3}τ", *angle / std::f32::consts::TAU))
+                .on_hover_text("Each τ represents one turn (τ = 2π)");
+        })
+        .response
+        .on_hover_text("The angle is stored in radians, but presented in degrees");
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            ui.hyperlink_to("Password:", super::password::url_to_file_source_code())
+                .on_hover_text("See the example code for how to use egui to store UI state");
+            ui.add(super::password::password(password));
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+struct ColorWidgets {
+    srgba_unmul: [u8; 4],
+    srgba_premul: [u8; 4],
+    rgba_unmul: [f32; 4],
+    rgba_premul: [f32; 4],
+}
+
+impl Default for ColorWidgets {
+    fn default() -> Self {
+        // Approximately the same color.
+        ColorWidgets {
+            srgba_unmul: [0, 255, 183, 127],
+            srgba_premul: [0, 187, 140, 127],
+            rgba_unmul: [0.0, 1.0, 0.5, 0.5],
+            rgba_premul: [0.0, 0.5, 0.25, 0.5],
+        }
+    }
+}
+
+impl ColorWidgets {
+    fn ui(&mut self, ui: &mut Ui) {
+        egui::reset_button(ui, self);
+
+        ui.label("egui lets you edit colors stored as either sRGBA or linear RGBA and with or without premultiplied alpha");
+
+        let Self {
+            srgba_unmul,
+            srgba_premul,
+            rgba_unmul,
+            rgba_premul,
+        } = self;
+
+        ui.horizontal(|ui| {
+            ui.color_edit_button_srgba_unmultiplied(srgba_unmul);
+            ui.label(format!(
+                "sRGBA: {} {} {} {}",
+                srgba_unmul[0], srgba_unmul[1], srgba_unmul[2], srgba_unmul[3],
+            ));
+        });
+
+        ui.horizontal(|ui| {
+            ui.color_edit_button_srgba_premultiplied(srgba_premul);
+            ui.label(format!(
+                "sRGBA with premultiplied alpha: {} {} {} {}",
+                srgba_premul[0], srgba_premul[1], srgba_premul[2], srgba_premul[3],
+            ));
+        });
+
+        ui.horizontal(|ui| {
+            ui.color_edit_button_rgba_unmultiplied(rgba_unmul);
+            ui.label(format!(
+                "Linear RGBA: {:.02} {:.02} {:.02} {:.02}",
+                rgba_unmul[0], rgba_unmul[1], rgba_unmul[2], rgba_unmul[3],
+            ));
+        });
+
+        ui.horizontal(|ui| {
+            ui.color_edit_button_rgba_premultiplied(rgba_premul);
+            ui.label(format!(
+                "Linear RGBA with premultiplied alpha: {:.02} {:.02} {:.02} {:.02}",
+                rgba_premul[0], rgba_premul[1], rgba_premul[2], rgba_premul[3],
+            ));
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+struct BoxPainting {
+    size: Vec2,
+    rounding: f32,
+    stroke_width: f32,
+    num_boxes: usize,
+}
+
+impl Default for BoxPainting {
+    fn default() -> Self {
+        Self {
+            size: vec2(64.0, 32.0),
+            rounding: 5.0,
+            stroke_width: 2.0,
+            num_boxes: 1,
+        }
+    }
+}
+
+impl BoxPainting {
+    pub fn ui(&mut self, ui: &mut Ui) {
+        ui.add(Slider::new(&mut self.size.x, 0.0..=500.0).text("width"));
+        ui.add(Slider::new(&mut self.size.y, 0.0..=500.0).text("height"));
+        ui.add(Slider::new(&mut self.rounding, 0.0..=50.0).text("rounding"));
+        ui.add(Slider::new(&mut self.stroke_width, 0.0..=10.0).text("stroke_width"));
+        ui.add(Slider::new(&mut self.num_boxes, 0..=8).text("num_boxes"));
+
+        ui.horizontal_wrapped(|ui| {
+            for _ in 0..self.num_boxes {
+                let (rect, _response) = ui.allocate_at_least(self.size, Sense::hover());
+                ui.painter().rect(
+                    rect,
+                    self.rounding,
+                    Color32::from_gray(64),
+                    Stroke::new(self.stroke_width, Color32::WHITE),
+                );
+            }
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+struct CustomCollapsingHeader {
+    selected: bool,
+    radio_value: bool,
+}
+
+impl Default for CustomCollapsingHeader {
+    fn default() -> Self {
+        Self {
+            selected: true,
+            radio_value: false,
+        }
+    }
+}
+
+impl CustomCollapsingHeader {
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.label("Example of a collapsing header with custom header:");
+
+        let id = ui.make_persistent_id("my_collapsing_header");
+        egui::collapsing_header::CollapsingState::load_with_default_open(ui.ctx(), id, true)
+            .show_header(ui, |ui| {
+                ui.toggle_value(&mut self.selected, "Click to select/unselect");
+                ui.radio_value(&mut self.radio_value, false, "");
+                ui.radio_value(&mut self.radio_value, true, "");
+            })
+            .body(|ui| {
+                ui.label("The body is always custom");
+            });
+
+        CollapsingHeader::new("Normal collapsing header for comparison").show(ui, |ui| {
+            ui.label("Nothing exciting here");
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, PartialEq)]
+enum Action {
+    Keep,
+    Delete,
+}
+
+#[derive(Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+struct Tree(Vec<Tree>);
+
+impl Tree {
+    pub fn demo() -> Self {
+        Self(vec![
+            Tree(vec![Tree::default(); 4]),
+            Tree(vec![Tree(vec![Tree::default(); 2]); 3]),
+        ])
+    }
+
+    pub fn ui(&mut self, ui: &mut Ui) -> Action {
+        self.ui_impl(ui, 0, "root")
+    }
+}
+
+impl Tree {
+    fn ui_impl(&mut self, ui: &mut Ui, depth: usize, name: &str) -> Action {
+        CollapsingHeader::new(name)
+            .default_open(depth < 1)
+            .show(ui, |ui| self.children_ui(ui, depth))
+            .body_returned
+            .unwrap_or(Action::Keep)
+    }
+
+    fn children_ui(&mut self, ui: &mut Ui, depth: usize) -> Action {
+        if depth > 0
+            && ui
+                .button(RichText::new("delete").color(ui.visuals().warn_fg_color))
+                .clicked()
+        {
+            return Action::Delete;
+        }
+
+        self.0 = std::mem::take(self)
+            .0
+            .into_iter()
+            .enumerate()
+            .filter_map(|(i, mut tree)| {
+                if tree.ui_impl(ui, depth + 1, &format!("child #{}", i)) == Action::Keep {
+                    Some(tree)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        if ui.button("+").clicked() {
+            self.0.push(Tree::default());
+        }
+
+        Action::Keep
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn text_layout_ui(
+    ui: &mut egui::Ui,
+    max_rows: &mut usize,
+    break_anywhere: &mut bool,
+    overflow_character: &mut Option<char>,
+) {
+    use egui::text::LayoutJob;
+
+    let mut job = LayoutJob::default();
+
+    let first_row_indentation = 10.0;
+
+    let (default_color, strong_color) = if ui.visuals().dark_mode {
+        (Color32::LIGHT_GRAY, Color32::WHITE)
+    } else {
+        (Color32::DARK_GRAY, Color32::BLACK)
+    };
+
+    job.append(
+        "This is a demonstration of ",
+        first_row_indentation,
+        TextFormat {
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "the egui text layout engine. ",
+        0.0,
+        TextFormat {
+            color: strong_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "It supports ",
+        0.0,
+        TextFormat {
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "different ",
+        0.0,
+        TextFormat {
+            color: Color32::from_rgb(110, 255, 110),
+            ..Default::default()
+        },
+    );
+    job.append(
+        "colors, ",
+        0.0,
+        TextFormat {
+            color: Color32::from_rgb(128, 140, 255),
+            ..Default::default()
+        },
+    );
+    job.append(
+        "backgrounds, ",
+        0.0,
+        TextFormat {
+            color: default_color,
+            background: Color32::from_rgb(128, 32, 32),
+            ..Default::default()
+        },
+    );
+    job.append(
+        "mixing ",
+        0.0,
+        TextFormat {
+            font_id: FontId::proportional(17.0),
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "fonts, ",
+        0.0,
+        TextFormat {
+            font_id: FontId::monospace(12.0),
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "raised text, ",
+        0.0,
+        TextFormat {
+            font_id: FontId::proportional(7.0),
+            color: default_color,
+            valign: Align::TOP,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "with ",
+        0.0,
+        TextFormat {
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "underlining",
+        0.0,
+        TextFormat {
+            color: default_color,
+            underline: Stroke::new(1.0, Color32::LIGHT_BLUE),
+            ..Default::default()
+        },
+    );
+    job.append(
+        " and ",
+        0.0,
+        TextFormat {
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "strikethrough",
+        0.0,
+        TextFormat {
+            color: default_color,
+            strikethrough: Stroke::new(2.0, Color32::RED.linear_multiply(0.5)),
+            ..Default::default()
+        },
+    );
+    job.append(
+        ". Of course, ",
+        0.0,
+        TextFormat {
+            color: default_color,
+            ..Default::default()
+        },
+    );
+    job.append(
+        "you can",
+        0.0,
+        TextFormat {
+            color: default_color,
+            strikethrough: Stroke::new(1.0, strong_color),
+            ..Default::default()
+        },
+    );
+    job.append(
+        " mix these!",
+        0.0,
+        TextFormat {
+            font_id: FontId::proportional(7.0),
+            color: Color32::LIGHT_BLUE,
+            background: Color32::from_rgb(128, 0, 0),
+            underline: Stroke::new(1.0, strong_color),
+            ..Default::default()
+        },
+    );
+
+    ui.label(job);
+
+    ui.separator();
+
+    ui.horizontal(|ui| {
+        ui.add(DragValue::new(max_rows));
+        ui.label("Max rows");
+    });
+    ui.checkbox(break_anywhere, "Break anywhere");
+    ui.horizontal(|ui| {
+        ui.selectable_value(overflow_character, None, "None");
+        ui.selectable_value(overflow_character, Some('…'), "…");
+        ui.selectable_value(overflow_character, Some('—'), "—");
+        ui.selectable_value(overflow_character, Some('-'), "  -  ");
+        ui.label("Overflow character");
+    });
+
+    let mut job = LayoutJob::single_section(LOREM_IPSUM.to_owned(), TextFormat::default());
+    job.wrap = TextWrapping {
+        max_rows: *max_rows,
+        break_anywhere: *break_anywhere,
+        overflow_character: *overflow_character,
+        ..Default::default()
+    };
+    ui.label(job);
+
+    ui.vertical_centered(|ui| {
+        ui.add(crate::egui_github_link_file_line!());
+    });
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/mod.rs b/egui/crates/egui_demo_lib/src/demo/mod.rs
new file mode 100644
index 0000000..dddf215
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/mod.rs
@@ -0,0 +1,53 @@
+//! Demo-code for showing how egui is used.
+//!
+//! The demo-code is also used in benchmarks and tests.
+
+// ----------------------------------------------------------------------------
+
+pub mod about;
+pub mod code_editor;
+pub mod code_example;
+pub mod context_menu;
+pub mod dancing_strings;
+pub mod demo_app_windows;
+pub mod drag_and_drop;
+pub mod font_book;
+pub mod highlighting;
+pub mod layout_test;
+pub mod misc_demo_window;
+pub mod multi_touch;
+pub mod paint_bezier;
+pub mod painting;
+pub mod password;
+pub mod plot_demo;
+pub mod scrolling;
+pub mod sliders;
+pub mod strip_demo;
+pub mod table_demo;
+pub mod tests;
+pub mod text_edit;
+pub mod toggle_switch;
+pub mod widget_gallery;
+pub mod window_options;
+pub mod window_with_panels;
+
+pub use {
+    about::About, demo_app_windows::DemoWindows, misc_demo_window::MiscDemoWindow,
+    widget_gallery::WidgetGallery,
+};
+
+// ----------------------------------------------------------------------------
+
+/// Something to view in the demo windows
+pub trait View {
+    fn ui(&mut self, ui: &mut egui::Ui);
+}
+
+/// Something to view
+pub trait Demo {
+    /// `&'static` so we can also use it as a key to store open/close state.
+    fn name(&self) -> &'static str;
+
+    /// Show windows, etc
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool);
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/multi_touch.rs b/egui/crates/egui_demo_lib/src/demo/multi_touch.rs
new file mode 100644
index 0000000..c358f6b
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/multi_touch.rs
@@ -0,0 +1,145 @@
+use egui::{
+    emath::{RectTransform, Rot2},
+    vec2, Color32, Frame, Pos2, Rect, Sense, Stroke, Vec2,
+};
+
+pub struct MultiTouch {
+    rotation: f32,
+    translation: Vec2,
+    zoom: f32,
+    last_touch_time: f64,
+}
+
+impl Default for MultiTouch {
+    fn default() -> Self {
+        Self {
+            rotation: 0.,
+            translation: Vec2::ZERO,
+            zoom: 1.,
+            last_touch_time: 0.0,
+        }
+    }
+}
+
+impl super::Demo for MultiTouch {
+    fn name(&self) -> &'static str {
+        "👌 Multi Touch"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .default_size(vec2(512.0, 512.0))
+            .resizable(true)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for MultiTouch {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+        ui.strong(
+            "This demo only works on devices with multitouch support (e.g. mobiles and tablets).",
+        );
+        ui.separator();
+        ui.label("Try touch gestures Pinch/Stretch, Rotation, and Pressure with 2+ fingers.");
+
+        let num_touches = ui.input(|i| i.multi_touch().map_or(0, |mt| mt.num_touches));
+        ui.label(format!("Current touches: {}", num_touches));
+
+        let color = if ui.visuals().dark_mode {
+            Color32::WHITE
+        } else {
+            Color32::BLACK
+        };
+
+        Frame::canvas(ui.style()).show(ui, |ui| {
+            // Note that we use `Sense::drag()` although we do not use any pointer events. With
+            // the current implementation, the fact that a touch event of two or more fingers is
+            // recognized, does not mean that the pointer events are suppressed, which are always
+            // generated for the first finger. Therefore, if we do not explicitly consume pointer
+            // events, the window will move around, not only when dragged with a single finger, but
+            // also when a two-finger touch is active. I guess this problem can only be cleanly
+            // solved when the synthetic pointer events are created by egui, and not by the
+            // backend.
+
+            // set up the drawing canvas with normalized coordinates:
+            let (response, painter) =
+                ui.allocate_painter(ui.available_size_before_wrap(), Sense::drag());
+
+            // normalize painter coordinates to ±1 units in each direction with [0,0] in the center:
+            let painter_proportions = response.rect.square_proportions();
+            let to_screen = RectTransform::from_to(
+                Rect::from_min_size(Pos2::ZERO - painter_proportions, 2. * painter_proportions),
+                response.rect,
+            );
+
+            // check for touch input (or the lack thereof) and update zoom and scale factors, plus
+            // color and width:
+            let mut stroke_width = 1.;
+            if let Some(multi_touch) = ui.ctx().multi_touch() {
+                // This adjusts the current zoom factor and rotation angle according to the dynamic
+                // change (for the current frame) of the touch gesture:
+                self.zoom *= multi_touch.zoom_delta;
+                self.rotation += multi_touch.rotation_delta;
+                // the translation we get from `multi_touch` needs to be scaled down to the
+                // normalized coordinates we use as the basis for painting:
+                self.translation += to_screen.inverse().scale() * multi_touch.translation_delta;
+                // touch pressure will make the arrow thicker (not all touch devices support this):
+                stroke_width += 10. * multi_touch.force;
+
+                self.last_touch_time = ui.input(|i| i.time);
+            } else {
+                self.slowly_reset(ui);
+            }
+            let zoom_and_rotate = self.zoom * Rot2::from_angle(self.rotation);
+            let arrow_start_offset = self.translation + zoom_and_rotate * vec2(-0.5, 0.5);
+
+            // Paints an arrow pointing from bottom-left (-0.5, 0.5) to top-right (0.5, -0.5), but
+            // scaled, rotated, and translated according to the current touch gesture:
+            let arrow_start = Pos2::ZERO + arrow_start_offset;
+            let arrow_direction = zoom_and_rotate * vec2(1., -1.);
+            painter.arrow(
+                to_screen * arrow_start,
+                to_screen.scale() * arrow_direction,
+                Stroke::new(stroke_width, color),
+            );
+        });
+    }
+}
+
+impl MultiTouch {
+    fn slowly_reset(&mut self, ui: &egui::Ui) {
+        // This has nothing to do with the touch gesture. It just smoothly brings the
+        // painted arrow back into its original position, for a nice visual effect:
+
+        let time_since_last_touch = (ui.input(|i| i.time) - self.last_touch_time) as f32;
+
+        let delay = 0.5;
+        if time_since_last_touch < delay {
+            ui.ctx().request_repaint();
+        } else {
+            // seconds after which half the amount of zoom/rotation will be reverted:
+            let half_life =
+                egui::remap_clamp(time_since_last_touch, delay..=1.0, 1.0..=0.0).powf(4.0);
+
+            if half_life <= 1e-3 {
+                self.zoom = 1.0;
+                self.rotation = 0.0;
+                self.translation = Vec2::ZERO;
+            } else {
+                let dt = ui.input(|i| i.unstable_dt);
+                let half_life_factor = (-(2_f32.ln()) / half_life * dt).exp();
+                self.zoom = 1. + ((self.zoom - 1.) * half_life_factor);
+                self.rotation *= half_life_factor;
+                self.translation *= half_life_factor;
+                ui.ctx().request_repaint();
+            }
+        }
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/paint_bezier.rs b/egui/crates/egui_demo_lib/src/demo/paint_bezier.rs
new file mode 100644
index 0000000..ad507de
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/paint_bezier.rs
@@ -0,0 +1,171 @@
+use egui::epaint::{CubicBezierShape, PathShape, QuadraticBezierShape};
+use egui::*;
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct PaintBezier {
+    /// Bézier curve degree, it can be 3, 4.
+    degree: usize,
+
+    /// The control points. The [`Self::degree`] first of them are used.
+    control_points: [Pos2; 4],
+
+    /// Stroke for Bézier curve.
+    stroke: Stroke,
+
+    /// Fill for Bézier curve.
+    fill: Color32,
+
+    /// Stroke for auxiliary lines.
+    aux_stroke: Stroke,
+
+    bounding_box_stroke: Stroke,
+}
+
+impl Default for PaintBezier {
+    fn default() -> Self {
+        Self {
+            degree: 4,
+            control_points: [
+                pos2(50.0, 50.0),
+                pos2(60.0, 250.0),
+                pos2(200.0, 200.0),
+                pos2(250.0, 50.0),
+            ],
+            stroke: Stroke::new(1.0, Color32::from_rgb(25, 200, 100)),
+            fill: Color32::from_rgb(50, 100, 150).linear_multiply(0.25),
+            aux_stroke: Stroke::new(1.0, Color32::RED.linear_multiply(0.25)),
+            bounding_box_stroke: Stroke::new(0.0, Color32::LIGHT_GREEN.linear_multiply(0.25)),
+        }
+    }
+}
+
+impl PaintBezier {
+    pub fn ui_control(&mut self, ui: &mut egui::Ui) {
+        ui.collapsing("Colors", |ui| {
+            ui.horizontal(|ui| {
+                ui.label("Fill color:");
+                ui.color_edit_button_srgba(&mut self.fill);
+            });
+            egui::stroke_ui(ui, &mut self.stroke, "Curve Stroke");
+            egui::stroke_ui(ui, &mut self.aux_stroke, "Auxiliary Stroke");
+            egui::stroke_ui(ui, &mut self.bounding_box_stroke, "Bounding Box Stroke");
+        });
+
+        ui.collapsing("Global tessellation options", |ui| {
+            let mut tessellation_options = ui.ctx().tessellation_options(|to| *to);
+            tessellation_options.ui(ui);
+            ui.ctx()
+                .tessellation_options_mut(|to| *to = tessellation_options);
+        });
+
+        ui.radio_value(&mut self.degree, 3, "Quadratic Bézier");
+        ui.radio_value(&mut self.degree, 4, "Cubic Bézier");
+        ui.label("Move the points by dragging them.");
+        ui.small("Only convex curves can be accurately filled.");
+    }
+
+    pub fn ui_content(&mut self, ui: &mut Ui) -> egui::Response {
+        let (response, painter) =
+            ui.allocate_painter(Vec2::new(ui.available_width(), 300.0), Sense::hover());
+
+        let to_screen = emath::RectTransform::from_to(
+            Rect::from_min_size(Pos2::ZERO, response.rect.size()),
+            response.rect,
+        );
+
+        let control_point_radius = 8.0;
+
+        let control_point_shapes: Vec<Shape> = self
+            .control_points
+            .iter_mut()
+            .enumerate()
+            .take(self.degree)
+            .map(|(i, point)| {
+                let size = Vec2::splat(2.0 * control_point_radius);
+
+                let point_in_screen = to_screen.transform_pos(*point);
+                let point_rect = Rect::from_center_size(point_in_screen, size);
+                let point_id = response.id.with(i);
+                let point_response = ui.interact(point_rect, point_id, Sense::drag());
+
+                *point += point_response.drag_delta();
+                *point = to_screen.from().clamp(*point);
+
+                let point_in_screen = to_screen.transform_pos(*point);
+                let stroke = ui.style().interact(&point_response).fg_stroke;
+
+                Shape::circle_stroke(point_in_screen, control_point_radius, stroke)
+            })
+            .collect();
+
+        let points_in_screen: Vec<Pos2> = self
+            .control_points
+            .iter()
+            .take(self.degree)
+            .map(|p| to_screen * *p)
+            .collect();
+
+        match self.degree {
+            3 => {
+                let points = points_in_screen.clone().try_into().unwrap();
+                let shape =
+                    QuadraticBezierShape::from_points_stroke(points, true, self.fill, self.stroke);
+                painter.add(epaint::RectShape::stroke(
+                    shape.visual_bounding_rect(),
+                    0.0,
+                    self.bounding_box_stroke,
+                ));
+                painter.add(shape);
+            }
+            4 => {
+                let points = points_in_screen.clone().try_into().unwrap();
+                let shape =
+                    CubicBezierShape::from_points_stroke(points, true, self.fill, self.stroke);
+                painter.add(epaint::RectShape::stroke(
+                    shape.visual_bounding_rect(),
+                    0.0,
+                    self.bounding_box_stroke,
+                ));
+                painter.add(shape);
+            }
+            _ => {
+                unreachable!();
+            }
+        };
+
+        painter.add(PathShape::line(points_in_screen, self.aux_stroke));
+        painter.extend(control_point_shapes);
+
+        response
+    }
+}
+
+impl super::Demo for PaintBezier {
+    fn name(&self) -> &'static str {
+        "） Bézier Curve"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .vscroll(false)
+            .resizable(false)
+            .default_size([300.0, 350.0])
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for PaintBezier {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+        self.ui_control(ui);
+
+        Frame::canvas(ui.style()).show(ui, |ui| {
+            self.ui_content(ui);
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/painting.rs b/egui/crates/egui_demo_lib/src/demo/painting.rs
new file mode 100644
index 0000000..57e5f11
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/painting.rs
@@ -0,0 +1,100 @@
+use egui::*;
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Painting {
+    /// in 0-1 normalized coordinates
+    lines: Vec<Vec<Pos2>>,
+    stroke: Stroke,
+}
+
+impl Default for Painting {
+    fn default() -> Self {
+        Self {
+            lines: Default::default(),
+            stroke: Stroke::new(1.0, Color32::from_rgb(25, 200, 100)),
+        }
+    }
+}
+
+impl Painting {
+    pub fn ui_control(&mut self, ui: &mut egui::Ui) -> egui::Response {
+        ui.horizontal(|ui| {
+            egui::stroke_ui(ui, &mut self.stroke, "Stroke");
+            ui.separator();
+            if ui.button("Clear Painting").clicked() {
+                self.lines.clear();
+            }
+        })
+        .response
+    }
+
+    pub fn ui_content(&mut self, ui: &mut Ui) -> egui::Response {
+        let (mut response, painter) =
+            ui.allocate_painter(ui.available_size_before_wrap(), Sense::drag());
+
+        let to_screen = emath::RectTransform::from_to(
+            Rect::from_min_size(Pos2::ZERO, response.rect.square_proportions()),
+            response.rect,
+        );
+        let from_screen = to_screen.inverse();
+
+        if self.lines.is_empty() {
+            self.lines.push(vec![]);
+        }
+
+        let current_line = self.lines.last_mut().unwrap();
+
+        if let Some(pointer_pos) = response.interact_pointer_pos() {
+            let canvas_pos = from_screen * pointer_pos;
+            if current_line.last() != Some(&canvas_pos) {
+                current_line.push(canvas_pos);
+                response.mark_changed();
+            }
+        } else if !current_line.is_empty() {
+            self.lines.push(vec![]);
+            response.mark_changed();
+        }
+
+        let shapes = self
+            .lines
+            .iter()
+            .filter(|line| line.len() >= 2)
+            .map(|line| {
+                let points: Vec<Pos2> = line.iter().map(|p| to_screen * *p).collect();
+                egui::Shape::line(points, self.stroke)
+            });
+
+        painter.extend(shapes);
+
+        response
+    }
+}
+
+impl super::Demo for Painting {
+    fn name(&self) -> &'static str {
+        "🖊 Painting"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .default_size(vec2(512.0, 512.0))
+            .vscroll(false)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for Painting {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+        self.ui_control(ui);
+        ui.label("Paint with your mouse/touch!");
+        Frame::canvas(ui.style()).show(ui, |ui| {
+            self.ui_content(ui);
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/password.rs b/egui/crates/egui_demo_lib/src/demo/password.rs
new file mode 100644
index 0000000..528f5a5
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/password.rs
@@ -0,0 +1,66 @@
+//! Source code example about creating a widget which uses `egui::Memory` to store UI state.
+//!
+//! This is meant to be read as a tutorial, hence the plethora of comments.
+
+/// Password entry field with ability to toggle character hiding.
+///
+/// ## Example:
+/// ``` ignore
+/// password_ui(ui, &mut my_password);
+/// ```
+#[allow(clippy::ptr_arg)] // false positive
+pub fn password_ui(ui: &mut egui::Ui, password: &mut String) -> egui::Response {
+    // This widget has its own state — show or hide password characters (`show_plaintext`).
+    // In this case we use a simple `bool`, but you can also declare your own type.
+    // It must implement at least `Clone` and be `'static`.
+    // If you use the `persistence` feature, it also must implement `serde::{Deserialize, Serialize}`.
+
+    // Generate an id for the state
+    let state_id = ui.id().with("show_plaintext");
+
+    // Get state for this widget.
+    // You should get state by value, not by reference to avoid borrowing of [`Memory`].
+    let mut show_plaintext = ui.data_mut(|d| d.get_temp::<bool>(state_id).unwrap_or(false));
+
+    // Process ui, change a local copy of the state
+    // We want TextEdit to fill entire space, and have button after that, so in that case we can
+    // change direction to right_to_left.
+    let result = ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+        // Toggle the `show_plaintext` bool with a button:
+        let response = ui
+            .add(egui::SelectableLabel::new(show_plaintext, "👁"))
+            .on_hover_text("Show/hide password");
+
+        if response.clicked() {
+            show_plaintext = !show_plaintext;
+        }
+
+        // Show the password field:
+        ui.add_sized(
+            ui.available_size(),
+            egui::TextEdit::singleline(password).password(!show_plaintext),
+        );
+    });
+
+    // Store the (possibly changed) state:
+    ui.data_mut(|d| d.insert_temp(state_id, show_plaintext));
+
+    // All done! Return the interaction response so the user can check what happened
+    // (hovered, clicked, …) and maybe show a tooltip:
+    result.response
+}
+
+// A wrapper that allows the more idiomatic usage pattern: `ui.add(…)`
+/// Password entry field with ability to toggle character hiding.
+///
+/// ## Example:
+/// ``` ignore
+/// ui.add(password(&mut my_password));
+/// ```
+pub fn password(password: &mut String) -> impl egui::Widget + '_ {
+    move |ui: &mut egui::Ui| password_ui(ui, password)
+}
+
+pub fn url_to_file_source_code() -> String {
+    format!("https://github.com/emilk/egui/blob/master/{}", file!())
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/plot_demo.rs b/egui/crates/egui_demo_lib/src/demo/plot_demo.rs
new file mode 100644
index 0000000..0865bf7
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/plot_demo.rs
@@ -0,0 +1,978 @@
+use std::f64::consts::TAU;
+use std::ops::RangeInclusive;
+
+use egui::plot::{GridInput, GridMark};
+use egui::*;
+use plot::{
+    Arrows, Bar, BarChart, BoxElem, BoxPlot, BoxSpread, CoordinatesFormatter, Corner, HLine,
+    Legend, Line, LineStyle, MarkerShape, Plot, PlotImage, PlotPoint, PlotPoints, Points, Polygon,
+    Text, VLine,
+};
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq, Eq)]
+enum Panel {
+    Lines,
+    Markers,
+    Legend,
+    Charts,
+    Items,
+    Interaction,
+    CustomAxes,
+    LinkedAxes,
+}
+
+impl Default for Panel {
+    fn default() -> Self {
+        Self::Lines
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq, Default)]
+pub struct PlotDemo {
+    line_demo: LineDemo,
+    marker_demo: MarkerDemo,
+    legend_demo: LegendDemo,
+    charts_demo: ChartsDemo,
+    items_demo: ItemsDemo,
+    interaction_demo: InteractionDemo,
+    custom_axes_demo: CustomAxisDemo,
+    linked_axes_demo: LinkedAxisDemo,
+    open_panel: Panel,
+}
+
+impl super::Demo for PlotDemo {
+    fn name(&self) -> &'static str {
+        "🗠 Plot"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .default_size(vec2(400.0, 400.0))
+            .vscroll(false)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for PlotDemo {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            egui::reset_button(ui, self);
+            ui.collapsing("Instructions", |ui| {
+                ui.label("Pan by dragging, or scroll (+ shift = horizontal).");
+                ui.label("Box zooming: Right click to zoom in and zoom out using a selection.");
+                if cfg!(target_arch = "wasm32") {
+                    ui.label("Zoom with ctrl / ⌘ + pointer wheel, or with pinch gesture.");
+                } else if cfg!(target_os = "macos") {
+                    ui.label("Zoom with ctrl / ⌘ + scroll.");
+                } else {
+                    ui.label("Zoom with ctrl + scroll.");
+                }
+                ui.label("Reset view with double-click.");
+                ui.add(crate::egui_github_link_file!());
+            });
+        });
+        ui.separator();
+        ui.horizontal(|ui| {
+            ui.selectable_value(&mut self.open_panel, Panel::Lines, "Lines");
+            ui.selectable_value(&mut self.open_panel, Panel::Markers, "Markers");
+            ui.selectable_value(&mut self.open_panel, Panel::Legend, "Legend");
+            ui.selectable_value(&mut self.open_panel, Panel::Charts, "Charts");
+            ui.selectable_value(&mut self.open_panel, Panel::Items, "Items");
+            ui.selectable_value(&mut self.open_panel, Panel::Interaction, "Interaction");
+            ui.selectable_value(&mut self.open_panel, Panel::CustomAxes, "Custom Axes");
+            ui.selectable_value(&mut self.open_panel, Panel::LinkedAxes, "Linked Axes");
+        });
+        ui.separator();
+
+        match self.open_panel {
+            Panel::Lines => {
+                self.line_demo.ui(ui);
+            }
+            Panel::Markers => {
+                self.marker_demo.ui(ui);
+            }
+            Panel::Legend => {
+                self.legend_demo.ui(ui);
+            }
+            Panel::Charts => {
+                self.charts_demo.ui(ui);
+            }
+            Panel::Items => {
+                self.items_demo.ui(ui);
+            }
+            Panel::Interaction => {
+                self.interaction_demo.ui(ui);
+            }
+            Panel::CustomAxes => {
+                self.custom_axes_demo.ui(ui);
+            }
+            Panel::LinkedAxes => {
+                self.linked_axes_demo.ui(ui);
+            }
+        }
+    }
+}
+
+fn is_approx_zero(val: f64) -> bool {
+    val.abs() < 1e-6
+}
+
+fn is_approx_integer(val: f64) -> bool {
+    val.fract().abs() < 1e-6
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq)]
+struct LineDemo {
+    animate: bool,
+    time: f64,
+    circle_radius: f64,
+    circle_center: Pos2,
+    square: bool,
+    proportional: bool,
+    coordinates: bool,
+    line_style: LineStyle,
+}
+
+impl Default for LineDemo {
+    fn default() -> Self {
+        Self {
+            animate: !cfg!(debug_assertions),
+            time: 0.0,
+            circle_radius: 1.5,
+            circle_center: Pos2::new(0.0, 0.0),
+            square: false,
+            proportional: true,
+            coordinates: true,
+            line_style: LineStyle::Solid,
+        }
+    }
+}
+
+impl LineDemo {
+    fn options_ui(&mut self, ui: &mut Ui) {
+        let Self {
+            animate,
+            time: _,
+            circle_radius,
+            circle_center,
+            square,
+            proportional,
+            line_style,
+            coordinates,
+            ..
+        } = self;
+
+        ui.horizontal(|ui| {
+            ui.group(|ui| {
+                ui.vertical(|ui| {
+                    ui.label("Circle:");
+                    ui.add(
+                        egui::DragValue::new(circle_radius)
+                            .speed(0.1)
+                            .clamp_range(0.0..=f64::INFINITY)
+                            .prefix("r: "),
+                    );
+                    ui.horizontal(|ui| {
+                        ui.add(
+                            egui::DragValue::new(&mut circle_center.x)
+                                .speed(0.1)
+                                .prefix("x: "),
+                        );
+                        ui.add(
+                            egui::DragValue::new(&mut circle_center.y)
+                                .speed(1.0)
+                                .prefix("y: "),
+                        );
+                    });
+                });
+            });
+
+            ui.vertical(|ui| {
+                ui.style_mut().wrap = Some(false);
+                ui.checkbox(animate, "Animate");
+                ui.checkbox(square, "Square view")
+                    .on_hover_text("Always keep the viewport square.");
+                ui.checkbox(proportional, "Proportional data axes")
+                    .on_hover_text("Tick are the same size on both axes.");
+                ui.checkbox(coordinates, "Show coordinates")
+                    .on_hover_text("Can take a custom formatting function.");
+
+                ComboBox::from_label("Line style")
+                    .selected_text(line_style.to_string())
+                    .show_ui(ui, |ui| {
+                        for style in &[
+                            LineStyle::Solid,
+                            LineStyle::dashed_dense(),
+                            LineStyle::dashed_loose(),
+                            LineStyle::dotted_dense(),
+                            LineStyle::dotted_loose(),
+                        ] {
+                            ui.selectable_value(line_style, *style, style.to_string());
+                        }
+                    });
+            });
+        });
+    }
+
+    fn circle(&self) -> Line {
+        let n = 512;
+        let circle_points: PlotPoints = (0..=n)
+            .map(|i| {
+                let t = remap(i as f64, 0.0..=(n as f64), 0.0..=TAU);
+                let r = self.circle_radius;
+                [
+                    r * t.cos() + self.circle_center.x as f64,
+                    r * t.sin() + self.circle_center.y as f64,
+                ]
+            })
+            .collect();
+        Line::new(circle_points)
+            .color(Color32::from_rgb(100, 200, 100))
+            .style(self.line_style)
+            .name("circle")
+    }
+
+    fn sin(&self) -> Line {
+        let time = self.time;
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| 0.5 * (2.0 * x).sin() * time.sin(),
+            ..,
+            512,
+        ))
+        .color(Color32::from_rgb(200, 100, 100))
+        .style(self.line_style)
+        .name("wave")
+    }
+
+    fn thingy(&self) -> Line {
+        let time = self.time;
+        Line::new(PlotPoints::from_parametric_callback(
+            move |t| ((2.0 * t + time).sin(), (3.0 * t).sin()),
+            0.0..=TAU,
+            256,
+        ))
+        .color(Color32::from_rgb(100, 150, 250))
+        .style(self.line_style)
+        .name("x = sin(2t), y = sin(3t)")
+    }
+}
+
+impl LineDemo {
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        self.options_ui(ui);
+        if self.animate {
+            ui.ctx().request_repaint();
+            self.time += ui.input(|i| i.unstable_dt).at_most(1.0 / 30.0) as f64;
+        };
+        let mut plot = Plot::new("lines_demo").legend(Legend::default());
+        if self.square {
+            plot = plot.view_aspect(1.0);
+        }
+        if self.proportional {
+            plot = plot.data_aspect(1.0);
+        }
+        if self.coordinates {
+            plot = plot.coordinates_formatter(Corner::LeftBottom, CoordinatesFormatter::default());
+        }
+        plot.show(ui, |plot_ui| {
+            plot_ui.line(self.circle());
+            plot_ui.line(self.sin());
+            plot_ui.line(self.thingy());
+        })
+        .response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq)]
+struct MarkerDemo {
+    fill_markers: bool,
+    marker_radius: f32,
+    automatic_colors: bool,
+    marker_color: Color32,
+}
+
+impl Default for MarkerDemo {
+    fn default() -> Self {
+        Self {
+            fill_markers: true,
+            marker_radius: 5.0,
+            automatic_colors: true,
+            marker_color: Color32::GREEN,
+        }
+    }
+}
+
+impl MarkerDemo {
+    fn markers(&self) -> Vec<Points> {
+        MarkerShape::all()
+            .enumerate()
+            .map(|(i, marker)| {
+                let y_offset = i as f64 * 0.5 + 1.0;
+                let mut points = Points::new(vec![
+                    [1.0, 0.0 + y_offset],
+                    [2.0, 0.5 + y_offset],
+                    [3.0, 0.0 + y_offset],
+                    [4.0, 0.5 + y_offset],
+                    [5.0, 0.0 + y_offset],
+                    [6.0, 0.5 + y_offset],
+                ])
+                .name(format!("{:?}", marker))
+                .filled(self.fill_markers)
+                .radius(self.marker_radius)
+                .shape(marker);
+
+                if !self.automatic_colors {
+                    points = points.color(self.marker_color);
+                }
+
+                points
+            })
+            .collect()
+    }
+
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        ui.horizontal(|ui| {
+            ui.checkbox(&mut self.fill_markers, "Fill");
+            ui.add(
+                egui::DragValue::new(&mut self.marker_radius)
+                    .speed(0.1)
+                    .clamp_range(0.0..=f64::INFINITY)
+                    .prefix("Radius: "),
+            );
+            ui.checkbox(&mut self.automatic_colors, "Automatic colors");
+            if !self.automatic_colors {
+                ui.color_edit_button_srgba(&mut self.marker_color);
+            }
+        });
+
+        let markers_plot = Plot::new("markers_demo")
+            .data_aspect(1.0)
+            .legend(Legend::default());
+        markers_plot
+            .show(ui, |plot_ui| {
+                for marker in self.markers() {
+                    plot_ui.points(marker);
+                }
+            })
+            .response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default, PartialEq)]
+struct LegendDemo {
+    config: Legend,
+}
+
+impl LegendDemo {
+    fn line_with_slope(slope: f64) -> Line {
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| slope * x,
+            ..,
+            100,
+        ))
+    }
+
+    fn sin() -> Line {
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| x.sin(),
+            ..,
+            100,
+        ))
+    }
+
+    fn cos() -> Line {
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| x.cos(),
+            ..,
+            100,
+        ))
+    }
+
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        let LegendDemo { config } = self;
+
+        egui::Grid::new("settings").show(ui, |ui| {
+            ui.label("Text style:");
+            ui.horizontal(|ui| {
+                let all_text_styles = ui.style().text_styles();
+                for style in all_text_styles {
+                    ui.selectable_value(&mut config.text_style, style.clone(), style.to_string());
+                }
+            });
+            ui.end_row();
+
+            ui.label("Position:");
+            ui.horizontal(|ui| {
+                Corner::all().for_each(|position| {
+                    ui.selectable_value(&mut config.position, position, format!("{:?}", position));
+                });
+            });
+            ui.end_row();
+
+            ui.label("Opacity:");
+            ui.add(
+                egui::DragValue::new(&mut config.background_alpha)
+                    .speed(0.02)
+                    .clamp_range(0.0..=1.0),
+            );
+            ui.end_row();
+        });
+
+        let legend_plot = Plot::new("legend_demo")
+            .legend(config.clone())
+            .data_aspect(1.0);
+        legend_plot
+            .show(ui, |plot_ui| {
+                plot_ui.line(LegendDemo::line_with_slope(0.5).name("lines"));
+                plot_ui.line(LegendDemo::line_with_slope(1.0).name("lines"));
+                plot_ui.line(LegendDemo::line_with_slope(2.0).name("lines"));
+                plot_ui.line(LegendDemo::sin().name("sin(x)"));
+                plot_ui.line(LegendDemo::cos().name("cos(x)"));
+            })
+            .response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq, Default)]
+struct CustomAxisDemo {}
+
+impl CustomAxisDemo {
+    const MINS_PER_DAY: f64 = 24.0 * 60.0;
+    const MINS_PER_H: f64 = 60.0;
+
+    fn logistic_fn() -> Line {
+        fn days(min: f64) -> f64 {
+            CustomAxisDemo::MINS_PER_DAY * min
+        }
+
+        let values = PlotPoints::from_explicit_callback(
+            move |x| 1.0 / (1.0 + (-2.5 * (x / CustomAxisDemo::MINS_PER_DAY - 2.0)).exp()),
+            days(0.0)..days(5.0),
+            100,
+        );
+        Line::new(values)
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn x_grid(input: GridInput) -> Vec<GridMark> {
+        // Note: this always fills all possible marks. For optimization, `input.bounds`
+        // could be used to decide when the low-interval grids (minutes) should be added.
+
+        let mut marks = vec![];
+
+        let (min, max) = input.bounds;
+        let min = min.floor() as i32;
+        let max = max.ceil() as i32;
+
+        for i in min..=max {
+            let step_size = if i % Self::MINS_PER_DAY as i32 == 0 {
+                // 1 day
+                Self::MINS_PER_DAY
+            } else if i % Self::MINS_PER_H as i32 == 0 {
+                // 1 hour
+                Self::MINS_PER_H
+            } else if i % 5 == 0 {
+                // 5min
+                5.0
+            } else {
+                // skip grids below 5min
+                continue;
+            };
+
+            marks.push(GridMark {
+                value: i as f64,
+                step_size,
+            });
+        }
+
+        marks
+    }
+
+    #[allow(clippy::unused_self)]
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        const MINS_PER_DAY: f64 = CustomAxisDemo::MINS_PER_DAY;
+        const MINS_PER_H: f64 = CustomAxisDemo::MINS_PER_H;
+
+        fn day(x: f64) -> f64 {
+            (x / MINS_PER_DAY).floor()
+        }
+
+        fn hour(x: f64) -> f64 {
+            (x.rem_euclid(MINS_PER_DAY) / MINS_PER_H).floor()
+        }
+
+        fn minute(x: f64) -> f64 {
+            x.rem_euclid(MINS_PER_H).floor()
+        }
+
+        fn percent(y: f64) -> f64 {
+            100.0 * y
+        }
+
+        let x_fmt = |x, _range: &RangeInclusive<f64>| {
+            if x < 0.0 * MINS_PER_DAY || x >= 5.0 * MINS_PER_DAY {
+                // No labels outside value bounds
+                String::new()
+            } else if is_approx_integer(x / MINS_PER_DAY) {
+                // Days
+                format!("Day {}", day(x))
+            } else {
+                // Hours and minutes
+                format!("{h}:{m:02}", h = hour(x), m = minute(x))
+            }
+        };
+
+        let y_fmt = |y, _range: &RangeInclusive<f64>| {
+            // Display only integer percentages
+            if !is_approx_zero(y) && is_approx_integer(100.0 * y) {
+                format!("{:.0}%", percent(y))
+            } else {
+                String::new()
+            }
+        };
+
+        let label_fmt = |_s: &str, val: &PlotPoint| {
+            format!(
+                "Day {d}, {h}:{m:02}\n{p:.2}%",
+                d = day(val.x),
+                h = hour(val.x),
+                m = minute(val.x),
+                p = percent(val.y)
+            )
+        };
+
+        ui.label("Zoom in on the X-axis to see hours and minutes");
+
+        Plot::new("custom_axes")
+            .data_aspect(2.0 * MINS_PER_DAY as f32)
+            .x_axis_formatter(x_fmt)
+            .y_axis_formatter(y_fmt)
+            .x_grid_spacer(CustomAxisDemo::x_grid)
+            .label_formatter(label_fmt)
+            .show(ui, |plot_ui| {
+                plot_ui.line(CustomAxisDemo::logistic_fn());
+            })
+            .response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq)]
+struct LinkedAxisDemo {
+    link_x: bool,
+    link_y: bool,
+    link_cursor_x: bool,
+    link_cursor_y: bool,
+}
+
+impl Default for LinkedAxisDemo {
+    fn default() -> Self {
+        let link_x = true;
+        let link_y = false;
+        let link_cursor_x = true;
+        let link_cursor_y = false;
+        Self {
+            link_x,
+            link_y,
+            link_cursor_x,
+            link_cursor_y,
+        }
+    }
+}
+
+impl LinkedAxisDemo {
+    fn line_with_slope(slope: f64) -> Line {
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| slope * x,
+            ..,
+            100,
+        ))
+    }
+
+    fn sin() -> Line {
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| x.sin(),
+            ..,
+            100,
+        ))
+    }
+
+    fn cos() -> Line {
+        Line::new(PlotPoints::from_explicit_callback(
+            move |x| x.cos(),
+            ..,
+            100,
+        ))
+    }
+
+    fn configure_plot(plot_ui: &mut plot::PlotUi) {
+        plot_ui.line(LinkedAxisDemo::line_with_slope(0.5));
+        plot_ui.line(LinkedAxisDemo::line_with_slope(1.0));
+        plot_ui.line(LinkedAxisDemo::line_with_slope(2.0));
+        plot_ui.line(LinkedAxisDemo::sin());
+        plot_ui.line(LinkedAxisDemo::cos());
+    }
+
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        ui.horizontal(|ui| {
+            ui.label("Linked axes:");
+            ui.checkbox(&mut self.link_x, "X");
+            ui.checkbox(&mut self.link_y, "Y");
+        });
+        ui.horizontal(|ui| {
+            ui.label("Linked cursors:");
+            ui.checkbox(&mut self.link_cursor_x, "X");
+            ui.checkbox(&mut self.link_cursor_y, "Y");
+        });
+
+        let link_group_id = ui.id().with("linked_demo");
+        ui.horizontal(|ui| {
+            Plot::new("linked_axis_1")
+                .data_aspect(1.0)
+                .width(250.0)
+                .height(250.0)
+                .link_axis(link_group_id, self.link_x, self.link_y)
+                .link_cursor(link_group_id, self.link_cursor_x, self.link_cursor_y)
+                .show(ui, LinkedAxisDemo::configure_plot);
+            Plot::new("linked_axis_2")
+                .data_aspect(2.0)
+                .width(150.0)
+                .height(250.0)
+                .link_axis(link_group_id, self.link_x, self.link_y)
+                .link_cursor(link_group_id, self.link_cursor_x, self.link_cursor_y)
+                .show(ui, LinkedAxisDemo::configure_plot);
+        });
+        Plot::new("linked_axis_3")
+            .data_aspect(0.5)
+            .width(250.0)
+            .height(150.0)
+            .link_axis(link_group_id, self.link_x, self.link_y)
+            .link_cursor(link_group_id, self.link_cursor_x, self.link_cursor_y)
+            .show(ui, LinkedAxisDemo::configure_plot)
+            .response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq, Default)]
+struct ItemsDemo {
+    texture: Option<egui::TextureHandle>,
+}
+
+impl ItemsDemo {
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        let n = 100;
+        let mut sin_values: Vec<_> = (0..=n)
+            .map(|i| remap(i as f64, 0.0..=n as f64, -TAU..=TAU))
+            .map(|i| [i, i.sin()])
+            .collect();
+
+        let line = Line::new(sin_values.split_off(n / 2)).fill(-1.5);
+        let polygon = Polygon::new(PlotPoints::from_parametric_callback(
+            |t| (4.0 * t.sin() + 2.0 * t.cos(), 4.0 * t.cos() + 2.0 * t.sin()),
+            0.0..TAU,
+            100,
+        ));
+        let points = Points::new(sin_values).stems(-1.5).radius(1.0);
+
+        let arrows = {
+            let pos_radius = 8.0;
+            let tip_radius = 7.0;
+            let arrow_origins = PlotPoints::from_parametric_callback(
+                |t| (pos_radius * t.sin(), pos_radius * t.cos()),
+                0.0..TAU,
+                36,
+            );
+            let arrow_tips = PlotPoints::from_parametric_callback(
+                |t| (tip_radius * t.sin(), tip_radius * t.cos()),
+                0.0..TAU,
+                36,
+            );
+            Arrows::new(arrow_origins, arrow_tips)
+        };
+
+        let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+            ui.ctx()
+                .load_texture("plot_demo", egui::ColorImage::example(), Default::default())
+        });
+        let image = PlotImage::new(
+            texture,
+            PlotPoint::new(0.0, 10.0),
+            5.0 * vec2(texture.aspect_ratio(), 1.0),
+        );
+
+        let plot = Plot::new("items_demo")
+            .legend(Legend::default().position(Corner::RightBottom))
+            .show_x(false)
+            .show_y(false)
+            .data_aspect(1.0);
+        plot.show(ui, |plot_ui| {
+            plot_ui.hline(HLine::new(9.0).name("Lines horizontal"));
+            plot_ui.hline(HLine::new(-9.0).name("Lines horizontal"));
+            plot_ui.vline(VLine::new(9.0).name("Lines vertical"));
+            plot_ui.vline(VLine::new(-9.0).name("Lines vertical"));
+            plot_ui.line(line.name("Line with fill"));
+            plot_ui.polygon(polygon.name("Convex polygon"));
+            plot_ui.points(points.name("Points with stems"));
+            plot_ui.text(Text::new(PlotPoint::new(-3.0, -3.0), "wow").name("Text"));
+            plot_ui.text(Text::new(PlotPoint::new(-2.0, 2.5), "so graph").name("Text"));
+            plot_ui.text(Text::new(PlotPoint::new(3.0, 3.0), "much color").name("Text"));
+            plot_ui.text(Text::new(PlotPoint::new(2.5, -2.0), "such plot").name("Text"));
+            plot_ui.image(image.name("Image"));
+            plot_ui.arrows(arrows.name("Arrows"));
+        })
+        .response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default, PartialEq)]
+struct InteractionDemo {}
+
+impl InteractionDemo {
+    #[allow(clippy::unused_self)]
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        let plot = Plot::new("interaction_demo").height(300.0);
+
+        let InnerResponse {
+            response,
+            inner: (screen_pos, pointer_coordinate, pointer_coordinate_drag_delta, bounds, hovered),
+        } = plot.show(ui, |plot_ui| {
+            (
+                plot_ui.screen_from_plot(PlotPoint::new(0.0, 0.0)),
+                plot_ui.pointer_coordinate(),
+                plot_ui.pointer_coordinate_drag_delta(),
+                plot_ui.plot_bounds(),
+                plot_ui.plot_hovered(),
+            )
+        });
+
+        ui.label(format!(
+            "plot bounds: min: {:.02?}, max: {:.02?}",
+            bounds.min(),
+            bounds.max()
+        ));
+        ui.label(format!(
+            "origin in screen coordinates: x: {:.02}, y: {:.02}",
+            screen_pos.x, screen_pos.y
+        ));
+        ui.label(format!("plot hovered: {}", hovered));
+        let coordinate_text = if let Some(coordinate) = pointer_coordinate {
+            format!("x: {:.02}, y: {:.02}", coordinate.x, coordinate.y)
+        } else {
+            "None".to_owned()
+        };
+        ui.label(format!("pointer coordinate: {}", coordinate_text));
+        let coordinate_text = format!(
+            "x: {:.02}, y: {:.02}",
+            pointer_coordinate_drag_delta.x, pointer_coordinate_drag_delta.y
+        );
+        ui.label(format!(
+            "pointer coordinate drag delta: {}",
+            coordinate_text
+        ));
+
+        response
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq, Eq)]
+enum Chart {
+    GaussBars,
+    StackedBars,
+    BoxPlot,
+}
+
+impl Default for Chart {
+    fn default() -> Self {
+        Self::GaussBars
+    }
+}
+
+#[derive(PartialEq)]
+struct ChartsDemo {
+    chart: Chart,
+    vertical: bool,
+}
+
+impl Default for ChartsDemo {
+    fn default() -> Self {
+        Self {
+            vertical: true,
+            chart: Chart::default(),
+        }
+    }
+}
+
+impl ChartsDemo {
+    fn ui(&mut self, ui: &mut Ui) -> Response {
+        ui.label("Type:");
+        ui.horizontal(|ui| {
+            ui.selectable_value(&mut self.chart, Chart::GaussBars, "Histogram");
+            ui.selectable_value(&mut self.chart, Chart::StackedBars, "Stacked Bar Chart");
+            ui.selectable_value(&mut self.chart, Chart::BoxPlot, "Box Plot");
+        });
+        ui.label("Orientation:");
+        ui.horizontal(|ui| {
+            ui.selectable_value(&mut self.vertical, true, "Vertical");
+            ui.selectable_value(&mut self.vertical, false, "Horizontal");
+        });
+        match self.chart {
+            Chart::GaussBars => self.bar_gauss(ui),
+            Chart::StackedBars => self.bar_stacked(ui),
+            Chart::BoxPlot => self.box_plot(ui),
+        }
+    }
+
+    fn bar_gauss(&self, ui: &mut Ui) -> Response {
+        let mut chart = BarChart::new(
+            (-395..=395)
+                .step_by(10)
+                .map(|x| x as f64 * 0.01)
+                .map(|x| {
+                    (
+                        x,
+                        (-x * x / 2.0).exp() / (2.0 * std::f64::consts::PI).sqrt(),
+                    )
+                })
+                // The 10 factor here is purely for a nice 1:1 aspect ratio
+                .map(|(x, f)| Bar::new(x, f * 10.0).width(0.095))
+                .collect(),
+        )
+        .color(Color32::LIGHT_BLUE)
+        .name("Normal Distribution");
+        if !self.vertical {
+            chart = chart.horizontal();
+        }
+
+        Plot::new("Normal Distribution Demo")
+            .legend(Legend::default())
+            .clamp_grid(true)
+            .show(ui, |plot_ui| plot_ui.bar_chart(chart))
+            .response
+    }
+
+    fn bar_stacked(&self, ui: &mut Ui) -> Response {
+        let mut chart1 = BarChart::new(vec![
+            Bar::new(0.5, 1.0).name("Day 1"),
+            Bar::new(1.5, 3.0).name("Day 2"),
+            Bar::new(2.5, 1.0).name("Day 3"),
+            Bar::new(3.5, 2.0).name("Day 4"),
+            Bar::new(4.5, 4.0).name("Day 5"),
+        ])
+        .width(0.7)
+        .name("Set 1");
+
+        let mut chart2 = BarChart::new(vec![
+            Bar::new(0.5, 1.0),
+            Bar::new(1.5, 1.5),
+            Bar::new(2.5, 0.1),
+            Bar::new(3.5, 0.7),
+            Bar::new(4.5, 0.8),
+        ])
+        .width(0.7)
+        .name("Set 2")
+        .stack_on(&[&chart1]);
+
+        let mut chart3 = BarChart::new(vec![
+            Bar::new(0.5, -0.5),
+            Bar::new(1.5, 1.0),
+            Bar::new(2.5, 0.5),
+            Bar::new(3.5, -1.0),
+            Bar::new(4.5, 0.3),
+        ])
+        .width(0.7)
+        .name("Set 3")
+        .stack_on(&[&chart1, &chart2]);
+
+        let mut chart4 = BarChart::new(vec![
+            Bar::new(0.5, 0.5),
+            Bar::new(1.5, 1.0),
+            Bar::new(2.5, 0.5),
+            Bar::new(3.5, -0.5),
+            Bar::new(4.5, -0.5),
+        ])
+        .width(0.7)
+        .name("Set 4")
+        .stack_on(&[&chart1, &chart2, &chart3]);
+
+        if !self.vertical {
+            chart1 = chart1.horizontal();
+            chart2 = chart2.horizontal();
+            chart3 = chart3.horizontal();
+            chart4 = chart4.horizontal();
+        }
+
+        Plot::new("Stacked Bar Chart Demo")
+            .legend(Legend::default())
+            .data_aspect(1.0)
+            .show(ui, |plot_ui| {
+                plot_ui.bar_chart(chart1);
+                plot_ui.bar_chart(chart2);
+                plot_ui.bar_chart(chart3);
+                plot_ui.bar_chart(chart4);
+            })
+            .response
+    }
+
+    fn box_plot(&self, ui: &mut Ui) -> Response {
+        let yellow = Color32::from_rgb(248, 252, 168);
+        let mut box1 = BoxPlot::new(vec![
+            BoxElem::new(0.5, BoxSpread::new(1.5, 2.2, 2.5, 2.6, 3.1)).name("Day 1"),
+            BoxElem::new(2.5, BoxSpread::new(0.4, 1.0, 1.1, 1.4, 2.1)).name("Day 2"),
+            BoxElem::new(4.5, BoxSpread::new(1.7, 2.0, 2.2, 2.5, 2.9)).name("Day 3"),
+        ])
+        .name("Experiment A");
+
+        let mut box2 = BoxPlot::new(vec![
+            BoxElem::new(1.0, BoxSpread::new(0.2, 0.5, 1.0, 2.0, 2.7)).name("Day 1"),
+            BoxElem::new(3.0, BoxSpread::new(1.5, 1.7, 2.1, 2.9, 3.3))
+                .name("Day 2: interesting")
+                .stroke(Stroke::new(1.5, yellow))
+                .fill(yellow.linear_multiply(0.2)),
+            BoxElem::new(5.0, BoxSpread::new(1.3, 2.0, 2.3, 2.9, 4.0)).name("Day 3"),
+        ])
+        .name("Experiment B");
+
+        let mut box3 = BoxPlot::new(vec![
+            BoxElem::new(1.5, BoxSpread::new(2.1, 2.2, 2.6, 2.8, 3.0)).name("Day 1"),
+            BoxElem::new(3.5, BoxSpread::new(1.3, 1.5, 1.9, 2.2, 2.4)).name("Day 2"),
+            BoxElem::new(5.5, BoxSpread::new(0.2, 0.4, 1.0, 1.3, 1.5)).name("Day 3"),
+        ])
+        .name("Experiment C");
+
+        if !self.vertical {
+            box1 = box1.horizontal();
+            box2 = box2.horizontal();
+            box3 = box3.horizontal();
+        }
+
+        Plot::new("Box Plot Demo")
+            .legend(Legend::default())
+            .show(ui, |plot_ui| {
+                plot_ui.box_plot(box1);
+                plot_ui.box_plot(box2);
+                plot_ui.box_plot(box3);
+            })
+            .response
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/scrolling.rs b/egui/crates/egui_demo_lib/src/demo/scrolling.rs
new file mode 100644
index 0000000..b970b32
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/scrolling.rs
@@ -0,0 +1,299 @@
+use egui::*;
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum ScrollDemo {
+    ScrollTo,
+    ManyLines,
+    LargeCanvas,
+    StickToEnd,
+    Bidirectional,
+}
+
+impl Default for ScrollDemo {
+    fn default() -> Self {
+        Self::ScrollTo
+    }
+}
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+#[derive(Default, PartialEq)]
+pub struct Scrolling {
+    demo: ScrollDemo,
+    scroll_to: ScrollTo,
+    scroll_stick_to: ScrollStickTo,
+}
+
+impl super::Demo for Scrolling {
+    fn name(&self) -> &'static str {
+        "↕ Scrolling"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(false)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for Scrolling {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            ui.selectable_value(&mut self.demo, ScrollDemo::ScrollTo, "Scroll to");
+            ui.selectable_value(
+                &mut self.demo,
+                ScrollDemo::ManyLines,
+                "Scroll a lot of lines",
+            );
+            ui.selectable_value(
+                &mut self.demo,
+                ScrollDemo::LargeCanvas,
+                "Scroll a large canvas",
+            );
+            ui.selectable_value(&mut self.demo, ScrollDemo::StickToEnd, "Stick to end");
+            ui.selectable_value(&mut self.demo, ScrollDemo::Bidirectional, "Bidirectional");
+        });
+        ui.separator();
+        match self.demo {
+            ScrollDemo::ScrollTo => {
+                self.scroll_to.ui(ui);
+            }
+            ScrollDemo::ManyLines => {
+                huge_content_lines(ui);
+            }
+            ScrollDemo::LargeCanvas => {
+                huge_content_painter(ui);
+            }
+            ScrollDemo::StickToEnd => {
+                self.scroll_stick_to.ui(ui);
+            }
+            ScrollDemo::Bidirectional => {
+                egui::ScrollArea::both().show(ui, |ui| {
+                    ui.style_mut().wrap = Some(false);
+                    for _ in 0..100 {
+                        ui.label(crate::LOREM_IPSUM);
+                    }
+                });
+            }
+        }
+    }
+}
+
+fn huge_content_lines(ui: &mut egui::Ui) {
+    ui.label(
+        "A lot of rows, but only the visible ones are laid out, so performance is still good:",
+    );
+    ui.add_space(4.0);
+
+    let text_style = TextStyle::Body;
+    let row_height = ui.text_style_height(&text_style);
+    let num_rows = 10_000;
+    ScrollArea::vertical().auto_shrink([false; 2]).show_rows(
+        ui,
+        row_height,
+        num_rows,
+        |ui, row_range| {
+            for row in row_range {
+                let text = format!("This is row {}/{}", row + 1, num_rows);
+                ui.label(text);
+            }
+        },
+    );
+}
+
+fn huge_content_painter(ui: &mut egui::Ui) {
+    // This is similar to the other demo, but is fully manual, for when you want to do custom painting.
+    ui.label("A lot of rows, but only the visible ones are painted, so performance is still good:");
+    ui.add_space(4.0);
+
+    let font_id = TextStyle::Body.resolve(ui.style());
+    let row_height = ui.fonts(|f| f.row_height(&font_id)) + ui.spacing().item_spacing.y;
+    let num_rows = 10_000;
+
+    ScrollArea::vertical()
+        .auto_shrink([false; 2])
+        .show_viewport(ui, |ui, viewport| {
+            ui.set_height(row_height * num_rows as f32);
+
+            let first_item = (viewport.min.y / row_height).floor().at_least(0.0) as usize;
+            let last_item = (viewport.max.y / row_height).ceil() as usize + 1;
+            let last_item = last_item.at_most(num_rows);
+
+            let mut used_rect = Rect::NOTHING;
+
+            for i in first_item..last_item {
+                let indentation = (i % 100) as f32;
+                let x = ui.min_rect().left() + indentation;
+                let y = ui.min_rect().top() + i as f32 * row_height;
+                let text = format!(
+                    "This is row {}/{}, indented by {} pixels",
+                    i + 1,
+                    num_rows,
+                    indentation
+                );
+                let text_rect = ui.painter().text(
+                    pos2(x, y),
+                    Align2::LEFT_TOP,
+                    text,
+                    font_id.clone(),
+                    ui.visuals().text_color(),
+                );
+                used_rect = used_rect.union(text_rect);
+            }
+
+            ui.allocate_rect(used_rect, Sense::hover()); // make sure it is visible!
+        });
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+#[derive(PartialEq)]
+struct ScrollTo {
+    track_item: usize,
+    tack_item_align: Option<Align>,
+    offset: f32,
+}
+
+impl Default for ScrollTo {
+    fn default() -> Self {
+        Self {
+            track_item: 25,
+            tack_item_align: Some(Align::Center),
+            offset: 0.0,
+        }
+    }
+}
+
+impl super::View for ScrollTo {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.label("This shows how you can scroll to a specific item or pixel offset");
+
+        let mut track_item = false;
+        let mut go_to_scroll_offset = false;
+        let mut scroll_top = false;
+        let mut scroll_bottom = false;
+
+        ui.horizontal(|ui| {
+            ui.label("Scroll to a specific item index:");
+            track_item |= ui
+                .add(Slider::new(&mut self.track_item, 1..=50).text("Track Item"))
+                .dragged();
+        });
+
+        ui.horizontal(|ui| {
+            ui.label("Item align:");
+            track_item |= ui
+                .radio_value(&mut self.tack_item_align, Some(Align::Min), "Top")
+                .clicked();
+            track_item |= ui
+                .radio_value(&mut self.tack_item_align, Some(Align::Center), "Center")
+                .clicked();
+            track_item |= ui
+                .radio_value(&mut self.tack_item_align, Some(Align::Max), "Bottom")
+                .clicked();
+            track_item |= ui
+                .radio_value(&mut self.tack_item_align, None, "None (Bring into view)")
+                .clicked();
+        });
+
+        ui.horizontal(|ui| {
+            ui.label("Scroll to a specific offset:");
+            go_to_scroll_offset |= ui
+                .add(DragValue::new(&mut self.offset).speed(1.0).suffix("px"))
+                .dragged();
+        });
+
+        ui.horizontal(|ui| {
+            scroll_top |= ui.button("Scroll to top").clicked();
+            scroll_bottom |= ui.button("Scroll to bottom").clicked();
+        });
+
+        let mut scroll_area = ScrollArea::vertical()
+            .max_height(200.0)
+            .auto_shrink([false; 2]);
+        if go_to_scroll_offset {
+            scroll_area = scroll_area.vertical_scroll_offset(self.offset);
+        }
+
+        ui.separator();
+        let (current_scroll, max_scroll) = scroll_area
+            .show(ui, |ui| {
+                if scroll_top {
+                    ui.scroll_to_cursor(Some(Align::TOP));
+                }
+                ui.vertical(|ui| {
+                    for item in 1..=50 {
+                        if track_item && item == self.track_item {
+                            let response =
+                                ui.colored_label(Color32::YELLOW, format!("This is item {}", item));
+                            response.scroll_to_me(self.tack_item_align);
+                        } else {
+                            ui.label(format!("This is item {}", item));
+                        }
+                    }
+                });
+
+                if scroll_bottom {
+                    ui.scroll_to_cursor(Some(Align::BOTTOM));
+                }
+
+                let margin = ui.visuals().clip_rect_margin;
+
+                let current_scroll = ui.clip_rect().top() - ui.min_rect().top() + margin;
+                let max_scroll = ui.min_rect().height() - ui.clip_rect().height() + 2.0 * margin;
+                (current_scroll, max_scroll)
+            })
+            .inner;
+        ui.separator();
+
+        ui.label(format!(
+            "Scroll offset: {:.0}/{:.0} px",
+            current_scroll, max_scroll
+        ));
+
+        ui.separator();
+        ui.vertical_centered(|ui| {
+            egui::reset_button(ui, self);
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+#[derive(Default, PartialEq)]
+struct ScrollStickTo {
+    n_items: usize,
+}
+
+impl super::View for ScrollStickTo {
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.label("Rows enter from the bottom, we want the scroll handle to start and stay at bottom unless moved");
+
+        ui.add_space(4.0);
+
+        let text_style = TextStyle::Body;
+        let row_height = ui.text_style_height(&text_style);
+        ScrollArea::vertical().stick_to_bottom(true).show_rows(
+            ui,
+            row_height,
+            self.n_items,
+            |ui, row_range| {
+                for row in row_range {
+                    let text = format!("This is row {}", row + 1);
+                    ui.label(text);
+                }
+            },
+        );
+
+        self.n_items += 1;
+        ui.ctx().request_repaint();
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/sliders.rs b/egui/crates/egui_demo_lib/src/demo/sliders.rs
new file mode 100644
index 0000000..1f565a5
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/sliders.rs
@@ -0,0 +1,194 @@
+use egui::*;
+use std::f64::INFINITY;
+
+/// Showcase sliders
+#[derive(PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Sliders {
+    pub min: f64,
+    pub max: f64,
+    pub logarithmic: bool,
+    pub clamp_to_range: bool,
+    pub smart_aim: bool,
+    pub step: f64,
+    pub use_steps: bool,
+    pub integer: bool,
+    pub vertical: bool,
+    pub value: f64,
+    pub trailing_fill: bool,
+}
+
+impl Default for Sliders {
+    fn default() -> Self {
+        Self {
+            min: 0.0,
+            max: 10000.0,
+            logarithmic: true,
+            clamp_to_range: false,
+            smart_aim: true,
+            step: 10.0,
+            use_steps: false,
+            integer: false,
+            vertical: false,
+            value: 10.0,
+            trailing_fill: false,
+        }
+    }
+}
+
+impl super::Demo for Sliders {
+    fn name(&self) -> &'static str {
+        "⬌ Sliders"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(false)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for Sliders {
+    fn ui(&mut self, ui: &mut Ui) {
+        let Self {
+            min,
+            max,
+            logarithmic,
+            clamp_to_range,
+            smart_aim,
+            step,
+            use_steps,
+            integer,
+            vertical,
+            value,
+            trailing_fill,
+        } = self;
+
+        ui.label("You can click a slider value to edit it with the keyboard.");
+
+        let (type_min, type_max) = if *integer {
+            ((i32::MIN as f64), (i32::MAX as f64))
+        } else if *logarithmic {
+            (-INFINITY, INFINITY)
+        } else {
+            (-1e5, 1e5) // linear sliders make little sense with huge numbers
+        };
+
+        *min = min.clamp(type_min, type_max);
+        *max = max.clamp(type_min, type_max);
+
+        let orientation = if *vertical {
+            SliderOrientation::Vertical
+        } else {
+            SliderOrientation::Horizontal
+        };
+
+        let istep = if *use_steps { *step } else { 0.0 };
+        if *integer {
+            let mut value_i32 = *value as i32;
+            ui.add(
+                Slider::new(&mut value_i32, (*min as i32)..=(*max as i32))
+                    .logarithmic(*logarithmic)
+                    .clamp_to_range(*clamp_to_range)
+                    .smart_aim(*smart_aim)
+                    .orientation(orientation)
+                    .text("i32 demo slider")
+                    .step_by(istep)
+                    .trailing_fill(*trailing_fill),
+            );
+            *value = value_i32 as f64;
+        } else {
+            ui.add(
+                Slider::new(value, (*min)..=(*max))
+                    .logarithmic(*logarithmic)
+                    .clamp_to_range(*clamp_to_range)
+                    .smart_aim(*smart_aim)
+                    .orientation(orientation)
+                    .text("f64 demo slider")
+                    .step_by(istep)
+                    .trailing_fill(*trailing_fill),
+            );
+
+            ui.label(
+                "Sliders will intelligently pick how many decimals to show. \
+                You can always see the full precision value by hovering the value.",
+            );
+
+            if ui.button("Assign PI").clicked() {
+                self.value = std::f64::consts::PI;
+            }
+        }
+
+        ui.separator();
+
+        ui.label("Slider range:");
+        ui.add(
+            Slider::new(min, type_min..=type_max)
+                .logarithmic(true)
+                .smart_aim(*smart_aim)
+                .text("left")
+                .trailing_fill(*trailing_fill),
+        );
+        ui.add(
+            Slider::new(max, type_min..=type_max)
+                .logarithmic(true)
+                .smart_aim(*smart_aim)
+                .text("right")
+                .trailing_fill(*trailing_fill),
+        );
+
+        ui.separator();
+
+        ui.checkbox(trailing_fill, "Toggle trailing color");
+        ui.label("When enabled, trailing color will be painted up until the circle.");
+
+        ui.separator();
+
+        ui.checkbox(use_steps, "Use steps");
+        ui.label("When enabled, the minimal value change would be restricted to a given step.");
+        if *use_steps {
+            ui.add(egui::DragValue::new(step).speed(1.0));
+        }
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            ui.label("Slider type:");
+            ui.radio_value(integer, true, "i32");
+            ui.radio_value(integer, false, "f64");
+        })
+        .response
+        .on_hover_text("All numeric types (f32, usize, …) are supported.");
+
+        ui.horizontal(|ui| {
+            ui.label("Slider orientation:");
+            ui.radio_value(vertical, false, "Horizontal");
+            ui.radio_value(vertical, true, "Vertical");
+        });
+        ui.add_space(8.0);
+
+        ui.checkbox(logarithmic, "Logarithmic");
+        ui.label("Logarithmic sliders are great for when you want to span a huge range, i.e. from zero to a million.");
+        ui.label("Logarithmic sliders can include infinity and zero.");
+        ui.add_space(8.0);
+
+        ui.checkbox(clamp_to_range, "Clamp to range");
+        ui.label("If true, the slider will clamp incoming and outgoing values to the given range.");
+        ui.label("If false, the slider can shows values outside its range, and you can manually enter values outside the range.");
+        ui.add_space(8.0);
+
+        ui.checkbox(smart_aim, "Smart Aim");
+        ui.label("Smart Aim will guide you towards round values when you drag the slider so you you are more likely to hit 250 than 247.23");
+        ui.add_space(8.0);
+
+        ui.vertical_centered(|ui| {
+            egui::reset_button(ui, self);
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/strip_demo.rs b/egui/crates/egui_demo_lib/src/demo/strip_demo.rs
new file mode 100644
index 0000000..2e9038b
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/strip_demo.rs
@@ -0,0 +1,119 @@
+use egui::Color32;
+use egui_extras::{Size, StripBuilder};
+
+/// Shows off a table with dynamic layout
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Default)]
+pub struct StripDemo {}
+
+impl super::Demo for StripDemo {
+    fn name(&self) -> &'static str {
+        "▣ Strip Demo"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(true)
+            .default_width(400.0)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for StripDemo {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        let dark_mode = ui.visuals().dark_mode;
+        let faded_color = ui.visuals().window_fill();
+        let faded_color = |color: Color32| -> Color32 {
+            use egui::Rgba;
+            let t = if dark_mode { 0.95 } else { 0.8 };
+            egui::lerp(Rgba::from(color)..=Rgba::from(faded_color), t).into()
+        };
+
+        StripBuilder::new(ui)
+            .size(Size::exact(50.0))
+            .size(Size::remainder())
+            .size(Size::relative(0.5).at_least(60.0))
+            .size(Size::exact(10.0))
+            .vertical(|mut strip| {
+                strip.cell(|ui| {
+                    ui.painter().rect_filled(
+                        ui.available_rect_before_wrap(),
+                        0.0,
+                        faded_color(Color32::BLUE),
+                    );
+                    ui.label("width: 100%\nheight: 50px");
+                });
+                strip.strip(|builder| {
+                    builder.sizes(Size::remainder(), 2).horizontal(|mut strip| {
+                        strip.cell(|ui| {
+                            ui.painter().rect_filled(
+                                ui.available_rect_before_wrap(),
+                                0.0,
+                                faded_color(Color32::RED),
+                            );
+                            ui.label("width: 50%\nheight: remaining");
+                        });
+                        strip.strip(|builder| {
+                            builder.sizes(Size::remainder(), 3).vertical(|mut strip| {
+                                strip.empty();
+                                strip.cell(|ui| {
+                                    ui.painter().rect_filled(
+                                        ui.available_rect_before_wrap(),
+                                        0.0,
+                                        faded_color(Color32::YELLOW),
+                                    );
+                                    ui.label("width: 50%\nheight: 1/3 of the red region");
+                                });
+                                strip.empty();
+                            });
+                        });
+                    });
+                });
+                strip.strip(|builder| {
+                    builder
+                        .size(Size::remainder())
+                        .size(Size::exact(120.0))
+                        .size(Size::remainder())
+                        .size(Size::exact(70.0))
+                        .horizontal(|mut strip| {
+                            strip.empty();
+                            strip.strip(|builder| {
+                                builder
+                                    .size(Size::remainder())
+                                    .size(Size::exact(60.0))
+                                    .size(Size::remainder())
+                                    .vertical(|mut strip| {
+                                        strip.empty();
+                                        strip.cell(|ui| {
+                                            ui.painter().rect_filled(
+                                                ui.available_rect_before_wrap(),
+                                                0.0,
+                                                faded_color(Color32::GOLD),
+                                            );
+                                            ui.label("width: 120px\nheight: 60px");
+                                        });
+                                    });
+                            });
+                            strip.empty();
+                            strip.cell(|ui| {
+                                ui.painter().rect_filled(
+                                    ui.available_rect_before_wrap(),
+                                    0.0,
+                                    faded_color(Color32::GREEN),
+                                );
+                                ui.label("width: 70px\n\nheight: 50%, but at least 60px.");
+                            });
+                        });
+                });
+                strip.cell(|ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.add(crate::egui_github_link_file!());
+                    });
+                });
+            });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/table_demo.rs b/egui/crates/egui_demo_lib/src/demo/table_demo.rs
new file mode 100644
index 0000000..7354183
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/table_demo.rs
@@ -0,0 +1,252 @@
+#[derive(PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+enum DemoType {
+    Manual,
+    ManyHomogeneous,
+    ManyHeterogenous,
+}
+
+/// Shows off a table with dynamic layout
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TableDemo {
+    demo: DemoType,
+    striped: bool,
+    resizable: bool,
+    num_rows: usize,
+    scroll_to_row_slider: usize,
+    scroll_to_row: Option<usize>,
+}
+
+impl Default for TableDemo {
+    fn default() -> Self {
+        Self {
+            demo: DemoType::Manual,
+            striped: true,
+            resizable: true,
+            num_rows: 10_000,
+            scroll_to_row_slider: 0,
+            scroll_to_row: None,
+        }
+    }
+}
+
+impl super::Demo for TableDemo {
+    fn name(&self) -> &'static str {
+        "☰ Table Demo"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(true)
+            .default_width(400.0)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+const NUM_MANUAL_ROWS: usize = 20;
+
+impl super::View for TableDemo {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.vertical(|ui| {
+            ui.horizontal(|ui| {
+                ui.checkbox(&mut self.striped, "Striped");
+                ui.checkbox(&mut self.resizable, "Resizable columns");
+            });
+
+            ui.label("Table type:");
+            ui.radio_value(&mut self.demo, DemoType::Manual, "Few, manual rows");
+            ui.radio_value(
+                &mut self.demo,
+                DemoType::ManyHomogeneous,
+                "Thousands of rows of same height",
+            );
+            ui.radio_value(
+                &mut self.demo,
+                DemoType::ManyHeterogenous,
+                "Thousands of rows of differing heights",
+            );
+
+            if self.demo != DemoType::Manual {
+                ui.add(
+                    egui::Slider::new(&mut self.num_rows, 0..=100_000)
+                        .logarithmic(true)
+                        .text("Num rows"),
+                );
+            }
+
+            {
+                let max_rows = if self.demo == DemoType::Manual {
+                    NUM_MANUAL_ROWS
+                } else {
+                    self.num_rows
+                };
+
+                let slider_response = ui.add(
+                    egui::Slider::new(&mut self.scroll_to_row_slider, 0..=max_rows)
+                        .logarithmic(true)
+                        .text("Row to scroll to"),
+                );
+                if slider_response.changed() {
+                    self.scroll_to_row = Some(self.scroll_to_row_slider);
+                }
+            }
+        });
+
+        ui.separator();
+
+        // Leave room for the source code link after the table demo:
+        use egui_extras::{Size, StripBuilder};
+        StripBuilder::new(ui)
+            .size(Size::remainder().at_least(100.0)) // for the table
+            .size(Size::exact(10.0)) // for the source code link
+            .vertical(|mut strip| {
+                strip.cell(|ui| {
+                    egui::ScrollArea::horizontal().show(ui, |ui| {
+                        self.table_ui(ui);
+                    });
+                });
+                strip.cell(|ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.add(crate::egui_github_link_file!());
+                    });
+                });
+            });
+    }
+}
+
+impl TableDemo {
+    fn table_ui(&mut self, ui: &mut egui::Ui) {
+        use egui_extras::{Column, TableBuilder};
+
+        let text_height = egui::TextStyle::Body.resolve(ui.style()).size;
+
+        let mut table = TableBuilder::new(ui)
+            .striped(self.striped)
+            .resizable(self.resizable)
+            .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
+            .column(Column::auto())
+            .column(Column::initial(100.0).range(40.0..=300.0))
+            .column(Column::initial(100.0).at_least(40.0).clip(true))
+            .column(Column::remainder())
+            .min_scrolled_height(0.0);
+
+        if let Some(row_nr) = self.scroll_to_row.take() {
+            table = table.scroll_to_row(row_nr, None);
+        }
+
+        table
+            .header(20.0, |mut header| {
+                header.col(|ui| {
+                    ui.strong("Row");
+                });
+                header.col(|ui| {
+                    ui.strong("Expanding content");
+                });
+                header.col(|ui| {
+                    ui.strong("Clipped text");
+                });
+                header.col(|ui| {
+                    ui.strong("Content");
+                });
+            })
+            .body(|mut body| match self.demo {
+                DemoType::Manual => {
+                    for row_index in 0..NUM_MANUAL_ROWS {
+                        let is_thick = thick_row(row_index);
+                        let row_height = if is_thick { 30.0 } else { 18.0 };
+                        body.row(row_height, |mut row| {
+                            row.col(|ui| {
+                                ui.label(row_index.to_string());
+                            });
+                            row.col(|ui| {
+                                expanding_content(ui);
+                            });
+                            row.col(|ui| {
+                                ui.label(long_text(row_index));
+                            });
+                            row.col(|ui| {
+                                ui.style_mut().wrap = Some(false);
+                                if is_thick {
+                                    ui.heading("Extra thick row");
+                                } else {
+                                    ui.label("Normal row");
+                                }
+                            });
+                        });
+                    }
+                }
+                DemoType::ManyHomogeneous => {
+                    body.rows(text_height, self.num_rows, |row_index, mut row| {
+                        row.col(|ui| {
+                            ui.label(row_index.to_string());
+                        });
+                        row.col(|ui| {
+                            expanding_content(ui);
+                        });
+                        row.col(|ui| {
+                            ui.label(long_text(row_index));
+                        });
+                        row.col(|ui| {
+                            ui.add(
+                                egui::Label::new("Thousands of rows of even height").wrap(false),
+                            );
+                        });
+                    });
+                }
+                DemoType::ManyHeterogenous => {
+                    fn row_thickness(row_index: usize) -> f32 {
+                        if thick_row(row_index) {
+                            30.0
+                        } else {
+                            18.0
+                        }
+                    }
+                    body.heterogeneous_rows(
+                        (0..self.num_rows).into_iter().map(row_thickness),
+                        |row_index, mut row| {
+                            row.col(|ui| {
+                                ui.label(row_index.to_string());
+                            });
+                            row.col(|ui| {
+                                expanding_content(ui);
+                            });
+                            row.col(|ui| {
+                                ui.label(long_text(row_index));
+                            });
+                            row.col(|ui| {
+                                ui.style_mut().wrap = Some(false);
+                                if thick_row(row_index) {
+                                    ui.heading("Extra thick row");
+                                } else {
+                                    ui.label("Normal row");
+                                }
+                            });
+                        },
+                    );
+                }
+            });
+    }
+}
+
+fn expanding_content(ui: &mut egui::Ui) {
+    let width = ui.available_width().clamp(20.0, 200.0);
+    let height = ui.available_height();
+    let (rect, _response) = ui.allocate_exact_size(egui::vec2(width, height), egui::Sense::hover());
+    ui.painter().hline(
+        rect.x_range(),
+        rect.center().y,
+        (1.0, ui.visuals().text_color()),
+    );
+}
+
+fn long_text(row_index: usize) -> String {
+    format!("Row {row_index} has some long text that you may want to clip, or it will take up too much horizontal space!")
+}
+
+fn thick_row(row_index: usize) -> bool {
+    row_index % 6 == 0
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/tests.rs b/egui/crates/egui_demo_lib/src/demo/tests.rs
new file mode 100644
index 0000000..2204548
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/tests.rs
@@ -0,0 +1,480 @@
+#[derive(Default)]
+pub struct CursorTest {}
+
+impl super::Demo for CursorTest {
+    fn name(&self) -> &'static str {
+        "Cursor Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name()).open(open).show(ctx, |ui| {
+            use super::View as _;
+            self.ui(ui);
+        });
+    }
+}
+
+impl super::View for CursorTest {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.vertical_centered_justified(|ui| {
+            ui.heading("Hover to switch cursor icon:");
+            for &cursor_icon in &egui::CursorIcon::ALL {
+                let _ = ui
+                    .button(format!("{:?}", cursor_icon))
+                    .on_hover_cursor(cursor_icon);
+            }
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default)]
+pub struct IdTest {}
+
+impl super::Demo for IdTest {
+    fn name(&self) -> &'static str {
+        "ID Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name()).open(open).show(ctx, |ui| {
+            use super::View as _;
+            self.ui(ui);
+        });
+    }
+}
+
+impl super::View for IdTest {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.heading("Name collision example");
+
+        ui.label("\
+            Widgets that store state require unique and persisting identifiers so we can track their state between frames.\n\
+            For instance, collapsible headers needs to store whether or not they are open. \
+            Their Id:s are derived from their names. \
+            If you fail to give them unique names then clicking one will open both. \
+            To help you debug this, an error message is printed on screen:");
+
+        ui.collapsing("Collapsing header", |ui| {
+            ui.label("Contents of first foldable ui");
+        });
+        ui.collapsing("Collapsing header", |ui| {
+            ui.label("Contents of second foldable ui");
+        });
+
+        ui.label("\
+            Any widget that can be interacted with also need a unique Id. \
+            For most widgets the Id is generated by a running counter. \
+            As long as elements are not added or removed, the Id stays the same. \
+            This is fine, because during interaction (i.e. while dragging a slider), \
+            the number of widgets previously in the same window is most likely not changing \
+            (and if it is, the window will have a new layout, and the slider will end up somewhere else, and so aborting the interaction probably makes sense).");
+
+        ui.label("So these buttons have automatic Id:s, and therefore there is no name clash:");
+        let _ = ui.button("Button");
+        let _ = ui.button("Button");
+
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum WidgetType {
+    Label,
+    Button,
+    TextEdit,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ManualLayoutTest {
+    widget_offset: egui::Vec2,
+    widget_size: egui::Vec2,
+    widget_type: WidgetType,
+    text_edit_contents: String,
+}
+
+impl Default for ManualLayoutTest {
+    fn default() -> Self {
+        Self {
+            widget_offset: egui::Vec2::splat(150.0),
+            widget_size: egui::vec2(200.0, 100.0),
+            widget_type: WidgetType::Button,
+            text_edit_contents: crate::LOREM_IPSUM.to_owned(),
+        }
+    }
+}
+
+impl super::Demo for ManualLayoutTest {
+    fn name(&self) -> &'static str {
+        "Manual Layout Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .resizable(false)
+            .open(open)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for ManualLayoutTest {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        egui::reset_button(ui, self);
+
+        let Self {
+            widget_offset,
+            widget_size,
+            widget_type,
+            text_edit_contents,
+        } = self;
+        ui.horizontal(|ui| {
+            ui.label("Test widget:");
+            ui.radio_value(widget_type, WidgetType::Button, "Button");
+            ui.radio_value(widget_type, WidgetType::Label, "Label");
+            ui.radio_value(widget_type, WidgetType::TextEdit, "TextEdit");
+        });
+        egui::Grid::new("pos_size").show(ui, |ui| {
+            ui.label("Widget position:");
+            ui.add(egui::Slider::new(&mut widget_offset.x, 0.0..=400.0));
+            ui.add(egui::Slider::new(&mut widget_offset.y, 0.0..=400.0));
+            ui.end_row();
+
+            ui.label("Widget size:");
+            ui.add(egui::Slider::new(&mut widget_size.x, 0.0..=400.0));
+            ui.add(egui::Slider::new(&mut widget_size.y, 0.0..=400.0));
+            ui.end_row();
+        });
+
+        let widget_rect =
+            egui::Rect::from_min_size(ui.min_rect().min + *widget_offset, *widget_size);
+
+        ui.add(crate::egui_github_link_file!());
+
+        // Showing how to place a widget anywhere in the [`Ui`]:
+        match *widget_type {
+            WidgetType::Button => {
+                ui.put(widget_rect, egui::Button::new("Example button"));
+            }
+            WidgetType::Label => {
+                ui.put(widget_rect, egui::Label::new("Example label"));
+            }
+            WidgetType::TextEdit => {
+                ui.put(widget_rect, egui::TextEdit::multiline(text_edit_contents));
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(PartialEq)]
+pub struct TableTest {
+    num_cols: usize,
+    num_rows: usize,
+    min_col_width: f32,
+    max_col_width: f32,
+    text_length: usize,
+}
+
+impl Default for TableTest {
+    fn default() -> Self {
+        Self {
+            num_cols: 4,
+            num_rows: 4,
+            min_col_width: 10.0,
+            max_col_width: 200.0,
+            text_length: 10,
+        }
+    }
+}
+
+impl super::Demo for TableTest {
+    fn name(&self) -> &'static str {
+        "Table Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name()).open(open).show(ctx, |ui| {
+            use super::View as _;
+            self.ui(ui);
+        });
+    }
+}
+
+impl super::View for TableTest {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.add(
+            egui::Slider::new(&mut self.min_col_width, 0.0..=400.0).text("Minimum column width"),
+        );
+        ui.add(
+            egui::Slider::new(&mut self.max_col_width, 0.0..=400.0).text("Maximum column width"),
+        );
+        ui.add(egui::Slider::new(&mut self.num_cols, 0..=5).text("Columns"));
+        ui.add(egui::Slider::new(&mut self.num_rows, 0..=20).text("Rows"));
+
+        ui.separator();
+
+        let words = [
+            "random", "words", "in", "a", "random", "order", "that", "just", "keeps", "going",
+            "with", "some", "more",
+        ];
+
+        egui::Grid::new("my_grid")
+            .striped(true)
+            .min_col_width(self.min_col_width)
+            .max_col_width(self.max_col_width)
+            .show(ui, |ui| {
+                for row in 0..self.num_rows {
+                    for col in 0..self.num_cols {
+                        if col == 0 {
+                            ui.label(format!("row {}", row));
+                        } else {
+                            let word_idx = row * 3 + col * 5;
+                            let word_count = (row * 5 + col * 75) % 13;
+                            let mut string = String::new();
+                            for word in words.iter().cycle().skip(word_idx).take(word_count) {
+                                string += word;
+                                string += " ";
+                            }
+                            ui.label(string);
+                        }
+                    }
+                    ui.end_row();
+                }
+            });
+
+        ui.separator();
+        ui.add(egui::Slider::new(&mut self.text_length, 1..=40).text("Text length"));
+        egui::Grid::new("parent grid").striped(true).show(ui, |ui| {
+            ui.vertical(|ui| {
+                ui.label("Vertical nest1");
+                ui.label("Vertical nest2");
+            });
+            ui.label("First row, second column");
+            ui.end_row();
+
+            ui.horizontal(|ui| {
+                ui.label("Horizontal nest1");
+                ui.label("Horizontal nest2");
+            });
+            ui.label("Second row, second column");
+            ui.end_row();
+
+            ui.scope(|ui| {
+                ui.label("Scope nest 1");
+                ui.label("Scope nest 2");
+            });
+            ui.label("Third row, second column");
+            ui.end_row();
+
+            egui::Grid::new("nested grid").show(ui, |ui| {
+                ui.label("Grid nest11");
+                ui.label("Grid nest12");
+                ui.end_row();
+                ui.label("Grid nest21");
+                ui.label("Grid nest22");
+                ui.end_row();
+            });
+            ui.label("Fourth row, second column");
+            ui.end_row();
+
+            let mut dyn_text = String::from("O");
+            dyn_text.extend(std::iter::repeat('h').take(self.text_length));
+            ui.label(dyn_text);
+            ui.label("Fifth row, second column");
+            ui.end_row();
+        });
+
+        ui.vertical_centered(|ui| {
+            egui::reset_button(ui, self);
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(Default)]
+pub struct InputTest {
+    info: String,
+}
+
+impl super::Demo for InputTest {
+    fn name(&self) -> &'static str {
+        "Input Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(false)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for InputTest {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+
+        let response = ui.add(
+            egui::Button::new("Click, double-click, triple-click or drag me with any mouse button")
+                .sense(egui::Sense::click_and_drag()),
+        );
+
+        let mut new_info = String::new();
+        for &button in &[
+            egui::PointerButton::Primary,
+            egui::PointerButton::Secondary,
+            egui::PointerButton::Middle,
+            egui::PointerButton::Extra1,
+            egui::PointerButton::Extra2,
+        ] {
+            use std::fmt::Write as _;
+
+            if response.clicked_by(button) {
+                writeln!(new_info, "Clicked by {:?} button", button).ok();
+            }
+            if response.double_clicked_by(button) {
+                writeln!(new_info, "Double-clicked by {:?} button", button).ok();
+            }
+            if response.triple_clicked_by(button) {
+                writeln!(new_info, "Triple-clicked by {:?} button", button).ok();
+            }
+            if response.dragged_by(button) {
+                writeln!(
+                    new_info,
+                    "Dragged by {:?} button, delta: {:?}",
+                    button,
+                    response.drag_delta()
+                )
+                .ok();
+            }
+        }
+        if !new_info.is_empty() {
+            self.info = new_info;
+        }
+
+        ui.label(&self.info);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub struct WindowResizeTest {
+    text: String,
+}
+
+impl Default for WindowResizeTest {
+    fn default() -> Self {
+        Self {
+            text: crate::LOREM_IPSUM_LONG.to_owned(),
+        }
+    }
+}
+
+impl super::Demo for WindowResizeTest {
+    fn name(&self) -> &'static str {
+        "↔ Window Resize"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        use egui::*;
+
+        Window::new("↔ auto-sized")
+            .open(open)
+            .auto_sized()
+            .show(ctx, |ui| {
+                ui.label("This window will auto-size based on its contents.");
+                ui.heading("Resize this area:");
+                Resize::default().show(ui, |ui| {
+                    lorem_ipsum(ui, crate::LOREM_IPSUM);
+                });
+                ui.heading("Resize the above area!");
+            });
+
+        Window::new("↔ resizable + scroll")
+            .open(open)
+            .vscroll(true)
+            .resizable(true)
+            .default_height(300.0)
+            .show(ctx, |ui| {
+                ui.label(
+                    "This window is resizable and has a scroll area. You can shrink it to any size.",
+                );
+                ui.separator();
+                lorem_ipsum(ui, crate::LOREM_IPSUM_LONG);
+            });
+
+        Window::new("↔ resizable + embedded scroll")
+            .open(open)
+            .vscroll(false)
+            .resizable(true)
+            .default_height(300.0)
+            .show(ctx, |ui| {
+                ui.label("This window is resizable but has no built-in scroll area.");
+                ui.label("However, we have a sub-region with a scroll bar:");
+                ui.separator();
+                ScrollArea::vertical().show(ui, |ui| {
+                    let lorem_ipsum_extra_long =
+                        format!("{}\n\n{}", crate::LOREM_IPSUM_LONG, crate::LOREM_IPSUM_LONG);
+                    lorem_ipsum(ui, &lorem_ipsum_extra_long);
+                });
+                // ui.heading("Some additional text here, that should also be visible"); // this works, but messes with the resizing a bit
+            });
+
+        Window::new("↔ resizable without scroll")
+            .open(open)
+            .vscroll(false)
+            .resizable(true)
+            .show(ctx, |ui| {
+                ui.label("This window is resizable but has no scroll area. This means it can only be resized to a size where all the contents is visible.");
+                ui.label("egui will not clip the contents of a window, nor add whitespace to it.");
+                ui.separator();
+                lorem_ipsum(ui, crate::LOREM_IPSUM);
+            });
+
+        Window::new("↔ resizable with TextEdit")
+            .open(open)
+            .vscroll(false)
+            .resizable(true)
+            .default_height(300.0)
+            .show(ctx, |ui| {
+                ui.label("Shows how you can fill an area with a widget.");
+                ui.add_sized(ui.available_size(), TextEdit::multiline(&mut self.text));
+            });
+
+        Window::new("↔ freely resized")
+            .open(open)
+            .vscroll(false)
+            .resizable(true)
+            .default_size([250.0, 150.0])
+            .show(ctx, |ui| {
+                ui.label("This window has empty space that fills up the available space, preventing auto-shrink.");
+                ui.allocate_space(ui.available_size());
+            });
+    }
+}
+
+fn lorem_ipsum(ui: &mut egui::Ui, text: &str) {
+    ui.with_layout(
+        egui::Layout::top_down(egui::Align::LEFT).with_cross_justify(true),
+        |ui| {
+            ui.label(egui::RichText::new(text).weak());
+        },
+    );
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/text_edit.rs b/egui/crates/egui_demo_lib/src/demo/text_edit.rs
new file mode 100644
index 0000000..6ad3f24
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/text_edit.rs
@@ -0,0 +1,108 @@
+/// Showcase [`TextEdit`].
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct TextEdit {
+    pub text: String,
+}
+
+impl Default for TextEdit {
+    fn default() -> Self {
+        Self {
+            text: "Edit this text".to_owned(),
+        }
+    }
+}
+
+impl super::Demo for TextEdit {
+    fn name(&self) -> &'static str {
+        "🖹 TextEdit"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(false)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for TextEdit {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        let Self { text } = self;
+
+        ui.horizontal(|ui| {
+            ui.spacing_mut().item_spacing.x = 0.0;
+            ui.label("Advanced usage of ");
+            ui.code("TextEdit");
+            ui.label(".");
+        });
+
+        let output = egui::TextEdit::multiline(text)
+            .hint_text("Type something!")
+            .show(ui);
+
+        ui.horizontal(|ui| {
+            ui.spacing_mut().item_spacing.x = 0.0;
+            ui.label("Selected text: ");
+            if let Some(text_cursor_range) = output.cursor_range {
+                use egui::TextBuffer as _;
+                let selected_chars = text_cursor_range.as_sorted_char_range();
+                let selected_text = text.char_range(selected_chars);
+                ui.code(selected_text);
+            }
+        });
+
+        let anything_selected = output
+            .cursor_range
+            .map_or(false, |cursor| !cursor.is_empty());
+
+        ui.add_enabled(
+            anything_selected,
+            egui::Label::new("Press ctrl+Y to toggle the case of selected text (cmd+Y on Mac)"),
+        );
+
+        if ui.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Y)) {
+            if let Some(text_cursor_range) = output.cursor_range {
+                use egui::TextBuffer as _;
+                let selected_chars = text_cursor_range.as_sorted_char_range();
+                let selected_text = text.char_range(selected_chars.clone());
+                let upper_case = selected_text.to_uppercase();
+                let new_text = if selected_text == upper_case {
+                    selected_text.to_lowercase()
+                } else {
+                    upper_case
+                };
+                text.delete_char_range(selected_chars.clone());
+                text.insert_text(&new_text, selected_chars.start);
+            }
+        }
+
+        ui.horizontal(|ui| {
+            ui.label("Move cursor to the:");
+
+            if ui.button("start").clicked() {
+                let text_edit_id = output.response.id;
+                if let Some(mut state) = egui::TextEdit::load_state(ui.ctx(), text_edit_id) {
+                    let ccursor = egui::text::CCursor::new(0);
+                    state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
+                    state.store(ui.ctx(), text_edit_id);
+                    ui.ctx().memory_mut(|mem| mem.request_focus(text_edit_id)); // give focus back to the [`TextEdit`].
+                }
+            }
+
+            if ui.button("end").clicked() {
+                let text_edit_id = output.response.id;
+                if let Some(mut state) = egui::TextEdit::load_state(ui.ctx(), text_edit_id) {
+                    let ccursor = egui::text::CCursor::new(text.chars().count());
+                    state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
+                    state.store(ui.ctx(), text_edit_id);
+                    ui.ctx().memory_mut(|mem| mem.request_focus(text_edit_id)); // give focus back to the [`TextEdit`].
+                }
+            }
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/toggle_switch.rs b/egui/crates/egui_demo_lib/src/demo/toggle_switch.rs
new file mode 100644
index 0000000..8a2d533
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/toggle_switch.rs
@@ -0,0 +1,111 @@
+//! Source code example of how to create your own widget.
+//! This is meant to be read as a tutorial, hence the plethora of comments.
+
+/// iOS-style toggle switch:
+///
+/// ``` text
+///      _____________
+///     /       /.....\
+///    |       |.......|
+///     \_______\_____/
+/// ```
+///
+/// ## Example:
+/// ``` ignore
+/// toggle_ui(ui, &mut my_bool);
+/// ```
+pub fn toggle_ui(ui: &mut egui::Ui, on: &mut bool) -> egui::Response {
+    // Widget code can be broken up in four steps:
+    //  1. Decide a size for the widget
+    //  2. Allocate space for it
+    //  3. Handle interactions with the widget (if any)
+    //  4. Paint the widget
+
+    // 1. Deciding widget size:
+    // You can query the `ui` how much space is available,
+    // but in this example we have a fixed size widget based on the height of a standard button:
+    let desired_size = ui.spacing().interact_size.y * egui::vec2(2.0, 1.0);
+
+    // 2. Allocating space:
+    // This is where we get a region of the screen assigned.
+    // We also tell the Ui to sense clicks in the allocated region.
+    let (rect, mut response) = ui.allocate_exact_size(desired_size, egui::Sense::click());
+
+    // 3. Interact: Time to check for clicks!
+    if response.clicked() {
+        *on = !*on;
+        response.mark_changed(); // report back that the value changed
+    }
+
+    // Attach some meta-data to the response which can be used by screen readers:
+    response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Checkbox, *on, ""));
+
+    // 4. Paint!
+    // Make sure we need to paint:
+    if ui.is_rect_visible(rect) {
+        // Let's ask for a simple animation from egui.
+        // egui keeps track of changes in the boolean associated with the id and
+        // returns an animated value in the 0-1 range for how much "on" we are.
+        let how_on = ui.ctx().animate_bool(response.id, *on);
+        // We will follow the current style by asking
+        // "how should something that is being interacted with be painted?".
+        // This will, for instance, give us different colors when the widget is hovered or clicked.
+        let visuals = ui.style().interact_selectable(&response, *on);
+        // All coordinates are in absolute screen coordinates so we use `rect` to place the elements.
+        let rect = rect.expand(visuals.expansion);
+        let radius = 0.5 * rect.height();
+        ui.painter()
+            .rect(rect, radius, visuals.bg_fill, visuals.bg_stroke);
+        // Paint the circle, animating it from left to right with `how_on`:
+        let circle_x = egui::lerp((rect.left() + radius)..=(rect.right() - radius), how_on);
+        let center = egui::pos2(circle_x, rect.center().y);
+        ui.painter()
+            .circle(center, 0.75 * radius, visuals.bg_fill, visuals.fg_stroke);
+    }
+
+    // All done! Return the interaction response so the user can check what happened
+    // (hovered, clicked, ...) and maybe show a tooltip:
+    response
+}
+
+/// Here is the same code again, but a bit more compact:
+#[allow(dead_code)]
+fn toggle_ui_compact(ui: &mut egui::Ui, on: &mut bool) -> egui::Response {
+    let desired_size = ui.spacing().interact_size.y * egui::vec2(2.0, 1.0);
+    let (rect, mut response) = ui.allocate_exact_size(desired_size, egui::Sense::click());
+    if response.clicked() {
+        *on = !*on;
+        response.mark_changed();
+    }
+    response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Checkbox, *on, ""));
+
+    if ui.is_rect_visible(rect) {
+        let how_on = ui.ctx().animate_bool(response.id, *on);
+        let visuals = ui.style().interact_selectable(&response, *on);
+        let rect = rect.expand(visuals.expansion);
+        let radius = 0.5 * rect.height();
+        ui.painter()
+            .rect(rect, radius, visuals.bg_fill, visuals.bg_stroke);
+        let circle_x = egui::lerp((rect.left() + radius)..=(rect.right() - radius), how_on);
+        let center = egui::pos2(circle_x, rect.center().y);
+        ui.painter()
+            .circle(center, 0.75 * radius, visuals.bg_fill, visuals.fg_stroke);
+    }
+
+    response
+}
+
+// A wrapper that allows the more idiomatic usage pattern: `ui.add(toggle(&mut my_bool))`
+/// iOS-style toggle switch.
+///
+/// ## Example:
+/// ``` ignore
+/// ui.add(toggle(&mut my_bool));
+/// ```
+pub fn toggle(on: &mut bool) -> impl egui::Widget + '_ {
+    move |ui: &mut egui::Ui| toggle_ui(ui, on)
+}
+
+pub fn url_to_file_source_code() -> String {
+    format!("https://github.com/emilk/egui/blob/master/{}", file!())
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/widget_gallery.rs b/egui/crates/egui_demo_lib/src/demo/widget_gallery.rs
new file mode 100644
index 0000000..d91ae39
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/widget_gallery.rs
@@ -0,0 +1,290 @@
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+enum Enum {
+    First,
+    Second,
+    Third,
+}
+
+/// Shows off one example of each major type of widget.
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WidgetGallery {
+    enabled: bool,
+    visible: bool,
+    boolean: bool,
+    radio: Enum,
+    scalar: f32,
+    string: String,
+    color: egui::Color32,
+    animate_progress_bar: bool,
+
+    #[cfg(feature = "chrono")]
+    #[cfg_attr(feature = "serde", serde(skip))]
+    date: Option<chrono::NaiveDate>,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    texture: Option<egui::TextureHandle>,
+}
+
+impl Default for WidgetGallery {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            visible: true,
+            boolean: false,
+            radio: Enum::First,
+            scalar: 42.0,
+            string: Default::default(),
+            color: egui::Color32::LIGHT_BLUE.linear_multiply(0.5),
+            animate_progress_bar: false,
+            #[cfg(feature = "chrono")]
+            date: None,
+            texture: None,
+        }
+    }
+}
+
+impl super::Demo for WidgetGallery {
+    fn name(&self) -> &'static str {
+        "🗄 Widget Gallery"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(true)
+            .default_width(280.0)
+            .show(ctx, |ui| {
+                use super::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl super::View for WidgetGallery {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.add_enabled_ui(self.enabled, |ui| {
+            ui.set_visible(self.visible);
+
+            egui::Grid::new("my_grid")
+                .num_columns(2)
+                .spacing([40.0, 4.0])
+                .striped(true)
+                .show(ui, |ui| {
+                    self.gallery_grid_contents(ui);
+                });
+        });
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            ui.checkbox(&mut self.visible, "Visible")
+                .on_hover_text("Uncheck to hide all the widgets.");
+            if self.visible {
+                ui.checkbox(&mut self.enabled, "Interactive")
+                    .on_hover_text("Uncheck to inspect how the widgets look when disabled.");
+            }
+        });
+
+        ui.separator();
+
+        ui.vertical_centered(|ui| {
+            let tooltip_text = "The full egui documentation.\nYou can also click the different widgets names in the left column.";
+            ui.hyperlink("https://docs.rs/egui/").on_hover_text(tooltip_text);
+            ui.add(crate::egui_github_link_file!(
+                "Source code of the widget gallery"
+            ));
+        });
+    }
+}
+
+impl WidgetGallery {
+    fn gallery_grid_contents(&mut self, ui: &mut egui::Ui) {
+        let Self {
+            enabled: _,
+            visible: _,
+            boolean,
+            radio,
+            scalar,
+            string,
+            color,
+            animate_progress_bar,
+            #[cfg(feature = "chrono")]
+            date,
+            texture,
+        } = self;
+
+        let texture: &egui::TextureHandle = texture.get_or_insert_with(|| {
+            ui.ctx()
+                .load_texture("example", egui::ColorImage::example(), Default::default())
+        });
+
+        ui.add(doc_link_label("Label", "label,heading"));
+        ui.label("Welcome to the widget gallery!");
+        ui.end_row();
+
+        ui.add(doc_link_label("Hyperlink", "Hyperlink"));
+        use egui::special_emojis::GITHUB;
+        ui.hyperlink_to(
+            format!("{} egui on GitHub", GITHUB),
+            "https://github.com/emilk/egui",
+        );
+        ui.end_row();
+
+        ui.add(doc_link_label("TextEdit", "TextEdit,text_edit"));
+        ui.add(egui::TextEdit::singleline(string).hint_text("Write something here"));
+        ui.end_row();
+
+        ui.add(doc_link_label("Button", "button"));
+        if ui.button("Click me!").clicked() {
+            *boolean = !*boolean;
+        }
+        ui.end_row();
+
+        ui.add(doc_link_label("Link", "link"));
+        if ui.link("Click me!").clicked() {
+            *boolean = !*boolean;
+        }
+        ui.end_row();
+
+        ui.add(doc_link_label("Checkbox", "checkbox"));
+        ui.checkbox(boolean, "Checkbox");
+        ui.end_row();
+
+        ui.add(doc_link_label("RadioButton", "radio"));
+        ui.horizontal(|ui| {
+            ui.radio_value(radio, Enum::First, "First");
+            ui.radio_value(radio, Enum::Second, "Second");
+            ui.radio_value(radio, Enum::Third, "Third");
+        });
+        ui.end_row();
+
+        ui.add(doc_link_label(
+            "SelectableLabel",
+            "selectable_value,SelectableLabel",
+        ));
+        ui.horizontal(|ui| {
+            ui.selectable_value(radio, Enum::First, "First");
+            ui.selectable_value(radio, Enum::Second, "Second");
+            ui.selectable_value(radio, Enum::Third, "Third");
+        });
+        ui.end_row();
+
+        ui.add(doc_link_label("ComboBox", "ComboBox"));
+
+        egui::ComboBox::from_label("Take your pick")
+            .selected_text(format!("{:?}", radio))
+            .show_ui(ui, |ui| {
+                ui.style_mut().wrap = Some(false);
+                ui.set_min_width(60.0);
+                ui.selectable_value(radio, Enum::First, "First");
+                ui.selectable_value(radio, Enum::Second, "Second");
+                ui.selectable_value(radio, Enum::Third, "Third");
+            });
+        ui.end_row();
+
+        ui.add(doc_link_label("Slider", "Slider"));
+        ui.add(egui::Slider::new(scalar, 0.0..=360.0).suffix("°"));
+        ui.end_row();
+
+        ui.add(doc_link_label("DragValue", "DragValue"));
+        ui.add(egui::DragValue::new(scalar).speed(1.0));
+        ui.end_row();
+
+        ui.add(doc_link_label("ProgressBar", "ProgressBar"));
+        let progress = *scalar / 360.0;
+        let progress_bar = egui::ProgressBar::new(progress)
+            .show_percentage()
+            .animate(*animate_progress_bar);
+        *animate_progress_bar = ui
+            .add(progress_bar)
+            .on_hover_text("The progress bar can be animated!")
+            .hovered();
+        ui.end_row();
+
+        ui.add(doc_link_label("Color picker", "color_edit"));
+        ui.color_edit_button_srgba(color);
+        ui.end_row();
+
+        let img_size = 16.0 * texture.size_vec2() / texture.size_vec2().y;
+
+        ui.add(doc_link_label("Image", "Image"));
+        ui.image(texture, img_size);
+        ui.end_row();
+
+        ui.add(doc_link_label("ImageButton", "ImageButton"));
+        if ui.add(egui::ImageButton::new(texture, img_size)).clicked() {
+            *boolean = !*boolean;
+        }
+        ui.end_row();
+
+        #[cfg(feature = "chrono")]
+        {
+            let date = date.get_or_insert_with(|| chrono::offset::Utc::now().date_naive());
+            ui.add(doc_link_label("DatePickerButton", "DatePickerButton"));
+            ui.add(egui_extras::DatePickerButton::new(date));
+            ui.end_row();
+        }
+
+        ui.add(doc_link_label("Separator", "separator"));
+        ui.separator();
+        ui.end_row();
+
+        ui.add(doc_link_label("CollapsingHeader", "collapsing"));
+        ui.collapsing("Click to see what is hidden!", |ui| {
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("It's a ");
+                ui.add(doc_link_label("Spinner", "spinner"));
+                ui.add_space(4.0);
+                ui.add(egui::Spinner::new());
+            });
+        });
+        ui.end_row();
+
+        ui.add(doc_link_label("Plot", "plot"));
+        example_plot(ui);
+        ui.end_row();
+
+        ui.hyperlink_to(
+            "Custom widget:",
+            super::toggle_switch::url_to_file_source_code(),
+        );
+        ui.add(super::toggle_switch::toggle(boolean)).on_hover_text(
+            "It's easy to create your own widgets!\n\
+            This toggle switch is just 15 lines of code.",
+        );
+        ui.end_row();
+    }
+}
+
+fn example_plot(ui: &mut egui::Ui) -> egui::Response {
+    use egui::plot::{Line, PlotPoints};
+    let n = 128;
+    let line_points: PlotPoints = (0..=n)
+        .map(|i| {
+            use std::f64::consts::TAU;
+            let x = egui::remap(i as f64, 0.0..=n as f64, -TAU..=TAU);
+            [x, x.sin()]
+        })
+        .collect();
+    let line = Line::new(line_points);
+    egui::plot::Plot::new("example_plot")
+        .height(32.0)
+        .data_aspect(1.0)
+        .show(ui, |plot_ui| plot_ui.line(line))
+        .response
+}
+
+fn doc_link_label<'a>(title: &'a str, search_term: &'a str) -> impl egui::Widget + 'a {
+    let label = format!("{}:", title);
+    let url = format!("https://docs.rs/egui?search={}", search_term);
+    move |ui: &mut egui::Ui| {
+        ui.hyperlink_to(label, url).on_hover_ui(|ui| {
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Search egui docs for");
+                ui.code(search_term);
+            });
+        })
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/window_options.rs b/egui/crates/egui_demo_lib/src/demo/window_options.rs
new file mode 100644
index 0000000..ed142d0
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/window_options.rs
@@ -0,0 +1,141 @@
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WindowOptions {
+    title: String,
+    title_bar: bool,
+    closable: bool,
+    collapsible: bool,
+    resizable: bool,
+    scroll2: [bool; 2],
+    disabled_time: f64,
+
+    anchored: bool,
+    anchor: egui::Align2,
+    anchor_offset: egui::Vec2,
+}
+
+impl Default for WindowOptions {
+    fn default() -> Self {
+        Self {
+            title: "🗖 Window Options".to_owned(),
+            title_bar: true,
+            closable: true,
+            collapsible: true,
+            resizable: true,
+            scroll2: [true; 2],
+            disabled_time: f64::NEG_INFINITY,
+            anchored: false,
+            anchor: egui::Align2::RIGHT_TOP,
+            anchor_offset: egui::Vec2::ZERO,
+        }
+    }
+}
+
+impl super::Demo for WindowOptions {
+    fn name(&self) -> &'static str {
+        "🗖 Window Options"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        let Self {
+            title,
+            title_bar,
+            closable,
+            collapsible,
+            resizable,
+            scroll2,
+            disabled_time,
+            anchored,
+            anchor,
+            anchor_offset,
+        } = self.clone();
+
+        let enabled = ctx.input(|i| i.time) - disabled_time > 2.0;
+        if !enabled {
+            ctx.request_repaint();
+        }
+
+        use super::View as _;
+        let mut window = egui::Window::new(title)
+            .id(egui::Id::new("demo_window_options")) // required since we change the title
+            .resizable(resizable)
+            .collapsible(collapsible)
+            .title_bar(title_bar)
+            .scroll2(scroll2)
+            .enabled(enabled);
+        if closable {
+            window = window.open(open);
+        }
+        if anchored {
+            window = window.anchor(anchor, anchor_offset);
+        }
+        window.show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for WindowOptions {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        let Self {
+            title,
+            title_bar,
+            closable,
+            collapsible,
+            resizable,
+            scroll2,
+            disabled_time: _,
+            anchored,
+            anchor,
+            anchor_offset,
+        } = self;
+        ui.horizontal(|ui| {
+            ui.label("title:");
+            ui.text_edit_singleline(title);
+        });
+
+        ui.horizontal(|ui| {
+            ui.group(|ui| {
+                ui.vertical(|ui| {
+                    ui.checkbox(title_bar, "title_bar");
+                    ui.checkbox(closable, "closable");
+                    ui.checkbox(collapsible, "collapsible");
+                    ui.checkbox(resizable, "resizable");
+                    ui.checkbox(&mut scroll2[0], "hscroll");
+                    ui.checkbox(&mut scroll2[1], "vscroll");
+                });
+            });
+            ui.group(|ui| {
+                ui.vertical(|ui| {
+                    ui.checkbox(anchored, "anchored");
+                    ui.set_enabled(*anchored);
+                    ui.horizontal(|ui| {
+                        ui.label("x:");
+                        ui.selectable_value(&mut anchor[0], egui::Align::LEFT, "Left");
+                        ui.selectable_value(&mut anchor[0], egui::Align::Center, "Center");
+                        ui.selectable_value(&mut anchor[0], egui::Align::RIGHT, "Right");
+                    });
+                    ui.horizontal(|ui| {
+                        ui.label("y:");
+                        ui.selectable_value(&mut anchor[1], egui::Align::TOP, "Top");
+                        ui.selectable_value(&mut anchor[1], egui::Align::Center, "Center");
+                        ui.selectable_value(&mut anchor[1], egui::Align::BOTTOM, "Bottom");
+                    });
+                    ui.horizontal(|ui| {
+                        ui.label("Offset:");
+                        ui.add(egui::DragValue::new(&mut anchor_offset.x));
+                        ui.add(egui::DragValue::new(&mut anchor_offset.y));
+                    });
+                });
+            });
+        });
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            if ui.button("Disable for 2 seconds").clicked() {
+                self.disabled_time = ui.input(|i| i.time);
+            }
+            egui::reset_button(ui, self);
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/demo/window_with_panels.rs b/egui/crates/egui_demo_lib/src/demo/window_with_panels.rs
new file mode 100644
index 0000000..5518f21
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/demo/window_with_panels.rs
@@ -0,0 +1,92 @@
+#[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct WindowWithPanels {}
+
+impl super::Demo for WindowWithPanels {
+    fn name(&self) -> &'static str {
+        "🗖 Window With Panels"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        use super::View as _;
+        let window = egui::Window::new("Window with Panels")
+            .default_width(600.0)
+            .default_height(400.0)
+            .vscroll(false)
+            .open(open);
+        window.show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for WindowWithPanels {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        // Note that the order we add the panels is very important!
+
+        egui::TopBottomPanel::top("top_panel")
+            .resizable(true)
+            .min_height(32.0)
+            .show_inside(ui, |ui| {
+                egui::ScrollArea::vertical().show(ui, |ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.heading("Expandable Upper Panel");
+                    });
+                    lorem_ipsum(ui);
+                });
+            });
+
+        egui::SidePanel::left("left_panel")
+            .resizable(true)
+            .default_width(150.0)
+            .width_range(80.0..=200.0)
+            .show_inside(ui, |ui| {
+                ui.vertical_centered(|ui| {
+                    ui.heading("Left Panel");
+                });
+                egui::ScrollArea::vertical().show(ui, |ui| {
+                    lorem_ipsum(ui);
+                });
+            });
+
+        egui::SidePanel::right("right_panel")
+            .resizable(true)
+            .default_width(150.0)
+            .width_range(80.0..=200.0)
+            .show_inside(ui, |ui| {
+                ui.vertical_centered(|ui| {
+                    ui.heading("Right Panel");
+                });
+                egui::ScrollArea::vertical().show(ui, |ui| {
+                    lorem_ipsum(ui);
+                });
+            });
+
+        egui::TopBottomPanel::bottom("bottom_panel")
+            .resizable(false)
+            .min_height(0.0)
+            .show_inside(ui, |ui| {
+                ui.vertical_centered(|ui| {
+                    ui.heading("Bottom Panel");
+                });
+            });
+
+        egui::CentralPanel::default().show_inside(ui, |ui| {
+            ui.vertical_centered(|ui| {
+                ui.heading("Central Panel");
+            });
+            egui::ScrollArea::vertical().show(ui, |ui| {
+                lorem_ipsum(ui);
+            });
+        });
+    }
+}
+
+fn lorem_ipsum(ui: &mut egui::Ui) {
+    ui.with_layout(
+        egui::Layout::top_down(egui::Align::LEFT).with_cross_justify(true),
+        |ui| {
+            ui.label(egui::RichText::new(crate::LOREM_IPSUM_LONG).small().weak());
+            ui.add(egui::Separator::default().grow(8.0));
+            ui.label(egui::RichText::new(crate::LOREM_IPSUM_LONG).small().weak());
+        },
+    );
+}
diff --git a/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
new file mode 100644
index 0000000..04cbe5a
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
@@ -0,0 +1,281 @@
+use egui::{text_edit::CCursorRange, *};
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct EasyMarkEditor {
+    code: String,
+    highlight_editor: bool,
+    show_rendered: bool,
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    highlighter: crate::easy_mark::MemoizedEasymarkHighlighter,
+}
+
+impl PartialEq for EasyMarkEditor {
+    fn eq(&self, other: &Self) -> bool {
+        (&self.code, self.highlight_editor, self.show_rendered)
+            == (&other.code, other.highlight_editor, other.show_rendered)
+    }
+}
+
+impl Default for EasyMarkEditor {
+    fn default() -> Self {
+        Self {
+            code: DEFAULT_CODE.trim().to_owned(),
+            highlight_editor: true,
+            show_rendered: true,
+            highlighter: Default::default(),
+        }
+    }
+}
+
+impl EasyMarkEditor {
+    pub fn panels(&mut self, ctx: &egui::Context) {
+        egui::TopBottomPanel::bottom("easy_mark_bottom").show(ctx, |ui| {
+            let layout = egui::Layout::top_down(egui::Align::Center).with_main_justify(true);
+            ui.allocate_ui_with_layout(ui.available_size(), layout, |ui| {
+                ui.add(crate::egui_github_link_file!())
+            })
+        });
+
+        egui::CentralPanel::default().show(ctx, |ui| {
+            self.ui(ui);
+        });
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        egui::Grid::new("controls").show(ui, |ui| {
+            let _ = ui.button("Hotkeys").on_hover_ui(nested_hotkeys_ui);
+            ui.checkbox(&mut self.show_rendered, "Show rendered");
+            ui.checkbox(&mut self.highlight_editor, "Highlight editor");
+            egui::reset_button(ui, self);
+            ui.end_row();
+        });
+        ui.separator();
+
+        if self.show_rendered {
+            ui.columns(2, |columns| {
+                ScrollArea::vertical()
+                    .id_source("source")
+                    .show(&mut columns[0], |ui| self.editor_ui(ui));
+                ScrollArea::vertical()
+                    .id_source("rendered")
+                    .show(&mut columns[1], |ui| {
+                        // TODO(emilk): we can save some more CPU by caching the rendered output.
+                        crate::easy_mark::easy_mark(ui, &self.code);
+                    });
+            });
+        } else {
+            ScrollArea::vertical()
+                .id_source("source")
+                .show(ui, |ui| self.editor_ui(ui));
+        }
+    }
+
+    fn editor_ui(&mut self, ui: &mut egui::Ui) {
+        let Self {
+            code, highlighter, ..
+        } = self;
+
+        let response = if self.highlight_editor {
+            let mut layouter = |ui: &egui::Ui, easymark: &str, wrap_width: f32| {
+                let mut layout_job = highlighter.highlight(ui.style(), easymark);
+                layout_job.wrap.max_width = wrap_width;
+                ui.fonts(|f| f.layout_job(layout_job))
+            };
+
+            ui.add(
+                egui::TextEdit::multiline(code)
+                    .desired_width(f32::INFINITY)
+                    .font(egui::TextStyle::Monospace) // for cursor height
+                    .layouter(&mut layouter),
+            )
+        } else {
+            ui.add(egui::TextEdit::multiline(code).desired_width(f32::INFINITY))
+        };
+
+        if let Some(mut state) = TextEdit::load_state(ui.ctx(), response.id) {
+            if let Some(mut ccursor_range) = state.ccursor_range() {
+                let any_change = shortcuts(ui, code, &mut ccursor_range);
+                if any_change {
+                    state.set_ccursor_range(Some(ccursor_range));
+                    state.store(ui.ctx(), response.id);
+                }
+            }
+        }
+    }
+}
+
+pub const SHORTCUT_BOLD: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::B);
+pub const SHORTCUT_CODE: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::N);
+pub const SHORTCUT_ITALICS: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::I);
+pub const SHORTCUT_SUBSCRIPT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::L);
+pub const SHORTCUT_SUPERSCRIPT: KeyboardShortcut =
+    KeyboardShortcut::new(Modifiers::COMMAND, Key::Y);
+pub const SHORTCUT_STRIKETHROUGH: KeyboardShortcut =
+    KeyboardShortcut::new(Modifiers::CTRL.plus(Modifiers::SHIFT), Key::Q);
+pub const SHORTCUT_UNDERLINE: KeyboardShortcut =
+    KeyboardShortcut::new(Modifiers::CTRL.plus(Modifiers::SHIFT), Key::W);
+pub const SHORTCUT_INDENT: KeyboardShortcut =
+    KeyboardShortcut::new(Modifiers::CTRL.plus(Modifiers::SHIFT), Key::E);
+
+fn nested_hotkeys_ui(ui: &mut egui::Ui) {
+    egui::Grid::new("shortcuts").striped(true).show(ui, |ui| {
+        let mut label = |shortcut, what| {
+            ui.label(what);
+            ui.weak(ui.ctx().format_shortcut(&shortcut));
+            ui.end_row();
+        };
+
+        label(SHORTCUT_BOLD, "*bold*");
+        label(SHORTCUT_CODE, "`code`");
+        label(SHORTCUT_ITALICS, "/italics/");
+        label(SHORTCUT_SUBSCRIPT, "$subscript$");
+        label(SHORTCUT_SUPERSCRIPT, "^superscript^");
+        label(SHORTCUT_STRIKETHROUGH, "~strikethrough~");
+        label(SHORTCUT_UNDERLINE, "_underline_");
+        label(SHORTCUT_INDENT, "two spaces"); // Placeholder for tab indent
+    });
+}
+
+fn shortcuts(ui: &Ui, code: &mut dyn TextBuffer, ccursor_range: &mut CCursorRange) -> bool {
+    let mut any_change = false;
+
+    if ui.input_mut(|i| i.consume_shortcut(&SHORTCUT_INDENT)) {
+        // This is a placeholder till we can indent the active line
+        any_change = true;
+        let [primary, _secondary] = ccursor_range.sorted();
+
+        let advance = code.insert_text("  ", primary.index);
+        ccursor_range.primary.index += advance;
+        ccursor_range.secondary.index += advance;
+    }
+
+    for (shortcut, surrounding) in [
+        (SHORTCUT_BOLD, "*"),
+        (SHORTCUT_CODE, "`"),
+        (SHORTCUT_ITALICS, "/"),
+        (SHORTCUT_SUBSCRIPT, "$"),
+        (SHORTCUT_SUPERSCRIPT, "^"),
+        (SHORTCUT_STRIKETHROUGH, "~"),
+        (SHORTCUT_UNDERLINE, "_"),
+    ] {
+        if ui.input_mut(|i| i.consume_shortcut(&shortcut)) {
+            any_change = true;
+            toggle_surrounding(code, ccursor_range, surrounding);
+        };
+    }
+
+    any_change
+}
+
+/// E.g. toggle *strong* with `toggle_surrounding(&mut text, &mut cursor, "*")`
+fn toggle_surrounding(
+    code: &mut dyn TextBuffer,
+    ccursor_range: &mut CCursorRange,
+    surrounding: &str,
+) {
+    let [primary, secondary] = ccursor_range.sorted();
+
+    let surrounding_ccount = surrounding.chars().count();
+
+    let prefix_crange = primary.index.saturating_sub(surrounding_ccount)..primary.index;
+    let suffix_crange = secondary.index..secondary.index.saturating_add(surrounding_ccount);
+    let already_surrounded = code.char_range(prefix_crange.clone()) == surrounding
+        && code.char_range(suffix_crange.clone()) == surrounding;
+
+    if already_surrounded {
+        code.delete_char_range(suffix_crange);
+        code.delete_char_range(prefix_crange);
+        ccursor_range.primary.index -= surrounding_ccount;
+        ccursor_range.secondary.index -= surrounding_ccount;
+    } else {
+        code.insert_text(surrounding, secondary.index);
+        let advance = code.insert_text(surrounding, primary.index);
+
+        ccursor_range.primary.index += advance;
+        ccursor_range.secondary.index += advance;
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_CODE: &str = r#"
+# EasyMark
+EasyMark is a markup language, designed for extreme simplicity.
+
+```
+WARNING: EasyMark is still an evolving specification,
+and is also missing some features.
+```
+
+----------------
+
+# At a glance
+- inline text:
+  - normal, `code`, *strong*, ~strikethrough~, _underline_, /italics/, ^raised^, $small$
+  - `\` escapes the next character
+  - [hyperlink](https://github.com/emilk/egui)
+  - Embedded URL: <https://github.com/emilk/egui>
+- `# ` header
+- `---` separator (horizontal line)
+- `> ` quote
+- `- ` bullet list
+- `1. ` numbered list
+- \`\`\` code fence
+- a^2^ + b^2^ = c^2^
+- $Remember to read the small print$
+
+# Design
+> /"Why do what everyone else is doing, when everyone else is already doing it?"
+>   \- Emil
+
+Goals:
+1. easy to parse
+2. easy to learn
+3. similar to markdown
+
+[The reference parser](https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs) is \~250 lines of code, using only the Rust standard library. The parser uses no look-ahead or recursion.
+
+There is never more than one way to accomplish the same thing, and each special character is only used for one thing. For instance `*` is used for *strong* and `-` is used for bullet lists. There is no alternative way to specify the *strong* style or getting a bullet list.
+
+Similarity to markdown is kept when possible, but with much less ambiguity and some improvements (like _underlining_).
+
+# Details
+All style changes are single characters, so it is `*strong*`, NOT `**strong**`. Style is reset by a matching character, or at the end of the line.
+
+Style change characters and escapes (`\`) work everywhere except for in inline code, code blocks and in URLs.
+
+You can mix styles. For instance: /italics _underline_/ and *strong `code`*.
+
+You can use styles on URLs: ~my webpage is at <http://www.example.com>~.
+
+Newlines are preserved. If you want to continue text on the same line, just do so. Alternatively, escape the newline by ending the line with a backslash (`\`). \
+Escaping the newline effectively ignores it.
+
+The style characters are chosen to be similar to what they are representing:
+  `_` = _underline_
+  `~` = ~strikethrough~ (`-` is used for bullet points)
+  `/` = /italics/
+  `*` = *strong*
+  `$` = $small$
+  `^` = ^raised^
+
+# TODO
+- Sub-headers (`## h2`, `### h3` etc)
+- Hotkey Editor
+- International keyboard algorithm for non-letter keys
+- ALT+SHIFT+Num1 is not a functioning hotkey
+- Tab Indent Increment/Decrement CTRL+], CTRL+[
+
+- Images
+  - we want to be able to optionally specify size (width and\/or height)
+  - centering of images is very desirable
+  - captioning (image with a text underneath it)
+  - `![caption=My image][width=200][center](url)` ?
+- Nicer URL:s
+  - `<url>` and `[url](url)` do the same thing yet look completely different.
+  - let's keep similarity with images
+- Tables
+- Inspiration: <https://mycorrhiza.lesarbr.es/page/mycomarkup>
+"#;
diff --git a/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
new file mode 100644
index 0000000..c15a285
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
@@ -0,0 +1,192 @@
+use crate::easy_mark::easy_mark_parser;
+
+/// Highlight easymark, memoizing previous output to save CPU.
+///
+/// In practice, the highlighter is fast enough not to need any caching.
+#[derive(Default)]
+pub struct MemoizedEasymarkHighlighter {
+    style: egui::Style,
+    code: String,
+    output: egui::text::LayoutJob,
+}
+
+impl MemoizedEasymarkHighlighter {
+    pub fn highlight(&mut self, egui_style: &egui::Style, code: &str) -> egui::text::LayoutJob {
+        if (&self.style, self.code.as_str()) != (egui_style, code) {
+            self.style = egui_style.clone();
+            self.code = code.to_owned();
+            self.output = highlight_easymark(egui_style, code);
+        }
+        self.output.clone()
+    }
+}
+
+pub fn highlight_easymark(egui_style: &egui::Style, mut text: &str) -> egui::text::LayoutJob {
+    let mut job = egui::text::LayoutJob::default();
+    let mut style = easy_mark_parser::Style::default();
+    let mut start_of_line = true;
+
+    while !text.is_empty() {
+        if start_of_line && text.starts_with("```") {
+            let end = text.find("\n```").map_or_else(|| text.len(), |i| i + 4);
+            job.append(
+                &text[..end],
+                0.0,
+                format_from_style(
+                    egui_style,
+                    &easy_mark_parser::Style {
+                        code: true,
+                        ..Default::default()
+                    },
+                ),
+            );
+            text = &text[end..];
+            style = Default::default();
+            continue;
+        }
+
+        if text.starts_with('`') {
+            style.code = true;
+            let end = text[1..]
+                .find(&['`', '\n'][..])
+                .map_or_else(|| text.len(), |i| i + 2);
+            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
+            text = &text[end..];
+            style.code = false;
+            continue;
+        }
+
+        let mut skip;
+
+        if text.starts_with('\\') && text.len() >= 2 {
+            skip = 2;
+        } else if start_of_line && text.starts_with(' ') {
+            // we don't preview indentation, because it is confusing
+            skip = 1;
+        } else if start_of_line && text.starts_with("# ") {
+            style.heading = true;
+            skip = 2;
+        } else if start_of_line && text.starts_with("> ") {
+            style.quoted = true;
+            skip = 2;
+            // we don't preview indentation, because it is confusing
+        } else if start_of_line && text.starts_with("- ") {
+            skip = 2;
+            // we don't preview indentation, because it is confusing
+        } else if text.starts_with('*') {
+            skip = 1;
+            if style.strong {
+                // Include the character that is ending this style:
+                job.append(&text[..skip], 0.0, format_from_style(egui_style, &style));
+                text = &text[skip..];
+                skip = 0;
+            }
+            style.strong ^= true;
+        } else if text.starts_with('$') {
+            skip = 1;
+            if style.small {
+                // Include the character that is ending this style:
+                job.append(&text[..skip], 0.0, format_from_style(egui_style, &style));
+                text = &text[skip..];
+                skip = 0;
+            }
+            style.small ^= true;
+        } else if text.starts_with('^') {
+            skip = 1;
+            if style.raised {
+                // Include the character that is ending this style:
+                job.append(&text[..skip], 0.0, format_from_style(egui_style, &style));
+                text = &text[skip..];
+                skip = 0;
+            }
+            style.raised ^= true;
+        } else {
+            skip = 0;
+        }
+        // Note: we don't preview underline, strikethrough and italics because it confuses things.
+
+        // Swallow everything up to the next special character:
+        let line_end = text[skip..]
+            .find('\n')
+            .map_or_else(|| text.len(), |i| (skip + i + 1));
+        let end = text[skip..]
+            .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '['][..])
+            .map_or_else(|| text.len(), |i| (skip + i).max(1));
+
+        if line_end <= end {
+            job.append(
+                &text[..line_end],
+                0.0,
+                format_from_style(egui_style, &style),
+            );
+            text = &text[line_end..];
+            start_of_line = true;
+            style = Default::default();
+        } else {
+            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
+            text = &text[end..];
+            start_of_line = false;
+        }
+    }
+
+    job
+}
+
+fn format_from_style(
+    egui_style: &egui::Style,
+    emark_style: &easy_mark_parser::Style,
+) -> egui::text::TextFormat {
+    use egui::{Align, Color32, Stroke, TextStyle};
+
+    let color = if emark_style.strong || emark_style.heading {
+        egui_style.visuals.strong_text_color()
+    } else if emark_style.quoted {
+        egui_style.visuals.weak_text_color()
+    } else {
+        egui_style.visuals.text_color()
+    };
+
+    let text_style = if emark_style.heading {
+        TextStyle::Heading
+    } else if emark_style.code {
+        TextStyle::Monospace
+    } else if emark_style.small | emark_style.raised {
+        TextStyle::Small
+    } else {
+        TextStyle::Body
+    };
+
+    let background = if emark_style.code {
+        egui_style.visuals.code_bg_color
+    } else {
+        Color32::TRANSPARENT
+    };
+
+    let underline = if emark_style.underline {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let strikethrough = if emark_style.strikethrough {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let valign = if emark_style.raised {
+        Align::TOP
+    } else {
+        Align::BOTTOM
+    };
+
+    egui::text::TextFormat {
+        font_id: text_style.resolve(egui_style),
+        color,
+        background,
+        italics: emark_style.italics,
+        underline,
+        strikethrough,
+        valign,
+    }
+}
diff --git a/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
new file mode 100644
index 0000000..75d8135
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
@@ -0,0 +1,356 @@
+//! A parser for `EasyMark`: a very simple markup language.
+//!
+//! WARNING: `EasyMark` is subject to change.
+//
+//! # `EasyMark` design goals:
+//! 1. easy to parse
+//! 2. easy to learn
+//! 3. similar to markdown
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Item<'a> {
+    /// `\n`
+    // TODO(emilk): add Style here so empty heading still uses up the right amount of space.
+    Newline,
+
+    ///
+    Text(Style, &'a str),
+
+    /// title, url
+    Hyperlink(Style, &'a str, &'a str),
+
+    /// leading space before e.g. a [`Self::BulletPoint`].
+    Indentation(usize),
+
+    /// >
+    QuoteIndent,
+
+    /// - a point well made.
+    BulletPoint,
+
+    /// 1. numbered list. The string is the number(s).
+    NumberedPoint(&'a str),
+
+    /// ---
+    Separator,
+
+    /// language, code
+    CodeBlock(&'a str, &'a str),
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct Style {
+    /// # heading (large text)
+    pub heading: bool,
+
+    /// > quoted (slightly dimmer color or other font style)
+    pub quoted: bool,
+
+    /// `code` (monospace, some other color)
+    pub code: bool,
+
+    /// self.strong* (emphasized, e.g. bold)
+    pub strong: bool,
+
+    /// _underline_
+    pub underline: bool,
+
+    /// ~strikethrough~
+    pub strikethrough: bool,
+
+    /// /italics/
+    pub italics: bool,
+
+    /// $small$
+    pub small: bool,
+
+    /// ^raised^
+    pub raised: bool,
+}
+
+/// Parser for the `EasyMark` markup language.
+///
+/// See the module-level documentation for details.
+///
+/// # Example:
+/// ```
+/// # use egui_demo_lib::easy_mark::parser::Parser;
+/// for item in Parser::new("Hello *world*!") {
+/// }
+///
+/// ```
+pub struct Parser<'a> {
+    /// The remainder of the input text
+    s: &'a str,
+
+    /// Are we at the start of a line?
+    start_of_line: bool,
+
+    /// Current self.style. Reset after a newline.
+    style: Style,
+}
+
+impl<'a> Parser<'a> {
+    pub fn new(s: &'a str) -> Self {
+        Self {
+            s,
+            start_of_line: true,
+            style: Style::default(),
+        }
+    }
+
+    /// `1. `, `42. ` etc.
+    fn numbered_list(&mut self) -> Option<Item<'a>> {
+        let n_digits = self.s.chars().take_while(|c| c.is_ascii_digit()).count();
+        if n_digits > 0 && self.s.chars().skip(n_digits).take(2).eq(". ".chars()) {
+            let number = &self.s[..n_digits];
+            self.s = &self.s[(n_digits + 2)..];
+            self.start_of_line = false;
+            return Some(Item::NumberedPoint(number));
+        }
+        None
+    }
+
+    // ```{language}\n{code}```
+    fn code_block(&mut self) -> Option<Item<'a>> {
+        if let Some(language_start) = self.s.strip_prefix("```") {
+            if let Some(newline) = language_start.find('\n') {
+                let language = &language_start[..newline];
+                let code_start = &language_start[newline + 1..];
+                if let Some(end) = code_start.find("\n```") {
+                    let code = &code_start[..end].trim();
+                    self.s = &code_start[end + 4..];
+                    self.start_of_line = false;
+                    return Some(Item::CodeBlock(language, code));
+                } else {
+                    self.s = "";
+                    return Some(Item::CodeBlock(language, code_start));
+                }
+            }
+        }
+        None
+    }
+
+    // `code`
+    fn inline_code(&mut self) -> Option<Item<'a>> {
+        if let Some(rest) = self.s.strip_prefix('`') {
+            self.s = rest;
+            self.start_of_line = false;
+            self.style.code = true;
+            let rest_of_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
+            if let Some(end) = rest_of_line.find('`') {
+                let item = Item::Text(self.style, &self.s[..end]);
+                self.s = &self.s[end + 1..];
+                self.style.code = false;
+                return Some(item);
+            } else {
+                let end = rest_of_line.len();
+                let item = Item::Text(self.style, rest_of_line);
+                self.s = &self.s[end..];
+                self.style.code = false;
+                return Some(item);
+            }
+        }
+        None
+    }
+
+    /// `<url>` or `[link](url)`
+    fn url(&mut self) -> Option<Item<'a>> {
+        if self.s.starts_with('<') {
+            let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
+            if let Some(url_end) = this_line.find('>') {
+                let url = &self.s[1..url_end];
+                self.s = &self.s[url_end + 1..];
+                self.start_of_line = false;
+                return Some(Item::Hyperlink(self.style, url, url));
+            }
+        }
+
+        // [text](url)
+        if self.s.starts_with('[') {
+            let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
+            if let Some(bracket_end) = this_line.find(']') {
+                let text = &this_line[1..bracket_end];
+                if this_line[bracket_end + 1..].starts_with('(') {
+                    if let Some(parens_end) = this_line[bracket_end + 2..].find(')') {
+                        let parens_end = bracket_end + 2 + parens_end;
+                        let url = &self.s[bracket_end + 2..parens_end];
+                        self.s = &self.s[parens_end + 1..];
+                        self.start_of_line = false;
+                        return Some(Item::Hyperlink(self.style, text, url));
+                    }
+                }
+            }
+        }
+        None
+    }
+}
+
+impl<'a> Iterator for Parser<'a> {
+    type Item = Item<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.s.is_empty() {
+                return None;
+            }
+
+            // \n
+            if self.s.starts_with('\n') {
+                self.s = &self.s[1..];
+                self.start_of_line = true;
+                self.style = Style::default();
+                return Some(Item::Newline);
+            }
+
+            // Ignore line break (continue on the same line)
+            if self.s.starts_with("\\\n") && self.s.len() >= 2 {
+                self.s = &self.s[2..];
+                self.start_of_line = false;
+                continue;
+            }
+
+            // \ escape (to show e.g. a backtick)
+            if self.s.starts_with('\\') && self.s.len() >= 2 {
+                let text = &self.s[1..2];
+                self.s = &self.s[2..];
+                self.start_of_line = false;
+                return Some(Item::Text(self.style, text));
+            }
+
+            if self.start_of_line {
+                // leading space (indentation)
+                if self.s.starts_with(' ') {
+                    let length = self.s.find(|c| c != ' ').unwrap_or(self.s.len());
+                    self.s = &self.s[length..];
+                    self.start_of_line = true; // indentation doesn't count
+                    return Some(Item::Indentation(length));
+                }
+
+                // # Heading
+                if let Some(after) = self.s.strip_prefix("# ") {
+                    self.s = after;
+                    self.start_of_line = false;
+                    self.style.heading = true;
+                    continue;
+                }
+
+                // > quote
+                if let Some(after) = self.s.strip_prefix("> ") {
+                    self.s = after;
+                    self.start_of_line = true; // quote indentation doesn't count
+                    self.style.quoted = true;
+                    return Some(Item::QuoteIndent);
+                }
+
+                // - bullet point
+                if self.s.starts_with("- ") {
+                    self.s = &self.s[2..];
+                    self.start_of_line = false;
+                    return Some(Item::BulletPoint);
+                }
+
+                // `1. `, `42. ` etc.
+                if let Some(item) = self.numbered_list() {
+                    return Some(item);
+                }
+
+                // --- separator
+                if let Some(after) = self.s.strip_prefix("---") {
+                    self.s = after.trim_start_matches('-'); // remove extra dashes
+                    self.s = self.s.strip_prefix('\n').unwrap_or(self.s); // remove trailing newline
+                    self.start_of_line = false;
+                    return Some(Item::Separator);
+                }
+
+                // ```{language}\n{code}```
+                if let Some(item) = self.code_block() {
+                    return Some(item);
+                }
+            }
+
+            // `code`
+            if let Some(item) = self.inline_code() {
+                return Some(item);
+            }
+
+            if let Some(rest) = self.s.strip_prefix('*') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.strong = !self.style.strong;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('_') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.underline = !self.style.underline;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('~') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.strikethrough = !self.style.strikethrough;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('/') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.italics = !self.style.italics;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('$') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.small = !self.style.small;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('^') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.raised = !self.style.raised;
+                continue;
+            }
+
+            // `<url>` or `[link](url)`
+            if let Some(item) = self.url() {
+                return Some(item);
+            }
+
+            // Swallow everything up to the next special character:
+            let end = self
+                .s
+                .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '[', '\n'][..])
+                .map_or_else(|| self.s.len(), |special| special.max(1));
+
+            let item = Item::Text(self.style, &self.s[..end]);
+            self.s = &self.s[end..];
+            self.start_of_line = false;
+            return Some(item);
+        }
+    }
+}
+
+#[test]
+fn test_easy_mark_parser() {
+    let items: Vec<_> = Parser::new("~strikethrough `code`~").collect();
+    assert_eq!(
+        items,
+        vec![
+            Item::Text(
+                Style {
+                    strikethrough: true,
+                    ..Default::default()
+                },
+                "strikethrough "
+            ),
+            Item::Text(
+                Style {
+                    code: true,
+                    strikethrough: true,
+                    ..Default::default()
+                },
+                "code"
+            ),
+        ]
+    );
+}
diff --git a/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
new file mode 100644
index 0000000..44408ff
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
@@ -0,0 +1,174 @@
+use super::easy_mark_parser as easy_mark;
+use egui::*;
+
+/// Parse and display a VERY simple and small subset of Markdown.
+pub fn easy_mark(ui: &mut Ui, easy_mark: &str) {
+    easy_mark_it(ui, easy_mark::Parser::new(easy_mark));
+}
+
+pub fn easy_mark_it<'em>(ui: &mut Ui, items: impl Iterator<Item = easy_mark::Item<'em>>) {
+    let initial_size = vec2(
+        ui.available_width(),
+        ui.spacing().interact_size.y, // Assume there will be
+    );
+
+    let layout = Layout::left_to_right(Align::BOTTOM).with_main_wrap(true);
+
+    ui.allocate_ui_with_layout(initial_size, layout, |ui| {
+        ui.spacing_mut().item_spacing.x = 0.0;
+        let row_height = ui.text_style_height(&TextStyle::Body);
+        ui.set_row_height(row_height);
+
+        for item in items {
+            item_ui(ui, item);
+        }
+    });
+}
+
+pub fn item_ui(ui: &mut Ui, item: easy_mark::Item<'_>) {
+    let row_height = ui.text_style_height(&TextStyle::Body);
+    let one_indent = row_height / 2.0;
+
+    match item {
+        easy_mark::Item::Newline => {
+            // ui.label("\n"); // too much spacing (paragraph spacing)
+            ui.allocate_exact_size(vec2(0.0, row_height), Sense::hover()); // make sure we take up some height
+            ui.end_row();
+            ui.set_row_height(row_height);
+        }
+
+        easy_mark::Item::Text(style, text) => {
+            let label = rich_text_from_style(text, &style);
+            if style.small && !style.raised {
+                ui.with_layout(Layout::left_to_right(Align::BOTTOM), |ui| {
+                    ui.set_min_height(row_height);
+                    ui.label(label);
+                });
+            } else {
+                ui.label(label);
+            }
+        }
+        easy_mark::Item::Hyperlink(style, text, url) => {
+            let label = rich_text_from_style(text, &style);
+            if style.small && !style.raised {
+                ui.with_layout(Layout::left_to_right(Align::BOTTOM), |ui| {
+                    ui.set_height(row_height);
+                    ui.add(Hyperlink::from_label_and_url(label, url));
+                });
+            } else {
+                ui.add(Hyperlink::from_label_and_url(label, url));
+            }
+        }
+
+        easy_mark::Item::Separator => {
+            ui.add(Separator::default().horizontal());
+        }
+        easy_mark::Item::Indentation(indent) => {
+            let indent = indent as f32 * one_indent;
+            ui.allocate_exact_size(vec2(indent, row_height), Sense::hover());
+        }
+        easy_mark::Item::QuoteIndent => {
+            let rect = ui
+                .allocate_exact_size(vec2(2.0 * one_indent, row_height), Sense::hover())
+                .0;
+            let rect = rect.expand2(ui.style().spacing.item_spacing * 0.5);
+            ui.painter().line_segment(
+                [rect.center_top(), rect.center_bottom()],
+                (1.0, ui.visuals().weak_text_color()),
+            );
+        }
+        easy_mark::Item::BulletPoint => {
+            ui.allocate_exact_size(vec2(one_indent, row_height), Sense::hover());
+            bullet_point(ui, one_indent);
+            ui.allocate_exact_size(vec2(one_indent, row_height), Sense::hover());
+        }
+        easy_mark::Item::NumberedPoint(number) => {
+            let width = 3.0 * one_indent;
+            numbered_point(ui, width, number);
+            ui.allocate_exact_size(vec2(one_indent, row_height), Sense::hover());
+        }
+        easy_mark::Item::CodeBlock(_language, code) => {
+            let where_to_put_background = ui.painter().add(Shape::Noop);
+            let mut rect = ui.monospace(code).rect;
+            rect = rect.expand(1.0); // looks better
+            rect.max.x = ui.max_rect().max.x;
+            let code_bg_color = ui.visuals().code_bg_color;
+            ui.painter().set(
+                where_to_put_background,
+                Shape::rect_filled(rect, 1.0, code_bg_color),
+            );
+        }
+    };
+}
+
+fn rich_text_from_style(text: &str, style: &easy_mark::Style) -> RichText {
+    let easy_mark::Style {
+        heading,
+        quoted,
+        code,
+        strong,
+        underline,
+        strikethrough,
+        italics,
+        small,
+        raised,
+    } = *style;
+
+    let small = small || raised; // Raised text is also smaller
+
+    let mut rich_text = RichText::new(text);
+    if heading && !small {
+        rich_text = rich_text.heading().strong();
+    }
+    if small && !heading {
+        rich_text = rich_text.small();
+    }
+    if code {
+        rich_text = rich_text.code();
+    }
+    if strong {
+        rich_text = rich_text.strong();
+    } else if quoted {
+        rich_text = rich_text.weak();
+    }
+    if underline {
+        rich_text = rich_text.underline();
+    }
+    if strikethrough {
+        rich_text = rich_text.strikethrough();
+    }
+    if italics {
+        rich_text = rich_text.italics();
+    }
+    if raised {
+        rich_text = rich_text.raised();
+    }
+    rich_text
+}
+
+fn bullet_point(ui: &mut Ui, width: f32) -> Response {
+    let row_height = ui.text_style_height(&TextStyle::Body);
+    let (rect, response) = ui.allocate_exact_size(vec2(width, row_height), Sense::hover());
+    ui.painter().circle_filled(
+        rect.center(),
+        rect.height() / 8.0,
+        ui.visuals().strong_text_color(),
+    );
+    response
+}
+
+fn numbered_point(ui: &mut Ui, width: f32, number: &str) -> Response {
+    let font_id = TextStyle::Body.resolve(ui.style());
+    let row_height = ui.fonts(|f| f.row_height(&font_id));
+    let (rect, response) = ui.allocate_exact_size(vec2(width, row_height), Sense::hover());
+    let text = format!("{}.", number);
+    let text_color = ui.visuals().strong_text_color();
+    ui.painter().text(
+        rect.right_center(),
+        Align2::RIGHT_CENTER,
+        text,
+        font_id,
+        text_color,
+    );
+    response
+}
diff --git a/egui/crates/egui_demo_lib/src/easy_mark/mod.rs b/egui/crates/egui_demo_lib/src/easy_mark/mod.rs
new file mode 100644
index 0000000..d56b4fa
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/easy_mark/mod.rs
@@ -0,0 +1,11 @@
+//! Experimental markup language
+
+mod easy_mark_editor;
+mod easy_mark_highlighter;
+pub mod easy_mark_parser;
+mod easy_mark_viewer;
+
+pub use easy_mark_editor::EasyMarkEditor;
+pub use easy_mark_highlighter::MemoizedEasymarkHighlighter;
+pub use easy_mark_parser as parser;
+pub use easy_mark_viewer::easy_mark;
diff --git a/egui/crates/egui_demo_lib/src/lib.rs b/egui/crates/egui_demo_lib/src/lib.rs
new file mode 100644
index 0000000..43db89f
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/lib.rs
@@ -0,0 +1,109 @@
+//! Demo-code for showing how egui is used.
+//!
+//! This library can be used to test 3rd party egui integrations (see for instance <https://github.com/not-fl3/egui-miniquad/blob/master/examples/demo.rs>).
+//!
+//! The demo is also used in benchmarks and tests.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![allow(clippy::manual_range_contains)]
+#![forbid(unsafe_code)]
+
+mod color_test;
+mod demo;
+pub mod easy_mark;
+pub mod syntax_highlighting;
+
+pub use color_test::ColorTest;
+pub use demo::DemoWindows;
+
+// ----------------------------------------------------------------------------
+
+/// Create a [`Hyperlink`](egui::Hyperlink) to this egui source code file on github.
+#[macro_export]
+macro_rules! egui_github_link_file {
+    () => {
+        $crate::egui_github_link_file!("(source code)")
+    };
+    ($label: expr) => {
+        egui::github_link_file!(
+            "https://github.com/emilk/egui/blob/master/",
+            egui::RichText::new($label).small()
+        )
+    };
+}
+
+/// Create a [`Hyperlink`](egui::Hyperlink) to this egui source code file and line on github.
+#[macro_export]
+macro_rules! egui_github_link_file_line {
+    () => {
+        $crate::egui_github_link_file_line!("(source code)")
+    };
+    ($label: expr) => {
+        egui::github_link_file_line!(
+            "https://github.com/emilk/egui/blob/master/",
+            egui::RichText::new($label).small()
+        )
+    };
+}
+
+// ----------------------------------------------------------------------------
+
+pub const LOREM_IPSUM: &str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
+
+pub const LOREM_IPSUM_LONG: &str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam various, turpis et commodo pharetra, est eros bibendum elit, nec luctus magna felis sollicitudin mauris. Integer in mauris eu nibh euismod gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue, eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis, neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis, molestie eu, feugiat in, orci. In hac habitasse platea dictumst.";
+
+// ----------------------------------------------------------------------------
+
+#[test]
+fn test_egui_e2e() {
+    let mut demo_windows = crate::DemoWindows::default();
+    let ctx = egui::Context::default();
+    let raw_input = egui::RawInput::default();
+
+    const NUM_FRAMES: usize = 5;
+    for _ in 0..NUM_FRAMES {
+        let full_output = ctx.run(raw_input.clone(), |ctx| {
+            demo_windows.ui(ctx);
+        });
+        let clipped_primitives = ctx.tessellate(full_output.shapes);
+        assert!(!clipped_primitives.is_empty());
+    }
+}
+
+#[test]
+fn test_egui_zero_window_size() {
+    let mut demo_windows = crate::DemoWindows::default();
+    let ctx = egui::Context::default();
+    let raw_input = egui::RawInput {
+        screen_rect: Some(egui::Rect::from_min_max(egui::Pos2::ZERO, egui::Pos2::ZERO)),
+        ..Default::default()
+    };
+
+    const NUM_FRAMES: usize = 5;
+    for _ in 0..NUM_FRAMES {
+        let full_output = ctx.run(raw_input.clone(), |ctx| {
+            demo_windows.ui(ctx);
+        });
+        let clipped_primitives = ctx.tessellate(full_output.shapes);
+        assert!(
+            clipped_primitives.is_empty(),
+            "There should be nothing to show, has at least one primitive with clip_rect: {:?}",
+            clipped_primitives[0].clip_rect
+        );
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Detect narrow screens. This is used to show a simpler UI on mobile devices,
+/// especially for the web demo at <https://egui.rs>.
+pub fn is_mobile(ctx: &egui::Context) -> bool {
+    let screen_size = ctx.screen_rect().size();
+    screen_size.x < 550.0
+}
diff --git a/egui/crates/egui_demo_lib/src/syntax_highlighting.rs b/egui/crates/egui_demo_lib/src/syntax_highlighting.rs
new file mode 100644
index 0000000..50f1ff9
--- /dev/null
+++ b/egui/crates/egui_demo_lib/src/syntax_highlighting.rs
@@ -0,0 +1,506 @@
+use egui::text::LayoutJob;
+
+/// View some code with syntax highlighting and selection.
+pub fn code_view_ui(ui: &mut egui::Ui, mut code: &str) {
+    let language = "rs";
+    let theme = CodeTheme::from_memory(ui.ctx());
+
+    let mut layouter = |ui: &egui::Ui, string: &str, _wrap_width: f32| {
+        let layout_job = highlight(ui.ctx(), &theme, string, language);
+        // layout_job.wrap.max_width = wrap_width; // no wrapping
+        ui.fonts(|f| f.layout_job(layout_job))
+    };
+
+    ui.add(
+        egui::TextEdit::multiline(&mut code)
+            .font(egui::TextStyle::Monospace) // for cursor height
+            .code_editor()
+            .desired_rows(1)
+            .lock_focus(true)
+            .layouter(&mut layouter),
+    );
+}
+
+/// Memoized Code highlighting
+pub fn highlight(ctx: &egui::Context, theme: &CodeTheme, code: &str, language: &str) -> LayoutJob {
+    impl egui::util::cache::ComputerMut<(&CodeTheme, &str, &str), LayoutJob> for Highlighter {
+        fn compute(&mut self, (theme, code, lang): (&CodeTheme, &str, &str)) -> LayoutJob {
+            self.highlight(theme, code, lang)
+        }
+    }
+
+    type HighlightCache = egui::util::cache::FrameCache<LayoutJob, Highlighter>;
+
+    ctx.memory_mut(|mem| {
+        mem.caches
+            .cache::<HighlightCache>()
+            .get((theme, code, language))
+    })
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(not(feature = "syntect"))]
+#[derive(Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[derive(enum_map::Enum)]
+enum TokenType {
+    Comment,
+    Keyword,
+    Literal,
+    StringLiteral,
+    Punctuation,
+    Whitespace,
+}
+
+#[cfg(feature = "syntect")]
+#[derive(Clone, Copy, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+enum SyntectTheme {
+    Base16EightiesDark,
+    Base16MochaDark,
+    Base16OceanDark,
+    Base16OceanLight,
+    InspiredGitHub,
+    SolarizedDark,
+    SolarizedLight,
+}
+
+#[cfg(feature = "syntect")]
+impl SyntectTheme {
+    fn all() -> impl ExactSizeIterator<Item = Self> {
+        [
+            Self::Base16EightiesDark,
+            Self::Base16MochaDark,
+            Self::Base16OceanDark,
+            Self::Base16OceanLight,
+            Self::InspiredGitHub,
+            Self::SolarizedDark,
+            Self::SolarizedLight,
+        ]
+        .iter()
+        .copied()
+    }
+
+    fn name(&self) -> &'static str {
+        match self {
+            Self::Base16EightiesDark => "Base16 Eighties (dark)",
+            Self::Base16MochaDark => "Base16 Mocha (dark)",
+            Self::Base16OceanDark => "Base16 Ocean (dark)",
+            Self::Base16OceanLight => "Base16 Ocean (light)",
+            Self::InspiredGitHub => "InspiredGitHub (light)",
+            Self::SolarizedDark => "Solarized (dark)",
+            Self::SolarizedLight => "Solarized (light)",
+        }
+    }
+
+    fn syntect_key_name(&self) -> &'static str {
+        match self {
+            Self::Base16EightiesDark => "base16-eighties.dark",
+            Self::Base16MochaDark => "base16-mocha.dark",
+            Self::Base16OceanDark => "base16-ocean.dark",
+            Self::Base16OceanLight => "base16-ocean.light",
+            Self::InspiredGitHub => "InspiredGitHub",
+            Self::SolarizedDark => "Solarized (dark)",
+            Self::SolarizedLight => "Solarized (light)",
+        }
+    }
+
+    pub fn is_dark(&self) -> bool {
+        match self {
+            Self::Base16EightiesDark
+            | Self::Base16MochaDark
+            | Self::Base16OceanDark
+            | Self::SolarizedDark => true,
+
+            Self::Base16OceanLight | Self::InspiredGitHub | Self::SolarizedLight => false,
+        }
+    }
+}
+
+#[derive(Clone, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct CodeTheme {
+    dark_mode: bool,
+
+    #[cfg(feature = "syntect")]
+    syntect_theme: SyntectTheme,
+
+    #[cfg(not(feature = "syntect"))]
+    formats: enum_map::EnumMap<TokenType, egui::TextFormat>,
+}
+
+impl Default for CodeTheme {
+    fn default() -> Self {
+        Self::dark()
+    }
+}
+
+impl CodeTheme {
+    pub fn from_style(style: &egui::Style) -> Self {
+        if style.visuals.dark_mode {
+            Self::dark()
+        } else {
+            Self::light()
+        }
+    }
+
+    pub fn from_memory(ctx: &egui::Context) -> Self {
+        if ctx.style().visuals.dark_mode {
+            ctx.data_mut(|d| {
+                d.get_persisted(egui::Id::new("dark"))
+                    .unwrap_or_else(CodeTheme::dark)
+            })
+        } else {
+            ctx.data_mut(|d| {
+                d.get_persisted(egui::Id::new("light"))
+                    .unwrap_or_else(CodeTheme::light)
+            })
+        }
+    }
+
+    pub fn store_in_memory(self, ctx: &egui::Context) {
+        if self.dark_mode {
+            ctx.data_mut(|d| d.insert_persisted(egui::Id::new("dark"), self));
+        } else {
+            ctx.data_mut(|d| d.insert_persisted(egui::Id::new("light"), self));
+        }
+    }
+}
+
+#[cfg(feature = "syntect")]
+impl CodeTheme {
+    pub fn dark() -> Self {
+        Self {
+            dark_mode: true,
+            syntect_theme: SyntectTheme::Base16MochaDark,
+        }
+    }
+
+    pub fn light() -> Self {
+        Self {
+            dark_mode: false,
+            syntect_theme: SyntectTheme::SolarizedLight,
+        }
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        egui::widgets::global_dark_light_mode_buttons(ui);
+
+        for theme in SyntectTheme::all() {
+            if theme.is_dark() == self.dark_mode {
+                ui.radio_value(&mut self.syntect_theme, theme, theme.name());
+            }
+        }
+    }
+}
+
+#[cfg(not(feature = "syntect"))]
+impl CodeTheme {
+    pub fn dark() -> Self {
+        let font_id = egui::FontId::monospace(10.0);
+        use egui::{Color32, TextFormat};
+        Self {
+            dark_mode: true,
+            formats: enum_map::enum_map![
+                TokenType::Comment => TextFormat::simple(font_id.clone(), Color32::from_gray(120)),
+                TokenType::Keyword => TextFormat::simple(font_id.clone(), Color32::from_rgb(255, 100, 100)),
+                TokenType::Literal => TextFormat::simple(font_id.clone(), Color32::from_rgb(87, 165, 171)),
+                TokenType::StringLiteral => TextFormat::simple(font_id.clone(), Color32::from_rgb(109, 147, 226)),
+                TokenType::Punctuation => TextFormat::simple(font_id.clone(), Color32::LIGHT_GRAY),
+                TokenType::Whitespace => TextFormat::simple(font_id.clone(), Color32::TRANSPARENT),
+            ],
+        }
+    }
+
+    pub fn light() -> Self {
+        let font_id = egui::FontId::monospace(10.0);
+        use egui::{Color32, TextFormat};
+        Self {
+            dark_mode: false,
+            #[cfg(not(feature = "syntect"))]
+            formats: enum_map::enum_map![
+                TokenType::Comment => TextFormat::simple(font_id.clone(), Color32::GRAY),
+                TokenType::Keyword => TextFormat::simple(font_id.clone(), Color32::from_rgb(235, 0, 0)),
+                TokenType::Literal => TextFormat::simple(font_id.clone(), Color32::from_rgb(153, 134, 255)),
+                TokenType::StringLiteral => TextFormat::simple(font_id.clone(), Color32::from_rgb(37, 203, 105)),
+                TokenType::Punctuation => TextFormat::simple(font_id.clone(), Color32::DARK_GRAY),
+                TokenType::Whitespace => TextFormat::simple(font_id.clone(), Color32::TRANSPARENT),
+            ],
+        }
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal_top(|ui| {
+            let selected_id = egui::Id::null();
+            let mut selected_tt: TokenType =
+                ui.data_mut(|d| *d.get_persisted_mut_or(selected_id, TokenType::Comment));
+
+            ui.vertical(|ui| {
+                ui.set_width(150.0);
+                egui::widgets::global_dark_light_mode_buttons(ui);
+
+                ui.add_space(8.0);
+                ui.separator();
+                ui.add_space(8.0);
+
+                ui.scope(|ui| {
+                    for (tt, tt_name) in [
+                        (TokenType::Comment, "// comment"),
+                        (TokenType::Keyword, "keyword"),
+                        (TokenType::Literal, "literal"),
+                        (TokenType::StringLiteral, "\"string literal\""),
+                        (TokenType::Punctuation, "punctuation ;"),
+                        // (TokenType::Whitespace, "whitespace"),
+                    ] {
+                        let format = &mut self.formats[tt];
+                        ui.style_mut().override_font_id = Some(format.font_id.clone());
+                        ui.visuals_mut().override_text_color = Some(format.color);
+                        ui.radio_value(&mut selected_tt, tt, tt_name);
+                    }
+                });
+
+                let reset_value = if self.dark_mode {
+                    CodeTheme::dark()
+                } else {
+                    CodeTheme::light()
+                };
+
+                if ui
+                    .add_enabled(*self != reset_value, egui::Button::new("Reset theme"))
+                    .clicked()
+                {
+                    *self = reset_value;
+                }
+            });
+
+            ui.add_space(16.0);
+
+            ui.data_mut(|d| d.insert_persisted(selected_id, selected_tt));
+
+            egui::Frame::group(ui.style())
+                .inner_margin(egui::Vec2::splat(2.0))
+                .show(ui, |ui| {
+                    // ui.group(|ui| {
+                    ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
+                    ui.spacing_mut().slider_width = 128.0; // Controls color picker size
+                    egui::widgets::color_picker::color_picker_color32(
+                        ui,
+                        &mut self.formats[selected_tt].color,
+                        egui::color_picker::Alpha::Opaque,
+                    );
+                });
+        });
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "syntect")]
+struct Highlighter {
+    ps: syntect::parsing::SyntaxSet,
+    ts: syntect::highlighting::ThemeSet,
+}
+
+#[cfg(feature = "syntect")]
+impl Default for Highlighter {
+    fn default() -> Self {
+        Self {
+            ps: syntect::parsing::SyntaxSet::load_defaults_newlines(),
+            ts: syntect::highlighting::ThemeSet::load_defaults(),
+        }
+    }
+}
+
+#[cfg(feature = "syntect")]
+impl Highlighter {
+    #[allow(clippy::unused_self, clippy::unnecessary_wraps)]
+    fn highlight(&self, theme: &CodeTheme, code: &str, lang: &str) -> LayoutJob {
+        self.highlight_impl(theme, code, lang).unwrap_or_else(|| {
+            // Fallback:
+            LayoutJob::simple(
+                code.into(),
+                egui::FontId::monospace(12.0),
+                if theme.dark_mode {
+                    egui::Color32::LIGHT_GRAY
+                } else {
+                    egui::Color32::DARK_GRAY
+                },
+                f32::INFINITY,
+            )
+        })
+    }
+
+    fn highlight_impl(&self, theme: &CodeTheme, text: &str, language: &str) -> Option<LayoutJob> {
+        use syntect::easy::HighlightLines;
+        use syntect::highlighting::FontStyle;
+        use syntect::util::LinesWithEndings;
+
+        let syntax = self
+            .ps
+            .find_syntax_by_name(language)
+            .or_else(|| self.ps.find_syntax_by_extension(language))?;
+
+        let theme = theme.syntect_theme.syntect_key_name();
+        let mut h = HighlightLines::new(syntax, &self.ts.themes[theme]);
+
+        use egui::text::{LayoutSection, TextFormat};
+
+        let mut job = LayoutJob {
+            text: text.into(),
+            ..Default::default()
+        };
+
+        for line in LinesWithEndings::from(text) {
+            for (style, range) in h.highlight_line(line, &self.ps).ok()? {
+                let fg = style.foreground;
+                let text_color = egui::Color32::from_rgb(fg.r, fg.g, fg.b);
+                let italics = style.font_style.contains(FontStyle::ITALIC);
+                let underline = style.font_style.contains(FontStyle::ITALIC);
+                let underline = if underline {
+                    egui::Stroke::new(1.0, text_color)
+                } else {
+                    egui::Stroke::NONE
+                };
+                job.sections.push(LayoutSection {
+                    leading_space: 0.0,
+                    byte_range: as_byte_range(text, range),
+                    format: TextFormat {
+                        font_id: egui::FontId::monospace(12.0),
+                        color: text_color,
+                        italics,
+                        underline,
+                        ..Default::default()
+                    },
+                });
+            }
+        }
+
+        Some(job)
+    }
+}
+
+#[cfg(feature = "syntect")]
+fn as_byte_range(whole: &str, range: &str) -> std::ops::Range<usize> {
+    let whole_start = whole.as_ptr() as usize;
+    let range_start = range.as_ptr() as usize;
+    assert!(whole_start <= range_start);
+    assert!(range_start + range.len() <= whole_start + whole.len());
+    let offset = range_start - whole_start;
+    offset..(offset + range.len())
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(not(feature = "syntect"))]
+#[derive(Default)]
+struct Highlighter {}
+
+#[cfg(not(feature = "syntect"))]
+impl Highlighter {
+    #[allow(clippy::unused_self, clippy::unnecessary_wraps)]
+    fn highlight(&self, theme: &CodeTheme, mut text: &str, _language: &str) -> LayoutJob {
+        // Extremely simple syntax highlighter for when we compile without syntect
+
+        let mut job = LayoutJob::default();
+
+        while !text.is_empty() {
+            if text.starts_with("//") {
+                let end = text.find('\n').unwrap_or(text.len());
+                job.append(&text[..end], 0.0, theme.formats[TokenType::Comment].clone());
+                text = &text[end..];
+            } else if text.starts_with('"') {
+                let end = text[1..]
+                    .find('"')
+                    .map(|i| i + 2)
+                    .or_else(|| text.find('\n'))
+                    .unwrap_or(text.len());
+                job.append(
+                    &text[..end],
+                    0.0,
+                    theme.formats[TokenType::StringLiteral].clone(),
+                );
+                text = &text[end..];
+            } else if text.starts_with(|c: char| c.is_ascii_alphanumeric()) {
+                let end = text[1..]
+                    .find(|c: char| !c.is_ascii_alphanumeric())
+                    .map_or_else(|| text.len(), |i| i + 1);
+                let word = &text[..end];
+                let tt = if is_keyword(word) {
+                    TokenType::Keyword
+                } else {
+                    TokenType::Literal
+                };
+                job.append(word, 0.0, theme.formats[tt].clone());
+                text = &text[end..];
+            } else if text.starts_with(|c: char| c.is_ascii_whitespace()) {
+                let end = text[1..]
+                    .find(|c: char| !c.is_ascii_whitespace())
+                    .map_or_else(|| text.len(), |i| i + 1);
+                job.append(
+                    &text[..end],
+                    0.0,
+                    theme.formats[TokenType::Whitespace].clone(),
+                );
+                text = &text[end..];
+            } else {
+                let mut it = text.char_indices();
+                it.next();
+                let end = it.next().map_or(text.len(), |(idx, _chr)| idx);
+                job.append(
+                    &text[..end],
+                    0.0,
+                    theme.formats[TokenType::Punctuation].clone(),
+                );
+                text = &text[end..];
+            }
+        }
+
+        job
+    }
+}
+
+#[cfg(not(feature = "syntect"))]
+fn is_keyword(word: &str) -> bool {
+    matches!(
+        word,
+        "as" | "async"
+            | "await"
+            | "break"
+            | "const"
+            | "continue"
+            | "crate"
+            | "dyn"
+            | "else"
+            | "enum"
+            | "extern"
+            | "false"
+            | "fn"
+            | "for"
+            | "if"
+            | "impl"
+            | "in"
+            | "let"
+            | "loop"
+            | "match"
+            | "mod"
+            | "move"
+            | "mut"
+            | "pub"
+            | "ref"
+            | "return"
+            | "self"
+            | "Self"
+            | "static"
+            | "struct"
+            | "super"
+            | "trait"
+            | "true"
+            | "type"
+            | "unsafe"
+            | "use"
+            | "where"
+            | "while"
+    )
+}
diff --git a/egui/crates/egui_extras/CHANGELOG.md b/egui/crates/egui_extras/CHANGELOG.md
new file mode 100644
index 0000000..1911ea7
--- /dev/null
+++ b/egui/crates/egui_extras/CHANGELOG.md
@@ -0,0 +1,44 @@
+# Changelog for egui_extras
+All notable changes to the `egui_extras` integration will be noted in this file.
+
+
+## Unreleased
+
+
+## 0.21.0 - 2023-02-08
+* Update to egui 0.21
+
+
+## 0.20.0 - 2022-12-08
+* Added `RetainedImage::from_svg_bytes_with_size` to be able to specify a size for SVGs to be rasterized at.
+* Lots of `Table` improvements ([#2369](https://github.com/emilk/egui/pull/2369)):
+    * Double-click column separators to auto-size the column.
+    * All `Table` now store state. You may see warnings about reused table ids. Use `ui.push_id` to fix this.
+    * `TableBuilder::column` takes a `Column` instead of a `Size`.
+    * `Column` controls default size, size range, resizing, and clipping of columns.
+    * `Column::auto` will pick a size automatically
+    * Added `Table::scroll_to_row`.
+    * Added `Table::min_scrolled_height` and `Table::max_scroll_height`.
+    * Added `TableBody::max_size`.
+    * `Table::scroll` renamed to `Table::vscroll`.
+    * `egui_extras::Strip` now has `clip: false` by default.
+    * Fix bugs when putting `Table` inside of a horizontal `ScrollArea`.
+    * Many other bug fixes.
+* Add `Table::auto_shrink` - set to `false` to expand table to fit its containing `Ui` ([#2371](https://github.com/emilk/egui/pull/2371)).
+* Added `TableBuilder::vertical_scroll_offset`: method to set vertical scroll offset position for a table ([#1946](https://github.com/emilk/egui/pull/1946)).
+
+
+## 0.19.0 - 2022-08-20
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* You can now specify a texture filter for `RetainedImage` ([#1636](https://github.com/emilk/egui/pull/1636)).
+* Fixed uneven `Table` striping ([#1680](https://github.com/emilk/egui/pull/1680)).
+
+
+## 0.18.0 - 2022-04-30
+* Added `Strip`, `Table` and `DatePicker` ([#963](https://github.com/emilk/egui/pull/963)).
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Renamed feature "persistence" to "serde" ([#1540](https://github.com/emilk/egui/pull/1540)).
+
+
+## 0.17.0 - 2022-02-22
+* `RetainedImage`: convenience for loading svg, png, jpeg etc and showing them in egui.
diff --git a/egui/crates/egui_extras/Cargo.toml b/egui/crates/egui_extras/Cargo.toml
new file mode 100644
index 0000000..6fb0fdf
--- /dev/null
+++ b/egui/crates/egui_extras/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+name = "egui_extras"
+version = "0.21.0"
+authors = [
+  "Dominik Rössler <dominik@freshx.de>",
+  "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
+  "René Rössler <rene@freshx.de>",
+]
+description = "Extra functionality and widgets for the egui GUI library"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui"
+categories = ["gui", "game-development"]
+keywords = ["gui", "imgui", "immediate", "portable", "gamedev"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = []
+
+## Enable [`DatePickerButton`] widget.
+datepicker = ["chrono"]
+
+## Support loading svg images.
+svg = ["resvg", "tiny-skia", "usvg"]
+
+## Log warnings using `tracing` crate.
+tracing = ["dep:tracing", "egui/tracing"]
+
+
+[dependencies]
+egui = { version = "0.21.0", path = "../egui", default-features = false }
+
+serde = { version = "1", features = ["derive"] }
+
+#! ### Optional dependencies
+
+# Date operations needed for datepicker widget
+chrono = { version = "0.4", optional = true }
+
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+## Add support for loading images with the [`image`](https://docs.rs/image) crate.
+##
+## You also need to ALSO opt-in to the image formats you want to support, like so:
+## ```toml
+## image = { version = "0.24", features = ["jpeg", "png"] }
+## ```
+image = { version = "0.24", optional = true, default-features = false }
+
+# svg feature
+resvg = { version = "0.28", optional = true, default-features = false }
+tiny-skia = { version = "0.8", optional = true, default-features = false } # must be updated in lock-step with resvg
+usvg = { version = "0.28", optional = true, default-features = false }
+
+# feature "tracing"
+tracing = { version = "0.1", optional = true, default-features = false, features = [
+  "std",
+] }
diff --git a/egui/crates/egui_extras/README.md b/egui/crates/egui_extras/README.md
new file mode 100644
index 0000000..d49a594
--- /dev/null
+++ b/egui/crates/egui_extras/README.md
@@ -0,0 +1,9 @@
+# egui_extras
+
+[![Latest version](https://img.shields.io/crates/v/egui_extras.svg)](https://crates.io/crates/egui_extras)
+[![Documentation](https://docs.rs/egui_extras/badge.svg)](https://docs.rs/egui_extras)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+This is a crate that adds some features on top top of [`egui`](https://github.com/emilk/egui). This crate is for experimental features, and features that require big dependencies that do not belong in `egui`.
diff --git a/egui/crates/egui_extras/src/datepicker/button.rs b/egui/crates/egui_extras/src/datepicker/button.rs
new file mode 100644
index 0000000..e8aafef
--- /dev/null
+++ b/egui/crates/egui_extras/src/datepicker/button.rs
@@ -0,0 +1,153 @@
+use super::popup::DatePickerPopup;
+use chrono::NaiveDate;
+use egui::{Area, Button, Frame, InnerResponse, Key, Order, RichText, Ui, Widget};
+
+#[derive(Default, Clone, serde::Deserialize, serde::Serialize)]
+pub(crate) struct DatePickerButtonState {
+    pub picker_visible: bool,
+}
+
+pub struct DatePickerButton<'a> {
+    selection: &'a mut NaiveDate,
+    id_source: Option<&'a str>,
+    combo_boxes: bool,
+    arrows: bool,
+    calendar: bool,
+    calendar_week: bool,
+    show_icon: bool,
+}
+
+impl<'a> DatePickerButton<'a> {
+    pub fn new(selection: &'a mut NaiveDate) -> Self {
+        Self {
+            selection,
+            id_source: None,
+            combo_boxes: true,
+            arrows: true,
+            calendar: true,
+            calendar_week: true,
+            show_icon: true,
+        }
+    }
+
+    /// Add id source.
+    /// Must be set if multiple date picker buttons are in the same Ui.
+    pub fn id_source(mut self, id_source: &'a str) -> Self {
+        self.id_source = Some(id_source);
+        self
+    }
+
+    /// Show combo boxes in date picker popup. (Default: true)
+    pub fn combo_boxes(mut self, combo_boxes: bool) -> Self {
+        self.combo_boxes = combo_boxes;
+        self
+    }
+
+    /// Show arrows in date picker popup. (Default: true)
+    pub fn arrows(mut self, arrows: bool) -> Self {
+        self.arrows = arrows;
+        self
+    }
+
+    /// Show calendar in date picker popup. (Default: true)
+    pub fn calendar(mut self, calendar: bool) -> Self {
+        self.calendar = calendar;
+        self
+    }
+
+    /// Show calendar week in date picker popup. (Default: true)
+    pub fn calendar_week(mut self, week: bool) -> Self {
+        self.calendar_week = week;
+        self
+    }
+
+    /// Show the calender icon on the button. (Default: true)
+    pub fn show_icon(mut self, show_icon: bool) -> Self {
+        self.show_icon = show_icon;
+        self
+    }
+}
+
+impl<'a> Widget for DatePickerButton<'a> {
+    fn ui(self, ui: &mut Ui) -> egui::Response {
+        let id = ui.make_persistent_id(self.id_source);
+        let mut button_state = ui
+            .memory_mut(|mem| mem.data.get_persisted::<DatePickerButtonState>(id))
+            .unwrap_or_default();
+
+        let mut text = if self.show_icon {
+            RichText::new(format!("{} 📆", self.selection.format("%Y-%m-%d")))
+        } else {
+            RichText::new(format!("{}", self.selection.format("%Y-%m-%d")))
+        };
+        let visuals = ui.visuals().widgets.open;
+        if button_state.picker_visible {
+            text = text.color(visuals.text_color());
+        }
+        let mut button = Button::new(text);
+        if button_state.picker_visible {
+            button = button.fill(visuals.weak_bg_fill).stroke(visuals.bg_stroke);
+        }
+        let mut button_response = ui.add(button);
+        if button_response.clicked() {
+            button_state.picker_visible = true;
+            ui.memory_mut(|mem| mem.data.insert_persisted(id, button_state.clone()));
+        }
+
+        if button_state.picker_visible {
+            let width = 333.0;
+            let mut pos = button_response.rect.left_bottom();
+            let width_with_padding = width
+                + ui.style().spacing.item_spacing.x
+                + ui.style().spacing.window_margin.left
+                + ui.style().spacing.window_margin.right;
+            if pos.x + width_with_padding > ui.clip_rect().right() {
+                pos.x = button_response.rect.right() - width_with_padding;
+            }
+
+            // Check to make sure the calendar never is displayed out of window
+            pos.x = pos.x.max(ui.style().spacing.window_margin.left);
+
+            //TODO(elwerene): Better positioning
+
+            let InnerResponse {
+                inner: saved,
+                response: area_response,
+            } = Area::new(ui.make_persistent_id(self.id_source))
+                .order(Order::Foreground)
+                .fixed_pos(pos)
+                .show(ui.ctx(), |ui| {
+                    let frame = Frame::popup(ui.style());
+                    frame
+                        .show(ui, |ui| {
+                            ui.set_min_width(width);
+                            ui.set_max_width(width);
+
+                            DatePickerPopup {
+                                selection: self.selection,
+                                button_id: id,
+                                combo_boxes: self.combo_boxes,
+                                arrows: self.arrows,
+                                calendar: self.calendar,
+                                calendar_week: self.calendar_week,
+                            }
+                            .draw(ui)
+                        })
+                        .inner
+                });
+
+            if saved {
+                button_response.mark_changed();
+            }
+
+            if !button_response.clicked()
+                && (ui.input(|i| i.key_pressed(Key::Escape)) || area_response.clicked_elsewhere())
+            {
+                button_state.picker_visible = false;
+                ui.memory_mut(|mem| mem.data.insert_persisted(id, button_state));
+            }
+        }
+
+        button_response
+    }
+}
diff --git a/egui/crates/egui_extras/src/datepicker/mod.rs b/egui/crates/egui_extras/src/datepicker/mod.rs
new file mode 100644
index 0000000..d1e10f1
--- /dev/null
+++ b/egui/crates/egui_extras/src/datepicker/mod.rs
@@ -0,0 +1,34 @@
+mod button;
+mod popup;
+
+pub use button::DatePickerButton;
+use chrono::{Datelike, Duration, NaiveDate, Weekday};
+
+#[derive(Debug)]
+struct Week {
+    number: u8,
+    days: Vec<NaiveDate>,
+}
+
+fn month_data(year: i32, month: u32) -> Vec<Week> {
+    let first = NaiveDate::from_ymd_opt(year, month, 1).expect("Could not create NaiveDate");
+    let mut start = first;
+    while start.weekday() != Weekday::Mon {
+        start = start.checked_sub_signed(Duration::days(1)).unwrap();
+    }
+    let mut weeks = vec![];
+    let mut week = vec![];
+    while start < first || start.month() == first.month() || start.weekday() != Weekday::Mon {
+        week.push(start);
+
+        if start.weekday() == Weekday::Sun {
+            weeks.push(Week {
+                number: start.iso_week().week() as u8,
+                days: week.drain(..).collect(),
+            });
+        }
+        start = start.checked_add_signed(Duration::days(1)).unwrap();
+    }
+
+    weeks
+}
diff --git a/egui/crates/egui_extras/src/datepicker/popup.rs b/egui/crates/egui_extras/src/datepicker/popup.rs
new file mode 100644
index 0000000..7da8cbc
--- /dev/null
+++ b/egui/crates/egui_extras/src/datepicker/popup.rs
@@ -0,0 +1,433 @@
+use chrono::{Datelike, NaiveDate, Weekday};
+
+use egui::{Align, Button, Color32, ComboBox, Direction, Id, Layout, RichText, Ui, Vec2};
+
+use super::{button::DatePickerButtonState, month_data};
+
+use crate::{Column, Size, StripBuilder, TableBuilder};
+
+#[derive(Default, Clone, serde::Deserialize, serde::Serialize)]
+struct DatePickerPopupState {
+    year: i32,
+    month: u32,
+    day: u32,
+    setup: bool,
+}
+
+impl DatePickerPopupState {
+    fn last_day_of_month(&self) -> u32 {
+        let date: NaiveDate =
+            NaiveDate::from_ymd_opt(self.year, self.month, 1).expect("Could not create NaiveDate");
+        date.with_day(31)
+            .map(|_| 31)
+            .or_else(|| date.with_day(30).map(|_| 30))
+            .or_else(|| date.with_day(29).map(|_| 29))
+            .unwrap_or(28)
+    }
+}
+
+pub(crate) struct DatePickerPopup<'a> {
+    pub selection: &'a mut NaiveDate,
+    pub button_id: Id,
+    pub combo_boxes: bool,
+    pub arrows: bool,
+    pub calendar: bool,
+    pub calendar_week: bool,
+}
+
+impl<'a> DatePickerPopup<'a> {
+    /// Returns `true` if user pressed `Save` button.
+    pub fn draw(&mut self, ui: &mut Ui) -> bool {
+        let id = ui.make_persistent_id("date_picker");
+        let today = chrono::offset::Utc::now().date_naive();
+        let mut popup_state = ui
+            .memory_mut(|mem| mem.data.get_persisted::<DatePickerPopupState>(id))
+            .unwrap_or_default();
+        if !popup_state.setup {
+            popup_state.year = self.selection.year();
+            popup_state.month = self.selection.month();
+            popup_state.day = self.selection.day();
+            popup_state.setup = true;
+            ui.memory_mut(|mem| mem.data.insert_persisted(id, popup_state.clone()));
+        }
+
+        let weeks = month_data(popup_state.year, popup_state.month);
+        let (mut close, mut saved) = (false, false);
+        let height = 20.0;
+        let spacing = 2.0;
+        ui.spacing_mut().item_spacing = Vec2::splat(spacing);
+        StripBuilder::new(ui)
+            .clip(false)
+            .sizes(
+                Size::exact(height),
+                match (self.combo_boxes, self.arrows) {
+                    (true, true) => 2,
+                    (true, false) | (false, true) => 1,
+                    (false, false) => 0,
+                },
+            )
+            .sizes(
+                Size::exact((spacing + height) * (weeks.len() + 1) as f32),
+                self.calendar as usize,
+            )
+            .size(Size::exact(height))
+            .vertical(|mut strip| {
+                if self.combo_boxes {
+                    strip.strip(|builder| {
+                        builder.sizes(Size::remainder(), 3).horizontal(|mut strip| {
+                            strip.cell(|ui| {
+                                ComboBox::from_id_source("date_picker_year")
+                                    .selected_text(popup_state.year.to_string())
+                                    .show_ui(ui, |ui| {
+                                        for year in today.year() - 5..today.year() + 10 {
+                                            if ui
+                                                .selectable_value(
+                                                    &mut popup_state.year,
+                                                    year,
+                                                    year.to_string(),
+                                                )
+                                                .changed()
+                                            {
+                                                popup_state.day = popup_state
+                                                    .day
+                                                    .min(popup_state.last_day_of_month());
+                                                ui.memory_mut(|mem| {
+                                                    mem.data
+                                                        .insert_persisted(id, popup_state.clone());
+                                                });
+                                            }
+                                        }
+                                    });
+                            });
+                            strip.cell(|ui| {
+                                ComboBox::from_id_source("date_picker_month")
+                                    .selected_text(month_name(popup_state.month))
+                                    .show_ui(ui, |ui| {
+                                        for month in 1..=12 {
+                                            if ui
+                                                .selectable_value(
+                                                    &mut popup_state.month,
+                                                    month,
+                                                    month_name(month),
+                                                )
+                                                .changed()
+                                            {
+                                                popup_state.day = popup_state
+                                                    .day
+                                                    .min(popup_state.last_day_of_month());
+                                                ui.memory_mut(|mem| {
+                                                    mem.data
+                                                        .insert_persisted(id, popup_state.clone());
+                                                });
+                                            }
+                                        }
+                                    });
+                            });
+                            strip.cell(|ui| {
+                                ComboBox::from_id_source("date_picker_day")
+                                    .selected_text(popup_state.day.to_string())
+                                    .show_ui(ui, |ui| {
+                                        for day in 1..=popup_state.last_day_of_month() {
+                                            if ui
+                                                .selectable_value(
+                                                    &mut popup_state.day,
+                                                    day,
+                                                    day.to_string(),
+                                                )
+                                                .changed()
+                                            {
+                                                ui.memory_mut(|mem| {
+                                                    mem.data
+                                                        .insert_persisted(id, popup_state.clone());
+                                                });
+                                            }
+                                        }
+                                    });
+                            });
+                        });
+                    });
+                }
+
+                if self.arrows {
+                    strip.strip(|builder| {
+                        builder.sizes(Size::remainder(), 6).horizontal(|mut strip| {
+                            strip.cell(|ui| {
+                                ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                    if ui
+                                        .button("<<<")
+                                        .on_hover_text("subtract one year")
+                                        .clicked()
+                                    {
+                                        popup_state.year -= 1;
+                                        popup_state.day =
+                                            popup_state.day.min(popup_state.last_day_of_month());
+                                        ui.memory_mut(|mem| {
+                                            mem.data.insert_persisted(id, popup_state.clone());
+                                        });
+                                    }
+                                });
+                            });
+                            strip.cell(|ui| {
+                                ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                    if ui
+                                        .button("<<")
+                                        .on_hover_text("subtract one month")
+                                        .clicked()
+                                    {
+                                        popup_state.month -= 1;
+                                        if popup_state.month == 0 {
+                                            popup_state.month = 12;
+                                            popup_state.year -= 1;
+                                        }
+                                        popup_state.day =
+                                            popup_state.day.min(popup_state.last_day_of_month());
+                                        ui.memory_mut(|mem| {
+                                            mem.data.insert_persisted(id, popup_state.clone());
+                                        });
+                                    }
+                                });
+                            });
+                            strip.cell(|ui| {
+                                ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                    if ui.button("<").on_hover_text("subtract one day").clicked() {
+                                        popup_state.day -= 1;
+                                        if popup_state.day == 0 {
+                                            popup_state.month -= 1;
+                                            if popup_state.month == 0 {
+                                                popup_state.year -= 1;
+                                                popup_state.month = 12;
+                                            }
+                                            popup_state.day = popup_state.last_day_of_month();
+                                        }
+                                        ui.memory_mut(|mem| {
+                                            mem.data.insert_persisted(id, popup_state.clone());
+                                        });
+                                    }
+                                });
+                            });
+                            strip.cell(|ui| {
+                                ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                    if ui.button(">").on_hover_text("add one day").clicked() {
+                                        popup_state.day += 1;
+                                        if popup_state.day > popup_state.last_day_of_month() {
+                                            popup_state.day = 1;
+                                            popup_state.month += 1;
+                                            if popup_state.month > 12 {
+                                                popup_state.month = 1;
+                                                popup_state.year += 1;
+                                            }
+                                        }
+                                        ui.memory_mut(|mem| {
+                                            mem.data.insert_persisted(id, popup_state.clone());
+                                        });
+                                    }
+                                });
+                            });
+                            strip.cell(|ui| {
+                                ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                    if ui.button(">>").on_hover_text("add one month").clicked() {
+                                        popup_state.month += 1;
+                                        if popup_state.month > 12 {
+                                            popup_state.month = 1;
+                                            popup_state.year += 1;
+                                        }
+                                        popup_state.day =
+                                            popup_state.day.min(popup_state.last_day_of_month());
+                                        ui.memory_mut(|mem| {
+                                            mem.data.insert_persisted(id, popup_state.clone());
+                                        });
+                                    }
+                                });
+                            });
+                            strip.cell(|ui| {
+                                ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                    if ui.button(">>>").on_hover_text("add one year").clicked() {
+                                        popup_state.year += 1;
+                                        popup_state.day =
+                                            popup_state.day.min(popup_state.last_day_of_month());
+                                        ui.memory_mut(|mem| {
+                                            mem.data.insert_persisted(id, popup_state.clone());
+                                        });
+                                    }
+                                });
+                            });
+                        });
+                    });
+                }
+
+                if self.calendar {
+                    strip.cell(|ui| {
+                        ui.spacing_mut().item_spacing = Vec2::new(1.0, 2.0);
+                        TableBuilder::new(ui)
+                            .vscroll(false)
+                            .columns(Column::remainder(), if self.calendar_week { 8 } else { 7 })
+                            .header(height, |mut header| {
+                                if self.calendar_week {
+                                    header.col(|ui| {
+                                        ui.with_layout(
+                                            Layout::centered_and_justified(Direction::TopDown),
+                                            |ui| {
+                                                ui.label("Week");
+                                            },
+                                        );
+                                    });
+                                }
+
+                                //TODO(elwerene): Locale
+                                for name in ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"] {
+                                    header.col(|ui| {
+                                        ui.with_layout(
+                                            Layout::centered_and_justified(Direction::TopDown),
+                                            |ui| {
+                                                ui.label(name);
+                                            },
+                                        );
+                                    });
+                                }
+                            })
+                            .body(|mut body| {
+                                for week in weeks {
+                                    body.row(height, |mut row| {
+                                        if self.calendar_week {
+                                            row.col(|ui| {
+                                                ui.label(week.number.to_string());
+                                            });
+                                        }
+                                        for day in week.days {
+                                            row.col(|ui| {
+                                                ui.with_layout(
+                                                    Layout::top_down_justified(Align::Center),
+                                                    |ui| {
+                                                        let fill_color = if popup_state.year
+                                                            == day.year()
+                                                            && popup_state.month == day.month()
+                                                            && popup_state.day == day.day()
+                                                        {
+                                                            ui.visuals().selection.bg_fill
+                                                        } else if day.weekday() == Weekday::Sat
+                                                            || day.weekday() == Weekday::Sun
+                                                        {
+                                                            if ui.visuals().dark_mode {
+                                                                Color32::DARK_RED
+                                                            } else {
+                                                                Color32::LIGHT_RED
+                                                            }
+                                                        } else {
+                                                            ui.visuals().extreme_bg_color
+                                                        };
+
+                                                        let mut text_color = ui
+                                                            .visuals()
+                                                            .widgets
+                                                            .inactive
+                                                            .text_color();
+
+                                                        if day.month() != popup_state.month {
+                                                            text_color =
+                                                                text_color.linear_multiply(0.5);
+                                                        };
+
+                                                        let button_response = ui.add(
+                                                            Button::new(
+                                                                RichText::new(
+                                                                    day.day().to_string(),
+                                                                )
+                                                                .color(text_color),
+                                                            )
+                                                            .fill(fill_color),
+                                                        );
+
+                                                        if day == today {
+                                                            // Encircle today's date
+                                                            let stroke = ui
+                                                                .visuals()
+                                                                .widgets
+                                                                .inactive
+                                                                .fg_stroke;
+                                                            ui.painter().circle_stroke(
+                                                                button_response.rect.center(),
+                                                                8.0,
+                                                                stroke,
+                                                            );
+                                                        }
+
+                                                        if button_response.clicked() {
+                                                            popup_state.year = day.year();
+                                                            popup_state.month = day.month();
+                                                            popup_state.day = day.day();
+                                                            ui.memory_mut(|mem| {
+                                                                mem.data.insert_persisted(
+                                                                    id,
+                                                                    popup_state.clone(),
+                                                                );
+                                                            });
+                                                        }
+                                                    },
+                                                );
+                                            });
+                                        }
+                                    });
+                                }
+                            });
+                    });
+                }
+
+                strip.strip(|builder| {
+                    builder.sizes(Size::remainder(), 3).horizontal(|mut strip| {
+                        strip.empty();
+                        strip.cell(|ui| {
+                            ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                if ui.button("Cancel").clicked() {
+                                    close = true;
+                                }
+                            });
+                        });
+                        strip.cell(|ui| {
+                            ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
+                                if ui.button("Save").clicked() {
+                                    *self.selection = NaiveDate::from_ymd_opt(
+                                        popup_state.year,
+                                        popup_state.month,
+                                        popup_state.day,
+                                    )
+                                    .expect("Could not create NaiveDate");
+                                    saved = true;
+                                    close = true;
+                                }
+                            });
+                        });
+                    });
+                });
+            });
+
+        if close {
+            popup_state.setup = false;
+            ui.memory_mut(|mem| {
+                mem.data.insert_persisted(id, popup_state);
+                mem.data
+                    .get_persisted_mut_or_default::<DatePickerButtonState>(self.button_id)
+                    .picker_visible = false;
+            });
+        }
+
+        saved && close
+    }
+}
+
+fn month_name(i: u32) -> &'static str {
+    match i {
+        1 => "January",
+        2 => "February",
+        3 => "March",
+        4 => "April",
+        5 => "May",
+        6 => "June",
+        7 => "July",
+        8 => "August",
+        9 => "September",
+        10 => "October",
+        11 => "November",
+        12 => "December",
+        _ => panic!("Unknown month: {}", i),
+    }
+}
diff --git a/egui/crates/egui_extras/src/image.rs b/egui/crates/egui_extras/src/image.rs
new file mode 100644
index 0000000..3526b6d
--- /dev/null
+++ b/egui/crates/egui_extras/src/image.rs
@@ -0,0 +1,265 @@
+use egui::{mutex::Mutex, TextureFilter, TextureOptions};
+
+#[cfg(feature = "svg")]
+pub use usvg::FitTo;
+
+/// An image to be shown in egui.
+///
+/// Load once, and save somewhere in your app state.
+///
+/// Use the `svg` and `image` features to enable more constructors.
+pub struct RetainedImage {
+    debug_name: String,
+    size: [usize; 2],
+    /// Cleared once [`Self::texture`] has been loaded.
+    image: Mutex<egui::ColorImage>,
+    /// Lazily loaded when we have an egui context.
+    texture: Mutex<Option<egui::TextureHandle>>,
+    options: TextureOptions,
+}
+
+impl RetainedImage {
+    pub fn from_color_image(debug_name: impl Into<String>, image: ColorImage) -> Self {
+        Self {
+            debug_name: debug_name.into(),
+            size: image.size,
+            image: Mutex::new(image),
+            texture: Default::default(),
+            options: Default::default(),
+        }
+    }
+
+    /// Load a (non-svg) image.
+    ///
+    /// `image_bytes` should be the raw contents of an image file (`.png`, `.jpg`, …).
+    ///
+    /// Requires the "image" feature. You must also opt-in to the image formats you need
+    /// with e.g. `image = { version = "0.24", features = ["jpeg", "png"] }`.
+    ///
+    /// # Errors
+    /// On invalid image or unsupported image format.
+    #[cfg(feature = "image")]
+    pub fn from_image_bytes(
+        debug_name: impl Into<String>,
+        image_bytes: &[u8],
+    ) -> Result<Self, String> {
+        Ok(Self::from_color_image(
+            debug_name,
+            load_image_bytes(image_bytes)?,
+        ))
+    }
+
+    /// Pass in the bytes of an SVG that you've loaded.
+    ///
+    /// # Errors
+    /// On invalid image
+    #[cfg(feature = "svg")]
+    pub fn from_svg_bytes(debug_name: impl Into<String>, svg_bytes: &[u8]) -> Result<Self, String> {
+        Self::from_svg_bytes_with_size(debug_name, svg_bytes, FitTo::Original)
+    }
+
+    /// Pass in the str of an SVG that you've loaded.
+    ///
+    /// # Errors
+    /// On invalid image
+    #[cfg(feature = "svg")]
+    pub fn from_svg_str(debug_name: impl Into<String>, svg_str: &str) -> Result<Self, String> {
+        Self::from_svg_bytes(debug_name, svg_str.as_bytes())
+    }
+
+    /// Pass in the bytes of an SVG that you've loaded
+    /// and the scaling option to resize the SVG with
+    ///
+    /// # Errors
+    /// On invalid image
+    #[cfg(feature = "svg")]
+    pub fn from_svg_bytes_with_size(
+        debug_name: impl Into<String>,
+        svg_bytes: &[u8],
+        size: FitTo,
+    ) -> Result<Self, String> {
+        Ok(Self::from_color_image(
+            debug_name,
+            load_svg_bytes_with_size(svg_bytes, size)?,
+        ))
+    }
+
+    /// Set the texture filters to use for the image.
+    ///
+    /// **Note:** If the texture has already been uploaded to the GPU, this will require
+    /// re-uploading the texture with the updated filter.
+    ///
+    /// # Example
+    /// ```rust
+    /// # use egui_extras::RetainedImage;
+    /// # use egui::{Color32, epaint::{ColorImage, textures::TextureOptions}};
+    /// # let pixels = vec![Color32::BLACK];
+    /// # let color_image = ColorImage {
+    /// #   size: [1, 1],
+    /// #   pixels,
+    /// # };
+    /// #
+    /// // Upload a pixel art image without it getting blurry when resized
+    /// let image = RetainedImage::from_color_image("my_image", color_image)
+    ///     .with_options(TextureOptions::NEAREST);
+    /// ```
+    pub fn with_options(mut self, options: TextureOptions) -> Self {
+        self.options = options;
+
+        // If the texture has already been uploaded, this will force it to be re-uploaded with the
+        // updated filter.
+        *self.texture.lock() = None;
+
+        self
+    }
+
+    #[deprecated = "Use with_options instead"]
+    pub fn with_texture_filter(self, filter: TextureFilter) -> Self {
+        self.with_options(TextureOptions {
+            magnification: filter,
+            minification: filter,
+        })
+    }
+
+    /// The size of the image data (number of pixels wide/high).
+    pub fn size(&self) -> [usize; 2] {
+        self.size
+    }
+
+    /// The width of the image.
+    pub fn width(&self) -> usize {
+        self.size[0]
+    }
+
+    /// The height of the image.
+    pub fn height(&self) -> usize {
+        self.size[1]
+    }
+
+    /// The size of the image data (number of pixels wide/high).
+    pub fn size_vec2(&self) -> egui::Vec2 {
+        let [w, h] = self.size();
+        egui::vec2(w as f32, h as f32)
+    }
+
+    /// The debug name of the image, e.g. the file name.
+    pub fn debug_name(&self) -> &str {
+        &self.debug_name
+    }
+
+    /// The texture if for this image.
+    pub fn texture_id(&self, ctx: &egui::Context) -> egui::TextureId {
+        self.texture
+            .lock()
+            .get_or_insert_with(|| {
+                let image: &mut ColorImage = &mut self.image.lock();
+                let image = std::mem::take(image);
+                ctx.load_texture(&self.debug_name, image, self.options)
+            })
+            .id()
+    }
+
+    /// Show the image with the given maximum size.
+    pub fn show_max_size(&self, ui: &mut egui::Ui, max_size: egui::Vec2) -> egui::Response {
+        let mut desired_size = self.size_vec2();
+        desired_size *= (max_size.x / desired_size.x).min(1.0);
+        desired_size *= (max_size.y / desired_size.y).min(1.0);
+        self.show_size(ui, desired_size)
+    }
+
+    /// Show the image with the original size (one image pixel = one gui point).
+    pub fn show(&self, ui: &mut egui::Ui) -> egui::Response {
+        self.show_size(ui, self.size_vec2())
+    }
+
+    /// Show the image with the given scale factor (1.0 = original size).
+    pub fn show_scaled(&self, ui: &mut egui::Ui, scale: f32) -> egui::Response {
+        self.show_size(ui, self.size_vec2() * scale)
+    }
+
+    /// Show the image with the given size.
+    pub fn show_size(&self, ui: &mut egui::Ui, desired_size: egui::Vec2) -> egui::Response {
+        // We need to convert the SVG to a texture to display it:
+        // Future improvement: tell backend to do mip-mapping of the image to
+        // make it look smoother when downsized.
+        ui.image(self.texture_id(ui.ctx()), desired_size)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+use egui::ColorImage;
+
+/// Load a (non-svg) image.
+///
+/// Requires the "image" feature. You must also opt-in to the image formats you need
+/// with e.g. `image = { version = "0.24", features = ["jpeg", "png"] }`.
+///
+/// # Errors
+/// On invalid image or unsupported image format.
+#[cfg(feature = "image")]
+pub fn load_image_bytes(image_bytes: &[u8]) -> Result<egui::ColorImage, String> {
+    let image = image::load_from_memory(image_bytes).map_err(|err| err.to_string())?;
+    let size = [image.width() as _, image.height() as _];
+    let image_buffer = image.to_rgba8();
+    let pixels = image_buffer.as_flat_samples();
+    Ok(egui::ColorImage::from_rgba_unmultiplied(
+        size,
+        pixels.as_slice(),
+    ))
+}
+
+/// Load an SVG and rasterize it into an egui image.
+///
+/// Requires the "svg" feature.
+///
+/// # Errors
+/// On invalid image
+#[cfg(feature = "svg")]
+pub fn load_svg_bytes(svg_bytes: &[u8]) -> Result<egui::ColorImage, String> {
+    load_svg_bytes_with_size(svg_bytes, FitTo::Original)
+}
+
+/// Load an SVG and rasterize it into an egui image with a scaling parameter.
+///
+/// Requires the "svg" feature.
+///
+/// # Errors
+/// On invalid image
+#[cfg(feature = "svg")]
+pub fn load_svg_bytes_with_size(
+    svg_bytes: &[u8],
+    fit_to: FitTo,
+) -> Result<egui::ColorImage, String> {
+    let opt = usvg::Options::default();
+
+    let rtree = usvg::Tree::from_data(svg_bytes, &opt).map_err(|err| err.to_string())?;
+
+    let pixmap_size = rtree.size.to_screen_size();
+    let [w, h] = match fit_to {
+        FitTo::Original => [pixmap_size.width(), pixmap_size.height()],
+        FitTo::Size(w, h) => [w, h],
+        FitTo::Height(h) => [
+            (pixmap_size.width() as f32 * (h as f32 / pixmap_size.height() as f32)) as u32,
+            h,
+        ],
+        FitTo::Width(w) => [
+            w,
+            (pixmap_size.height() as f32 * (w as f32 / pixmap_size.width() as f32)) as u32,
+        ],
+        FitTo::Zoom(z) => [
+            (pixmap_size.width() as f32 * z) as u32,
+            (pixmap_size.height() as f32 * z) as u32,
+        ],
+    };
+
+    let mut pixmap = tiny_skia::Pixmap::new(w, h)
+        .ok_or_else(|| format!("Failed to create SVG Pixmap of size {}x{}", w, h))?;
+
+    resvg::render(&rtree, fit_to, Default::default(), pixmap.as_mut())
+        .ok_or_else(|| "Failed to render SVG".to_owned())?;
+
+    let image = egui::ColorImage::from_rgba_unmultiplied([w as _, h as _], pixmap.data());
+
+    Ok(image)
+}
diff --git a/egui/crates/egui_extras/src/layout.rs b/egui/crates/egui_extras/src/layout.rs
new file mode 100644
index 0000000..932594b
--- /dev/null
+++ b/egui/crates/egui_extras/src/layout.rs
@@ -0,0 +1,171 @@
+use egui::{Pos2, Rect, Response, Sense, Ui};
+
+#[derive(Clone, Copy)]
+pub(crate) enum CellSize {
+    /// Absolute size in points
+    Absolute(f32),
+
+    /// Take all available space
+    Remainder,
+}
+
+/// Cells are positioned in two dimensions, cells go in one direction and form lines.
+///
+/// In a strip there's only one line which goes in the direction of the strip:
+///
+/// In a horizontal strip, a [`StripLayout`] with horizontal [`CellDirection`] is used.
+/// Its cells go from left to right inside this [`StripLayout`].
+///
+/// In a table there's a [`StripLayout`] for each table row with a horizontal [`CellDirection`].
+/// Its cells go from left to right. And the lines go from top to bottom.
+pub(crate) enum CellDirection {
+    /// Cells go from left to right.
+    Horizontal,
+
+    /// Cells go from top to bottom.
+    Vertical,
+}
+
+/// Positions cells in [`CellDirection`] and starts a new line on [`StripLayout::end_line`]
+pub struct StripLayout<'l> {
+    pub(crate) ui: &'l mut Ui,
+    direction: CellDirection,
+    pub(crate) rect: Rect,
+    pub(crate) cursor: Pos2,
+    /// Keeps track of the max used position,
+    /// so we know how much space we used.
+    max: Pos2,
+    cell_layout: egui::Layout,
+}
+
+impl<'l> StripLayout<'l> {
+    pub(crate) fn new(ui: &'l mut Ui, direction: CellDirection, cell_layout: egui::Layout) -> Self {
+        let rect = ui.available_rect_before_wrap();
+        let pos = rect.left_top();
+
+        Self {
+            ui,
+            direction,
+            rect,
+            cursor: pos,
+            max: pos,
+            cell_layout,
+        }
+    }
+
+    fn cell_rect(&self, width: &CellSize, height: &CellSize) -> Rect {
+        Rect {
+            min: self.cursor,
+            max: Pos2 {
+                x: match width {
+                    CellSize::Absolute(width) => self.cursor.x + width,
+                    CellSize::Remainder => self.rect.right(),
+                },
+                y: match height {
+                    CellSize::Absolute(height) => self.cursor.y + height,
+                    CellSize::Remainder => self.rect.bottom(),
+                },
+            },
+        }
+    }
+
+    fn set_pos(&mut self, rect: Rect) {
+        self.max.x = self.max.x.max(rect.right());
+        self.max.y = self.max.y.max(rect.bottom());
+
+        match self.direction {
+            CellDirection::Horizontal => {
+                self.cursor.x = rect.right() + self.ui.spacing().item_spacing.x;
+            }
+            CellDirection::Vertical => {
+                self.cursor.y = rect.bottom() + self.ui.spacing().item_spacing.y;
+            }
+        }
+    }
+
+    pub(crate) fn empty(&mut self, width: CellSize, height: CellSize) {
+        self.set_pos(self.cell_rect(&width, &height));
+    }
+
+    /// This is the innermost part of [`crate::Table`] and [`crate::Strip`].
+    ///
+    /// Return the used space (`min_rect`) plus the [`Response`] of the whole cell.
+    pub(crate) fn add(
+        &mut self,
+        clip: bool,
+        striped: bool,
+        width: CellSize,
+        height: CellSize,
+        add_cell_contents: impl FnOnce(&mut Ui),
+    ) -> (Rect, Response) {
+        let max_rect = self.cell_rect(&width, &height);
+
+        if striped {
+            // Make sure we don't have a gap in the stripe background:
+            let stripe_rect = max_rect.expand2(0.5 * self.ui.spacing().item_spacing);
+
+            self.ui
+                .painter()
+                .rect_filled(stripe_rect, 0.0, self.ui.visuals().faint_bg_color);
+        }
+
+        let used_rect = self.cell(clip, max_rect, add_cell_contents);
+
+        self.set_pos(max_rect);
+
+        let allocation_rect = if clip {
+            max_rect
+        } else {
+            max_rect.union(used_rect)
+        };
+
+        let response = self.ui.allocate_rect(allocation_rect, Sense::hover());
+
+        (used_rect, response)
+    }
+
+    /// only needed for layouts with multiple lines, like [`Table`](crate::Table).
+    pub fn end_line(&mut self) {
+        match self.direction {
+            CellDirection::Horizontal => {
+                self.cursor.y = self.max.y + self.ui.spacing().item_spacing.y;
+                self.cursor.x = self.rect.left();
+            }
+            CellDirection::Vertical => {
+                self.cursor.x = self.max.x + self.ui.spacing().item_spacing.x;
+                self.cursor.y = self.rect.top();
+            }
+        }
+    }
+
+    /// Skip a lot of space.
+    pub(crate) fn skip_space(&mut self, delta: egui::Vec2) {
+        let before = self.cursor;
+        self.cursor += delta;
+        let rect = Rect::from_two_pos(before, self.cursor);
+        self.ui.allocate_rect(rect, Sense::hover());
+    }
+
+    fn cell(&mut self, clip: bool, rect: Rect, add_cell_contents: impl FnOnce(&mut Ui)) -> Rect {
+        let mut child_ui = self.ui.child_ui(rect, self.cell_layout);
+
+        if clip {
+            let margin = egui::Vec2::splat(self.ui.visuals().clip_rect_margin);
+            let margin = margin.min(0.5 * self.ui.spacing().item_spacing);
+            let clip_rect = rect.expand2(margin);
+            child_ui.set_clip_rect(clip_rect.intersect(child_ui.clip_rect()));
+        }
+
+        add_cell_contents(&mut child_ui);
+        child_ui.min_rect()
+    }
+
+    /// Allocate the rect in [`Self::ui`] so that the scrollview knows about our size
+    pub fn allocate_rect(&mut self) -> Response {
+        let mut rect = self.rect;
+        rect.set_right(self.max.x);
+        rect.set_bottom(self.max.y);
+
+        self.ui.allocate_rect(rect, Sense::hover())
+    }
+}
diff --git a/egui/crates/egui_extras/src/lib.rs b/egui/crates/egui_extras/src/lib.rs
new file mode 100644
index 0000000..c071d70
--- /dev/null
+++ b/egui/crates/egui_extras/src/lib.rs
@@ -0,0 +1,55 @@
+//! This is a crate that adds some features on top top of [`egui`](https://github.com/emilk/egui).
+//!
+//! This crate are for experimental features, and features that require big dependencies that does not belong in `egui`.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![allow(clippy::manual_range_contains)]
+#![forbid(unsafe_code)]
+
+#[cfg(feature = "chrono")]
+mod datepicker;
+
+pub mod image;
+mod layout;
+mod sizing;
+mod strip;
+mod table;
+
+#[cfg(feature = "chrono")]
+pub use crate::datepicker::DatePickerButton;
+
+pub use crate::image::RetainedImage;
+pub(crate) use crate::layout::StripLayout;
+pub use crate::sizing::Size;
+pub use crate::strip::*;
+pub use crate::table::*;
+
+/// Log an error with either `tracing` or `eprintln`
+macro_rules! log_err {
+    ($fmt: literal, $($arg: tt)*) => {{
+        #[cfg(feature = "tracing")]
+        tracing::error!($fmt, $($arg)*);
+
+        #[cfg(not(feature = "tracing"))]
+        eprintln!(
+            concat!("egui_extras: ", $fmt), $($arg)*
+        );
+    }};
+}
+pub(crate) use log_err;
+
+/// Panic in debug builds, log otherwise.
+macro_rules! log_or_panic {
+    ($fmt: literal, $($arg: tt)*) => {{
+        if cfg!(debug_assertions) {
+            panic!($fmt, $($arg)*);
+        } else {
+            $crate::log_err!($fmt, $($arg)*);
+        }
+    }};
+}
+pub(crate) use log_or_panic;
diff --git a/egui/crates/egui_extras/src/sizing.rs b/egui/crates/egui_extras/src/sizing.rs
new file mode 100644
index 0000000..8a58302
--- /dev/null
+++ b/egui/crates/egui_extras/src/sizing.rs
@@ -0,0 +1,177 @@
+/// Size hint for table column/strip cell.
+#[derive(Clone, Debug, Copy)]
+pub enum Size {
+    /// Absolute size in points, with a given range of allowed sizes to resize within.
+    Absolute { initial: f32, range: (f32, f32) },
+
+    /// Relative size relative to all available space.
+    Relative { fraction: f32, range: (f32, f32) },
+
+    /// Multiple remainders each get the same space.
+    Remainder { range: (f32, f32) },
+}
+
+impl Size {
+    /// Exactly this big, with no room for resize.
+    pub fn exact(points: f32) -> Self {
+        Self::Absolute {
+            initial: points,
+            range: (points, points),
+        }
+    }
+
+    /// Initially this big, but can resize.
+    pub fn initial(points: f32) -> Self {
+        Self::Absolute {
+            initial: points,
+            range: (0.0, f32::INFINITY),
+        }
+    }
+
+    /// Relative size relative to all available space. Values must be in range `0.0..=1.0`.
+    pub fn relative(fraction: f32) -> Self {
+        egui::egui_assert!(0.0 <= fraction && fraction <= 1.0);
+        Self::Relative {
+            fraction,
+            range: (0.0, f32::INFINITY),
+        }
+    }
+
+    /// Multiple remainders each get the same space.
+    pub fn remainder() -> Self {
+        Self::Remainder {
+            range: (0.0, f32::INFINITY),
+        }
+    }
+
+    /// Won't shrink below this size (in points).
+    pub fn at_least(mut self, minimum: f32) -> Self {
+        match &mut self {
+            Self::Absolute { range, .. }
+            | Self::Relative { range, .. }
+            | Self::Remainder { range, .. } => {
+                range.0 = minimum;
+            }
+        }
+        self
+    }
+
+    /// Won't grow above this size (in points).
+    pub fn at_most(mut self, maximum: f32) -> Self {
+        match &mut self {
+            Self::Absolute { range, .. }
+            | Self::Relative { range, .. }
+            | Self::Remainder { range, .. } => {
+                range.1 = maximum;
+            }
+        }
+        self
+    }
+
+    /// Allowed range of movement (in points), if in a resizable [`Table`](crate::table::Table).
+    pub fn range(self) -> (f32, f32) {
+        match self {
+            Self::Absolute { range, .. }
+            | Self::Relative { range, .. }
+            | Self::Remainder { range, .. } => range,
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct Sizing {
+    pub(crate) sizes: Vec<Size>,
+}
+
+impl Sizing {
+    pub fn add(&mut self, size: Size) {
+        self.sizes.push(size);
+    }
+
+    pub fn to_lengths(&self, length: f32, spacing: f32) -> Vec<f32> {
+        if self.sizes.is_empty() {
+            return vec![];
+        }
+
+        let mut remainders = 0;
+        let sum_non_remainder = self
+            .sizes
+            .iter()
+            .map(|&size| match size {
+                Size::Absolute { initial, .. } => initial,
+                Size::Relative {
+                    fraction,
+                    range: (min, max),
+                } => {
+                    assert!(0.0 <= fraction && fraction <= 1.0);
+                    (length * fraction).clamp(min, max)
+                }
+                Size::Remainder { .. } => {
+                    remainders += 1;
+                    0.0
+                }
+            })
+            .sum::<f32>()
+            + spacing * (self.sizes.len() - 1) as f32;
+
+        let avg_remainder_length = if remainders == 0 {
+            0.0
+        } else {
+            let mut remainder_length = length - sum_non_remainder;
+            let avg_remainder_length = 0.0f32.max(remainder_length / remainders as f32).floor();
+            self.sizes.iter().for_each(|&size| {
+                if let Size::Remainder { range: (min, _max) } = size {
+                    if avg_remainder_length < min {
+                        remainder_length -= min;
+                        remainders -= 1;
+                    }
+                }
+            });
+            if remainders > 0 {
+                0.0f32.max(remainder_length / remainders as f32)
+            } else {
+                0.0
+            }
+        };
+
+        self.sizes
+            .iter()
+            .map(|&size| match size {
+                Size::Absolute { initial, .. } => initial,
+                Size::Relative {
+                    fraction,
+                    range: (min, max),
+                } => (length * fraction).clamp(min, max),
+                Size::Remainder { range: (min, max) } => avg_remainder_length.clamp(min, max),
+            })
+            .collect()
+    }
+}
+
+impl From<Vec<Size>> for Sizing {
+    fn from(sizes: Vec<Size>) -> Self {
+        Self { sizes }
+    }
+}
+
+#[test]
+fn test_sizing() {
+    let sizing: Sizing = vec![].into();
+    assert_eq!(sizing.to_lengths(50.0, 0.0), vec![]);
+
+    let sizing: Sizing = vec![Size::remainder().at_least(20.0), Size::remainder()].into();
+    assert_eq!(sizing.to_lengths(50.0, 0.0), vec![25.0, 25.0]);
+    assert_eq!(sizing.to_lengths(30.0, 0.0), vec![20.0, 10.0]);
+    assert_eq!(sizing.to_lengths(20.0, 0.0), vec![20.0, 0.0]);
+    assert_eq!(sizing.to_lengths(10.0, 0.0), vec![20.0, 0.0]);
+    assert_eq!(sizing.to_lengths(20.0, 10.0), vec![20.0, 0.0]);
+    assert_eq!(sizing.to_lengths(30.0, 10.0), vec![20.0, 0.0]);
+    assert_eq!(sizing.to_lengths(40.0, 10.0), vec![20.0, 10.0]);
+    assert_eq!(sizing.to_lengths(110.0, 10.0), vec![50.0, 50.0]);
+
+    let sizing: Sizing = vec![Size::relative(0.5).at_least(10.0), Size::exact(10.0)].into();
+    assert_eq!(sizing.to_lengths(50.0, 0.0), vec![25.0, 10.0]);
+    assert_eq!(sizing.to_lengths(30.0, 0.0), vec![15.0, 10.0]);
+    assert_eq!(sizing.to_lengths(20.0, 0.0), vec![10.0, 10.0]);
+    assert_eq!(sizing.to_lengths(10.0, 0.0), vec![10.0, 10.0]);
+}
diff --git a/egui/crates/egui_extras/src/strip.rs b/egui/crates/egui_extras/src/strip.rs
new file mode 100644
index 0000000..52a768f
--- /dev/null
+++ b/egui/crates/egui_extras/src/strip.rs
@@ -0,0 +1,197 @@
+use crate::{
+    layout::{CellDirection, CellSize, StripLayout},
+    sizing::Sizing,
+    Size,
+};
+use egui::{Response, Ui};
+
+/// Builder for creating a new [`Strip`].
+///
+/// This can be used to do dynamic layouts.
+///
+/// In contrast to normal egui behavior, strip cells do *not* grow with its children!
+///
+/// First use [`Self::size`] and [`Self::sizes`] to allocate space for the rows or columns will follow.
+/// Then build the strip with [`Self::horizontal`]/[`Self::vertical`], and add 'cells'
+/// to it using [`Strip::cell`]. The number of cells MUST match the number of pre-allocated sizes.
+///
+/// ### Example
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// use egui_extras::{StripBuilder, Size};
+/// StripBuilder::new(ui)
+///     .size(Size::remainder().at_least(100.0)) // top cell
+///     .size(Size::exact(40.0)) // bottom cell
+///     .vertical(|mut strip| {
+///         // Add the top 'cell'
+///         strip.cell(|ui| {
+///             ui.label("Fixed");
+///         });
+///         // We add a nested strip in the bottom cell:
+///         strip.strip(|builder| {
+///             builder.sizes(Size::remainder(), 2).horizontal(|mut strip| {
+///                 strip.cell(|ui| {
+///                     ui.label("Top Left");
+///                 });
+///                 strip.cell(|ui| {
+///                     ui.label("Top Right");
+///                 });
+///             });
+///         });
+///     });
+/// # });
+/// ```
+pub struct StripBuilder<'a> {
+    ui: &'a mut Ui,
+    sizing: Sizing,
+    clip: bool,
+    cell_layout: egui::Layout,
+}
+
+impl<'a> StripBuilder<'a> {
+    /// Create new strip builder.
+    pub fn new(ui: &'a mut Ui) -> Self {
+        let cell_layout = *ui.layout();
+        Self {
+            ui,
+            sizing: Default::default(),
+            cell_layout,
+            clip: false,
+        }
+    }
+
+    /// Should we clip the contents of each cell? Default: `false`.
+    pub fn clip(mut self, clip: bool) -> Self {
+        self.clip = clip;
+        self
+    }
+
+    /// What layout should we use for the individual cells?
+    pub fn cell_layout(mut self, cell_layout: egui::Layout) -> Self {
+        self.cell_layout = cell_layout;
+        self
+    }
+
+    /// Allocate space for for one column/row.
+    pub fn size(mut self, size: Size) -> Self {
+        self.sizing.add(size);
+        self
+    }
+
+    /// Allocate space for for several columns/rows at once.
+    pub fn sizes(mut self, size: Size, count: usize) -> Self {
+        for _ in 0..count {
+            self.sizing.add(size);
+        }
+        self
+    }
+
+    /// Build horizontal strip: Cells are positions from left to right.
+    /// Takes the available horizontal width, so there can't be anything right of the strip or the container will grow slowly!
+    ///
+    /// Returns a [`egui::Response`] for hover events.
+    pub fn horizontal<F>(self, strip: F) -> Response
+    where
+        F: for<'b> FnOnce(Strip<'a, 'b>),
+    {
+        let widths = self.sizing.to_lengths(
+            self.ui.available_rect_before_wrap().width(),
+            self.ui.spacing().item_spacing.x,
+        );
+        let mut layout = StripLayout::new(self.ui, CellDirection::Horizontal, self.cell_layout);
+        strip(Strip {
+            layout: &mut layout,
+            direction: CellDirection::Horizontal,
+            clip: self.clip,
+            sizes: widths,
+            size_index: 0,
+        });
+        layout.allocate_rect()
+    }
+
+    /// Build vertical strip: Cells are positions from top to bottom.
+    /// Takes the full available vertical height, so there can't be anything below of the strip or the container will grow slowly!
+    ///
+    /// Returns a [`egui::Response`] for hover events.
+    pub fn vertical<F>(self, strip: F) -> Response
+    where
+        F: for<'b> FnOnce(Strip<'a, 'b>),
+    {
+        let heights = self.sizing.to_lengths(
+            self.ui.available_rect_before_wrap().height(),
+            self.ui.spacing().item_spacing.y,
+        );
+        let mut layout = StripLayout::new(self.ui, CellDirection::Vertical, self.cell_layout);
+        strip(Strip {
+            layout: &mut layout,
+            direction: CellDirection::Vertical,
+            clip: self.clip,
+            sizes: heights,
+            size_index: 0,
+        });
+        layout.allocate_rect()
+    }
+}
+
+/// A Strip of cells which go in one direction. Each cell has a fixed size.
+/// In contrast to normal egui behavior, strip cells do *not* grow with its children!
+pub struct Strip<'a, 'b> {
+    layout: &'b mut StripLayout<'a>,
+    direction: CellDirection,
+    clip: bool,
+    sizes: Vec<f32>,
+    size_index: usize,
+}
+
+impl<'a, 'b> Strip<'a, 'b> {
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn next_cell_size(&mut self) -> (CellSize, CellSize) {
+        let size = if let Some(size) = self.sizes.get(self.size_index) {
+            self.size_index += 1;
+            *size
+        } else {
+            crate::log_or_panic!(
+                "Added more `Strip` cells than were pre-allocated ({} pre-allocated)",
+                self.sizes.len()
+            );
+            8.0 // anything will look wrong, so pick something that is obviously wrong
+        };
+
+        match self.direction {
+            CellDirection::Horizontal => (CellSize::Absolute(size), CellSize::Remainder),
+            CellDirection::Vertical => (CellSize::Remainder, CellSize::Absolute(size)),
+        }
+    }
+
+    /// Add cell contents.
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn cell(&mut self, add_contents: impl FnOnce(&mut Ui)) {
+        let (width, height) = self.next_cell_size();
+        let striped = false;
+        self.layout
+            .add(self.clip, striped, width, height, add_contents);
+    }
+
+    /// Add an empty cell.
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn empty(&mut self) {
+        let (width, height) = self.next_cell_size();
+        self.layout.empty(width, height);
+    }
+
+    /// Add a strip as cell.
+    pub fn strip(&mut self, strip_builder: impl FnOnce(StripBuilder<'_>)) {
+        let clip = self.clip;
+        self.cell(|ui| {
+            strip_builder(StripBuilder::new(ui).clip(clip));
+        });
+    }
+}
+
+impl<'a, 'b> Drop for Strip<'a, 'b> {
+    fn drop(&mut self) {
+        while self.size_index < self.sizes.len() {
+            self.empty();
+        }
+    }
+}
diff --git a/egui/crates/egui_extras/src/table.rs b/egui/crates/egui_extras/src/table.rs
new file mode 100644
index 0000000..2283ab4
--- /dev/null
+++ b/egui/crates/egui_extras/src/table.rs
@@ -0,0 +1,1063 @@
+//! Table view with (optional) fixed header and scrolling body.
+//! Cell widths are precalculated with given size hints so we can have tables like this:
+//! | fixed size | all available space/minimum | 30% of available width | fixed size |
+//! Takes all available height, so if you want something below the table, put it in a strip.
+
+use egui::{Align, NumExt as _, Rect, Response, ScrollArea, Ui, Vec2};
+
+use crate::{
+    layout::{CellDirection, CellSize},
+    StripLayout,
+};
+
+// -----------------------------------------------------------------=----------
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum InitialColumnSize {
+    /// Absolute size in points
+    Absolute(f32),
+
+    /// Base on content
+    Automatic(f32),
+
+    /// Take all available space
+    Remainder,
+}
+
+/// Specifies the properties of a column, like its width range.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Column {
+    initial_width: InitialColumnSize,
+    width_range: (f32, f32),
+    /// Clip contents if too narrow?
+    clip: bool,
+
+    resizable: Option<bool>,
+}
+
+impl Column {
+    /// Automatically sized based on content.
+    ///
+    /// If you have many thousands of rows and are therefore using [`TableBody::rows`]
+    /// or [`TableBody::heterogeneous_rows`], then the automatic size will only be based
+    /// on the currently visible rows.
+    pub fn auto() -> Self {
+        Self::auto_with_initial_suggestion(100.0)
+    }
+
+    /// Automatically sized.
+    ///
+    /// The given fallback is a loose suggestion, that may be used to wrap
+    /// cell contents, if they contain a wrapping layout.
+    /// In most cases though, the given value is ignored.
+    pub fn auto_with_initial_suggestion(suggested_width: f32) -> Self {
+        Self::new(InitialColumnSize::Automatic(suggested_width))
+    }
+
+    /// With this initial width.
+    pub fn initial(width: f32) -> Self {
+        Self::new(InitialColumnSize::Absolute(width))
+    }
+
+    /// Always this exact width, never shrink or grow.
+    pub fn exact(width: f32) -> Self {
+        Self::new(InitialColumnSize::Absolute(width))
+            .range(width..=width)
+            .clip(true)
+    }
+
+    /// Take all the space remaining after the other columns have
+    /// been sized.
+    ///
+    /// If you have multiple [`Column::remainder`] they all
+    /// share the remaining space equally.
+    pub fn remainder() -> Self {
+        Self::new(InitialColumnSize::Remainder)
+    }
+
+    fn new(initial_width: InitialColumnSize) -> Self {
+        Self {
+            initial_width,
+            width_range: (0.0, f32::INFINITY),
+            resizable: None,
+            clip: false,
+        }
+    }
+
+    /// Can this column be resized by dragging the column separator?
+    ///
+    /// If you don't call this, the fallback value of
+    /// [`TableBuilder::resizable`] is used (which by default is `false`).
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.resizable = Some(resizable);
+        self
+    }
+
+    /// If `true`: Allow the column to shrink enough to clip the contents.
+    /// If `false`: The column will always be wide enough to contain all its content.
+    ///
+    /// Clipping can make sense if you expect a column to contain a lot of things,
+    /// and you don't want it too take up too much space.
+    /// If you turn on clipping you should also consider calling [`Self::at_least`].
+    ///
+    /// Default: `false`.
+    pub fn clip(mut self, clip: bool) -> Self {
+        self.clip = clip;
+        self
+    }
+
+    /// Won't shrink below this width (in points).
+    ///
+    /// Default: 0.0
+    pub fn at_least(mut self, minimum: f32) -> Self {
+        self.width_range.0 = minimum;
+        self
+    }
+
+    /// Won't grow above this width (in points).
+    ///
+    /// Default: [`f32::INFINITY`]
+    pub fn at_most(mut self, maximum: f32) -> Self {
+        self.width_range.1 = maximum;
+        self
+    }
+
+    /// Allowed range of movement (in points), if in a resizable [`Table`](crate::table::Table).
+    pub fn range(mut self, range: std::ops::RangeInclusive<f32>) -> Self {
+        self.width_range = (*range.start(), *range.end());
+        self
+    }
+
+    fn is_auto(&self) -> bool {
+        match self.initial_width {
+            InitialColumnSize::Automatic(_) => true,
+            InitialColumnSize::Absolute(_) | InitialColumnSize::Remainder => false,
+        }
+    }
+}
+
+fn to_sizing(columns: &[Column]) -> crate::sizing::Sizing {
+    use crate::Size;
+
+    let mut sizing = crate::sizing::Sizing::default();
+    for column in columns {
+        let size = match column.initial_width {
+            InitialColumnSize::Absolute(width) => Size::exact(width),
+            InitialColumnSize::Automatic(suggested_width) => Size::initial(suggested_width),
+            InitialColumnSize::Remainder => Size::remainder(),
+        }
+        .at_least(column.width_range.0)
+        .at_most(column.width_range.1);
+        sizing.add(size);
+    }
+    sizing
+}
+
+// -----------------------------------------------------------------=----------
+
+struct TableScrollOptions {
+    vscroll: bool,
+    stick_to_bottom: bool,
+    scroll_to_row: Option<(usize, Option<Align>)>,
+    scroll_offset_y: Option<f32>,
+    min_scrolled_height: f32,
+    max_scroll_height: f32,
+    auto_shrink: [bool; 2],
+}
+
+impl Default for TableScrollOptions {
+    fn default() -> Self {
+        Self {
+            vscroll: true,
+            stick_to_bottom: false,
+            scroll_to_row: None,
+            scroll_offset_y: None,
+            min_scrolled_height: 200.0,
+            max_scroll_height: 800.0,
+            auto_shrink: [true; 2],
+        }
+    }
+}
+
+// -----------------------------------------------------------------=----------
+
+/// Builder for a [`Table`] with (optional) fixed header and scrolling body.
+///
+/// You must pre-allocate all columns with [`Self::column`]/[`Self::columns`].
+///
+/// If you have multiple [`Table`]:s in the same [`Ui`]
+/// you will need to give them unique id:s by surrounding them with [`Ui::push_id`].
+///
+/// ### Example
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// use egui_extras::{TableBuilder, Column};
+/// TableBuilder::new(ui)
+///     .column(Column::auto().resizable(true))
+///     .column(Column::remainder())
+///     .header(20.0, |mut header| {
+///         header.col(|ui| {
+///             ui.heading("First column");
+///         });
+///         header.col(|ui| {
+///             ui.heading("Second column");
+///         });
+///     })
+///     .body(|mut body| {
+///         body.row(30.0, |mut row| {
+///             row.col(|ui| {
+///                 ui.label("Hello");
+///             });
+///             row.col(|ui| {
+///                 ui.button("world!");
+///             });
+///         });
+///     });
+/// # });
+/// ```
+pub struct TableBuilder<'a> {
+    ui: &'a mut Ui,
+    columns: Vec<Column>,
+    striped: Option<bool>,
+    resizable: bool,
+    cell_layout: egui::Layout,
+    scroll_options: TableScrollOptions,
+}
+
+impl<'a> TableBuilder<'a> {
+    pub fn new(ui: &'a mut Ui) -> Self {
+        let cell_layout = *ui.layout();
+        Self {
+            ui,
+            columns: Default::default(),
+            striped: None,
+            resizable: false,
+            cell_layout,
+            scroll_options: Default::default(),
+        }
+    }
+
+    /// Enable striped row background for improved readability.
+    ///
+    /// Default is whatever is in [`egui::Visuals::striped`].
+    pub fn striped(mut self, striped: bool) -> Self {
+        self.striped = Some(striped);
+        self
+    }
+
+    /// Make the columns resizable by dragging.
+    ///
+    /// You can set this for individual columns with [`Column::resizable`].
+    /// [`Self::resizable`] is used as a fallback for any column for which you don't call
+    /// [`Column::resizable`].
+    ///
+    /// If the _last_ column is [`Column::remainder`], then it won't be resizable
+    /// (and instead use up the remainder).
+    ///
+    /// Default is `false`.
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.resizable = resizable;
+        self
+    }
+
+    /// Enable vertical scrolling in body (default: `true`)
+    pub fn vscroll(mut self, vscroll: bool) -> Self {
+        self.scroll_options.vscroll = vscroll;
+        self
+    }
+
+    #[deprecated = "Renamed to vscroll"]
+    pub fn scroll(self, vscroll: bool) -> Self {
+        self.vscroll(vscroll)
+    }
+
+    /// Should the scroll handle stick to the bottom position even as the content size changes
+    /// dynamically? The scroll handle remains stuck until manually changed, and will become stuck
+    /// once again when repositioned to the bottom. Default: `false`.
+    pub fn stick_to_bottom(mut self, stick: bool) -> Self {
+        self.scroll_options.stick_to_bottom = stick;
+        self
+    }
+
+    /// Set a row to scroll to.
+    ///
+    /// `align` specifies if the row should be positioned in the top, center, or bottom of the view
+    /// (using [`Align::TOP`], [`Align::Center`] or [`Align::BOTTOM`]).
+    /// If `align` is `None`, the table will scroll just enough to bring the cursor into view.
+    ///
+    /// See also: [`Self::vertical_scroll_offset`].
+    pub fn scroll_to_row(mut self, row: usize, align: Option<Align>) -> Self {
+        self.scroll_options.scroll_to_row = Some((row, align));
+        self
+    }
+
+    /// Set the vertical scroll offset position, in points.
+    ///
+    /// See also: [`Self::scroll_to_row`].
+    pub fn vertical_scroll_offset(mut self, offset: f32) -> Self {
+        self.scroll_options.scroll_offset_y = Some(offset);
+        self
+    }
+
+    /// The minimum height of a vertical scroll area which requires scroll bars.
+    ///
+    /// The scroll area will only become smaller than this if the content is smaller than this
+    /// (and so we don't require scroll bars).
+    ///
+    /// Default: `200.0`.
+    pub fn min_scrolled_height(mut self, min_scrolled_height: f32) -> Self {
+        self.scroll_options.min_scrolled_height = min_scrolled_height;
+        self
+    }
+
+    /// Don't make the scroll area higher than this (add scroll-bars instead!).
+    ///
+    /// In other words: add scroll-bars when this height is reached.
+    /// Default: `800.0`.
+    pub fn max_scroll_height(mut self, max_scroll_height: f32) -> Self {
+        self.scroll_options.max_scroll_height = max_scroll_height;
+        self
+    }
+
+    /// For each axis (x,y):
+    /// * If true, add blank space outside the table, keeping the table small.
+    /// * If false, add blank space inside the table, expanding the table to fit the containing ui.
+    ///
+    /// Default: `[true; 2]`.
+    ///
+    /// See [`ScrollArea::auto_shrink`] for more.
+    pub fn auto_shrink(mut self, auto_shrink: [bool; 2]) -> Self {
+        self.scroll_options.auto_shrink = auto_shrink;
+        self
+    }
+
+    /// What layout should we use for the individual cells?
+    pub fn cell_layout(mut self, cell_layout: egui::Layout) -> Self {
+        self.cell_layout = cell_layout;
+        self
+    }
+
+    /// Allocate space for one column.
+    pub fn column(mut self, column: Column) -> Self {
+        self.columns.push(column);
+        self
+    }
+
+    /// Allocate space for several columns at once.
+    pub fn columns(mut self, column: Column, count: usize) -> Self {
+        for _ in 0..count {
+            self.columns.push(column);
+        }
+        self
+    }
+
+    fn available_width(&self) -> f32 {
+        self.ui.available_rect_before_wrap().width()
+            - if self.scroll_options.vscroll {
+                self.ui.spacing().scroll_bar_inner_margin
+                    + self.ui.spacing().scroll_bar_width
+                    + self.ui.spacing().scroll_bar_outer_margin
+            } else {
+                0.0
+            }
+    }
+
+    /// Create a header row which always stays visible and at the top
+    pub fn header(self, height: f32, add_header_row: impl FnOnce(TableRow<'_, '_>)) -> Table<'a> {
+        let available_width = self.available_width();
+
+        let Self {
+            ui,
+            columns,
+            striped,
+            resizable,
+            cell_layout,
+            scroll_options,
+        } = self;
+
+        let striped = striped.unwrap_or(ui.visuals().striped);
+
+        let state_id = ui.id().with("__table_state");
+
+        let initial_widths =
+            to_sizing(&columns).to_lengths(available_width, ui.spacing().item_spacing.x);
+        let mut max_used_widths = vec![0.0; initial_widths.len()];
+        let (had_state, state) = TableState::load(ui, initial_widths, state_id);
+        let is_first_frame = !had_state;
+        let first_frame_auto_size_columns = is_first_frame && columns.iter().any(|c| c.is_auto());
+
+        let table_top = ui.cursor().top();
+
+        // Hide first-frame-jitters when auto-sizing.
+        ui.add_visible_ui(!first_frame_auto_size_columns, |ui| {
+            let mut layout = StripLayout::new(ui, CellDirection::Horizontal, cell_layout);
+            add_header_row(TableRow {
+                layout: &mut layout,
+                columns: &columns,
+                widths: &state.column_widths,
+                max_used_widths: &mut max_used_widths,
+                col_index: 0,
+                striped: false,
+                height,
+            });
+            layout.allocate_rect();
+        });
+
+        Table {
+            ui,
+            table_top,
+            state_id,
+            columns,
+            available_width,
+            state,
+            max_used_widths,
+            first_frame_auto_size_columns,
+            resizable,
+            striped,
+            cell_layout,
+            scroll_options,
+        }
+    }
+
+    /// Create table body without a header row
+    pub fn body<F>(self, add_body_contents: F)
+    where
+        F: for<'b> FnOnce(TableBody<'b>),
+    {
+        let available_width = self.available_width();
+
+        let Self {
+            ui,
+            columns,
+            striped,
+            resizable,
+            cell_layout,
+            scroll_options,
+        } = self;
+
+        let striped = striped.unwrap_or(ui.visuals().striped);
+
+        let state_id = ui.id().with("__table_state");
+
+        let initial_widths =
+            to_sizing(&columns).to_lengths(available_width, ui.spacing().item_spacing.x);
+        let max_used_widths = vec![0.0; initial_widths.len()];
+        let (had_state, state) = TableState::load(ui, initial_widths, state_id);
+        let is_first_frame = !had_state;
+        let first_frame_auto_size_columns = is_first_frame && columns.iter().any(|c| c.is_auto());
+
+        let table_top = ui.cursor().top();
+
+        Table {
+            ui,
+            table_top,
+            state_id,
+            columns,
+            available_width,
+            state,
+            max_used_widths,
+            first_frame_auto_size_columns,
+            resizable,
+            striped,
+            cell_layout,
+            scroll_options,
+        }
+        .body(add_body_contents);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+struct TableState {
+    column_widths: Vec<f32>,
+}
+
+impl TableState {
+    /// Returns `true` if it did load.
+    fn load(ui: &egui::Ui, default_widths: Vec<f32>, state_id: egui::Id) -> (bool, Self) {
+        let rect = Rect::from_min_size(ui.available_rect_before_wrap().min, Vec2::ZERO);
+        ui.ctx().check_for_id_clash(state_id, rect, "Table");
+
+        if let Some(state) = ui.data_mut(|d| d.get_persisted::<Self>(state_id)) {
+            // make sure that the stored widths aren't out-dated
+            if state.column_widths.len() == default_widths.len() {
+                return (true, state);
+            }
+        }
+
+        (
+            false,
+            Self {
+                column_widths: default_widths,
+            },
+        )
+    }
+
+    fn store(self, ui: &egui::Ui, state_id: egui::Id) {
+        ui.data_mut(|d| d.insert_persisted(state_id, self));
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Table struct which can construct a [`TableBody`].
+///
+/// Is created by [`TableBuilder`] by either calling [`TableBuilder::body`] or after creating a header row with [`TableBuilder::header`].
+pub struct Table<'a> {
+    ui: &'a mut Ui,
+    table_top: f32,
+    state_id: egui::Id,
+    columns: Vec<Column>,
+    available_width: f32,
+    state: TableState,
+    /// Accumulated maximum used widths for each column.
+    max_used_widths: Vec<f32>,
+    first_frame_auto_size_columns: bool,
+    resizable: bool,
+    striped: bool,
+    cell_layout: egui::Layout,
+
+    scroll_options: TableScrollOptions,
+}
+
+impl<'a> Table<'a> {
+    /// Access the contained [`egui::Ui`].
+    ///
+    /// You can use this to e.g. modify the [`egui::Style`] with [`egui::Ui::style_mut`].
+    pub fn ui_mut(&mut self) -> &mut egui::Ui {
+        self.ui
+    }
+
+    /// Create table body after adding a header row
+    pub fn body<F>(self, add_body_contents: F)
+    where
+        F: for<'b> FnOnce(TableBody<'b>),
+    {
+        let Table {
+            ui,
+            table_top,
+            state_id,
+            columns,
+            resizable,
+            mut available_width,
+            mut state,
+            mut max_used_widths,
+            first_frame_auto_size_columns,
+            striped,
+            cell_layout,
+            scroll_options,
+        } = self;
+
+        let TableScrollOptions {
+            vscroll,
+            stick_to_bottom,
+            scroll_to_row,
+            scroll_offset_y,
+            min_scrolled_height,
+            max_scroll_height,
+            auto_shrink,
+        } = scroll_options;
+
+        let avail_rect = ui.available_rect_before_wrap();
+
+        let mut scroll_area = ScrollArea::new([false, vscroll])
+            .auto_shrink([true; 2])
+            .stick_to_bottom(stick_to_bottom)
+            .min_scrolled_height(min_scrolled_height)
+            .max_height(max_scroll_height)
+            .auto_shrink(auto_shrink);
+
+        if let Some(scroll_offset_y) = scroll_offset_y {
+            scroll_area = scroll_area.vertical_scroll_offset(scroll_offset_y);
+        }
+
+        let columns_ref = &columns;
+        let widths_ref = &state.column_widths;
+        let max_used_widths_ref = &mut max_used_widths;
+
+        scroll_area.show(ui, move |ui| {
+            let mut scroll_to_y_range = None;
+
+            // Hide first-frame-jitters when auto-sizing.
+            ui.add_visible_ui(!first_frame_auto_size_columns, |ui| {
+                let layout = StripLayout::new(ui, CellDirection::Horizontal, cell_layout);
+
+                add_body_contents(TableBody {
+                    layout,
+                    columns: columns_ref,
+                    widths: widths_ref,
+                    max_used_widths: max_used_widths_ref,
+                    striped,
+                    row_nr: 0,
+                    start_y: avail_rect.top(),
+                    end_y: avail_rect.bottom(),
+                    scroll_to_row: scroll_to_row.map(|(r, _)| r),
+                    scroll_to_y_range: &mut scroll_to_y_range,
+                });
+
+                if scroll_to_row.is_some() && scroll_to_y_range.is_none() {
+                    // TableBody::row didn't find the right row, so scroll to the bottom:
+                    scroll_to_y_range = Some((f32::INFINITY, f32::INFINITY));
+                }
+            });
+
+            if let Some((min_y, max_y)) = scroll_to_y_range {
+                let x = 0.0; // ignored, we only have vertical scrolling
+                let rect = egui::Rect::from_min_max(egui::pos2(x, min_y), egui::pos2(x, max_y));
+                let align = scroll_to_row.and_then(|(_, a)| a);
+                ui.scroll_to_rect(rect, align);
+            }
+        });
+
+        let bottom = ui.min_rect().bottom();
+
+        let spacing_x = ui.spacing().item_spacing.x;
+        let mut x = avail_rect.left() - spacing_x * 0.5;
+        for (i, column_width) in state.column_widths.iter_mut().enumerate() {
+            let column = &columns[i];
+            let column_is_resizable = column.resizable.unwrap_or(resizable);
+            let (min_width, max_width) = column.width_range;
+
+            if !column.clip {
+                // Unless we clip we don't want to shrink below the
+                // size that was actually used:
+                *column_width = column_width.at_least(max_used_widths[i]);
+            }
+            *column_width = column_width.clamp(min_width, max_width);
+
+            let is_last_column = i + 1 == columns.len();
+
+            if is_last_column && column.initial_width == InitialColumnSize::Remainder {
+                // If the last column is 'remainder', then let it fill the remainder!
+                let eps = 0.1; // just to avoid some rounding errors.
+                *column_width = available_width - eps;
+                *column_width = column_width.at_least(max_used_widths[i]);
+                *column_width = column_width.clamp(min_width, max_width);
+                break;
+            }
+
+            x += *column_width + spacing_x;
+
+            if column.is_auto() && (first_frame_auto_size_columns || !column_is_resizable) {
+                *column_width = max_used_widths[i];
+                *column_width = column_width.clamp(min_width, max_width);
+            } else if column_is_resizable {
+                let column_resize_id = ui.id().with("resize_column").with(i);
+
+                let mut p0 = egui::pos2(x, table_top);
+                let mut p1 = egui::pos2(x, bottom);
+                let line_rect = egui::Rect::from_min_max(p0, p1)
+                    .expand(ui.style().interaction.resize_grab_radius_side);
+
+                let resize_response =
+                    ui.interact(line_rect, column_resize_id, egui::Sense::click_and_drag());
+
+                if resize_response.double_clicked() {
+                    // Resize to the minimum of what is needed.
+
+                    *column_width = max_used_widths[i].clamp(min_width, max_width);
+                } else if resize_response.dragged() {
+                    if let Some(pointer) = ui.ctx().pointer_latest_pos() {
+                        let mut new_width = *column_width + pointer.x - x;
+                        if !column.clip {
+                            // Unless we clip we don't want to shrink below the
+                            // size that was actually used.
+                            // However, we still want to allow content that shrinks when you try
+                            // to make the column less wide, so we allow some small shrinkage each frame:
+                            // big enough to allow shrinking over time, small enough not to look ugly when
+                            // shrinking fails. This is a bit of a HACK around immediate mode.
+                            let max_shrinkage_per_frame = 8.0;
+                            new_width =
+                                new_width.at_least(max_used_widths[i] - max_shrinkage_per_frame);
+                        }
+                        new_width = new_width.clamp(min_width, max_width);
+
+                        let x = x - *column_width + new_width;
+                        (p0.x, p1.x) = (x, x);
+
+                        *column_width = new_width;
+                    }
+                }
+
+                let dragging_something_else =
+                    ui.input(|i| i.pointer.any_down() || i.pointer.any_pressed());
+                let resize_hover = resize_response.hovered() && !dragging_something_else;
+
+                if resize_hover || resize_response.dragged() {
+                    ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeColumn);
+                }
+
+                let stroke = if resize_response.dragged() {
+                    ui.style().visuals.widgets.active.bg_stroke
+                } else if resize_hover {
+                    ui.style().visuals.widgets.hovered.bg_stroke
+                } else {
+                    // ui.visuals().widgets.inactive.bg_stroke
+                    ui.visuals().widgets.noninteractive.bg_stroke
+                };
+
+                ui.painter().line_segment([p0, p1], stroke);
+            };
+
+            available_width -= *column_width + spacing_x;
+        }
+
+        state.store(ui, state_id);
+    }
+}
+
+/// The body of a table.
+///
+/// Is created by calling `body` on a [`Table`] (after adding a header row) or [`TableBuilder`] (without a header row).
+pub struct TableBody<'a> {
+    layout: StripLayout<'a>,
+
+    columns: &'a [Column],
+
+    /// Current column widths.
+    widths: &'a [f32],
+
+    /// Accumulated maximum used widths for each column.
+    max_used_widths: &'a mut [f32],
+
+    striped: bool,
+    row_nr: usize,
+    start_y: f32,
+    end_y: f32,
+
+    /// Look for this row to scroll to.
+    scroll_to_row: Option<usize>,
+
+    /// If we find the correct row to scroll to,
+    /// this is set to the y-range of the row.
+    scroll_to_y_range: &'a mut Option<(f32, f32)>,
+}
+
+impl<'a> TableBody<'a> {
+    /// Access the contained [`egui::Ui`].
+    ///
+    /// You can use this to e.g. modify the [`egui::Style`] with [`egui::Ui::style_mut`].
+    pub fn ui_mut(&mut self) -> &mut egui::Ui {
+        self.layout.ui
+    }
+
+    /// Where in screen-space is the table body?
+    pub fn max_rect(&self) -> Rect {
+        self.layout
+            .rect
+            .translate(egui::vec2(0.0, self.scroll_offset_y()))
+    }
+
+    fn scroll_offset_y(&self) -> f32 {
+        self.start_y - self.layout.rect.top()
+    }
+
+    /// Return a vector containing all column widths for this table body.
+    ///
+    /// This is primarily meant for use with [`TableBody::heterogeneous_rows`] in cases where row
+    /// heights are expected to according to the width of one or more cells -- for example, if text
+    /// is wrapped rather than clipped within the cell.
+    pub fn widths(&self) -> &[f32] {
+        self.widths
+    }
+
+    /// Add a single row with the given height.
+    ///
+    /// If you have many thousands of row it can be more performant to instead use [`Self::rows`] or [`Self::heterogeneous_rows`].
+    pub fn row(&mut self, height: f32, add_row_content: impl FnOnce(TableRow<'a, '_>)) {
+        let top_y = self.layout.cursor.y;
+        add_row_content(TableRow {
+            layout: &mut self.layout,
+            columns: self.columns,
+            widths: self.widths,
+            max_used_widths: self.max_used_widths,
+            col_index: 0,
+            striped: self.striped && self.row_nr % 2 == 0,
+            height,
+        });
+        let bottom_y = self.layout.cursor.y;
+
+        if Some(self.row_nr) == self.scroll_to_row {
+            *self.scroll_to_y_range = Some((top_y, bottom_y));
+        }
+
+        self.row_nr += 1;
+    }
+
+    /// Add many rows with same height.
+    ///
+    /// Is a lot more performant than adding each individual row as non visible rows must not be rendered.
+    ///
+    /// If you need many rows with different heights, use [`Self::heterogeneous_rows`] instead.
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// use egui_extras::{TableBuilder, Column};
+    /// TableBuilder::new(ui)
+    ///     .column(Column::remainder().at_least(100.0))
+    ///     .body(|mut body| {
+    ///         let row_height = 18.0;
+    ///         let num_rows = 10_000;
+    ///         body.rows(row_height, num_rows, |row_index, mut row| {
+    ///             row.col(|ui| {
+    ///                 ui.label("First column");
+    ///             });
+    ///         });
+    ///     });
+    /// # });
+    /// ```
+    pub fn rows(
+        mut self,
+        row_height_sans_spacing: f32,
+        total_rows: usize,
+        mut add_row_content: impl FnMut(usize, TableRow<'_, '_>),
+    ) {
+        let spacing = self.layout.ui.spacing().item_spacing;
+        let row_height_with_spacing = row_height_sans_spacing + spacing.y;
+
+        if let Some(scroll_to_row) = self.scroll_to_row {
+            let scroll_to_row = scroll_to_row.at_most(total_rows.saturating_sub(1)) as f32;
+            *self.scroll_to_y_range = Some((
+                self.layout.cursor.y + scroll_to_row * row_height_with_spacing,
+                self.layout.cursor.y + (scroll_to_row + 1.0) * row_height_with_spacing,
+            ));
+        }
+
+        let scroll_offset_y = self
+            .scroll_offset_y()
+            .min(total_rows as f32 * row_height_with_spacing);
+        let max_height = self.end_y - self.start_y;
+        let mut min_row = 0;
+
+        if scroll_offset_y > 0.0 {
+            min_row = (scroll_offset_y / row_height_with_spacing).floor() as usize;
+            self.add_buffer(min_row as f32 * row_height_with_spacing);
+        }
+
+        let max_row =
+            ((scroll_offset_y + max_height) / row_height_with_spacing).ceil() as usize + 1;
+        let max_row = max_row.min(total_rows);
+
+        for idx in min_row..max_row {
+            add_row_content(
+                idx,
+                TableRow {
+                    layout: &mut self.layout,
+                    columns: self.columns,
+                    widths: self.widths,
+                    max_used_widths: self.max_used_widths,
+                    col_index: 0,
+                    striped: self.striped && idx % 2 == 0,
+                    height: row_height_sans_spacing,
+                },
+            );
+        }
+
+        if total_rows - max_row > 0 {
+            let skip_height = (total_rows - max_row) as f32 * row_height_with_spacing;
+            self.add_buffer(skip_height - spacing.y);
+        }
+    }
+
+    /// Add rows with varying heights.
+    ///
+    /// This takes a very slight performance hit compared to [`TableBody::rows`] due to the need to
+    /// iterate over all row heights in to calculate the virtual table height above and below the
+    /// visible region, but it is many orders of magnitude more performant than adding individual
+    /// heterogeneously-sized rows using [`TableBody::row`] at the cost of the additional complexity
+    /// that comes with pre-calculating row heights and representing them as an iterator.
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// use egui_extras::{TableBuilder, Column};
+    /// TableBuilder::new(ui)
+    ///     .column(Column::remainder().at_least(100.0))
+    ///     .body(|mut body| {
+    ///         let row_heights: Vec<f32> = vec![60.0, 18.0, 31.0, 240.0];
+    ///         body.heterogeneous_rows(row_heights.into_iter(), |row_index, mut row| {
+    ///             let thick = row_index % 6 == 0;
+    ///             row.col(|ui| {
+    ///                 ui.centered_and_justified(|ui| {
+    ///                     ui.label(row_index.to_string());
+    ///                 });
+    ///             });
+    ///         });
+    ///     });
+    /// # });
+    /// ```
+    pub fn heterogeneous_rows(
+        mut self,
+        heights: impl Iterator<Item = f32>,
+        mut add_row_content: impl FnMut(usize, TableRow<'_, '_>),
+    ) {
+        let spacing = self.layout.ui.spacing().item_spacing;
+        let mut enumerated_heights = heights.enumerate();
+
+        let max_height = self.end_y - self.start_y;
+        let scroll_offset_y = self.scroll_offset_y() as f64;
+
+        let scroll_to_y_range_offset = self.layout.cursor.y as f64;
+
+        let mut cursor_y: f64 = 0.0;
+
+        // Skip the invisible rows, and populate the first non-virtual row.
+        for (row_index, row_height) in &mut enumerated_heights {
+            let old_cursor_y = cursor_y;
+            cursor_y += (row_height + spacing.y) as f64;
+
+            if Some(row_index) == self.scroll_to_row {
+                *self.scroll_to_y_range = Some((
+                    (scroll_to_y_range_offset + old_cursor_y) as f32,
+                    (scroll_to_y_range_offset + cursor_y) as f32,
+                ));
+            }
+
+            if cursor_y >= scroll_offset_y {
+                // This row is visible:
+                self.add_buffer(old_cursor_y as f32); // skip all the invisible rows
+
+                add_row_content(
+                    row_index,
+                    TableRow {
+                        layout: &mut self.layout,
+                        columns: self.columns,
+                        widths: self.widths,
+                        max_used_widths: self.max_used_widths,
+                        col_index: 0,
+                        striped: self.striped && row_index % 2 == 0,
+                        height: row_height,
+                    },
+                );
+                break;
+            }
+        }
+
+        // populate visible rows:
+        for (row_index, row_height) in &mut enumerated_heights {
+            let top_y = cursor_y;
+            add_row_content(
+                row_index,
+                TableRow {
+                    layout: &mut self.layout,
+                    columns: self.columns,
+                    widths: self.widths,
+                    max_used_widths: self.max_used_widths,
+                    col_index: 0,
+                    striped: self.striped && row_index % 2 == 0,
+                    height: row_height,
+                },
+            );
+            cursor_y += (row_height + spacing.y) as f64;
+
+            if Some(row_index) == self.scroll_to_row {
+                *self.scroll_to_y_range = Some((
+                    (scroll_to_y_range_offset + top_y) as f32,
+                    (scroll_to_y_range_offset + cursor_y) as f32,
+                ));
+            }
+
+            if cursor_y > scroll_offset_y + max_height as f64 {
+                break;
+            }
+        }
+
+        // calculate height below the visible table range:
+        let mut height_below_visible: f64 = 0.0;
+        for (row_index, row_height) in enumerated_heights {
+            height_below_visible += (row_height + spacing.y) as f64;
+
+            let top_y = cursor_y;
+            cursor_y += (row_height + spacing.y) as f64;
+            if Some(row_index) == self.scroll_to_row {
+                *self.scroll_to_y_range = Some((
+                    (scroll_to_y_range_offset + top_y) as f32,
+                    (scroll_to_y_range_offset + cursor_y) as f32,
+                ));
+            }
+        }
+
+        if self.scroll_to_row.is_some() && self.scroll_to_y_range.is_none() {
+            // Catch desire to scroll past the end:
+            *self.scroll_to_y_range = Some((
+                (scroll_to_y_range_offset + cursor_y) as f32,
+                (scroll_to_y_range_offset + cursor_y) as f32,
+            ));
+        }
+
+        if height_below_visible > 0.0 {
+            // we need to add a buffer to allow the table to
+            // accurately calculate the scrollbar position
+            self.add_buffer(height_below_visible as f32);
+        }
+    }
+
+    // Create a table row buffer of the given height to represent the non-visible portion of the
+    // table.
+    fn add_buffer(&mut self, height: f32) {
+        self.layout.skip_space(egui::vec2(0.0, height));
+    }
+}
+
+impl<'a> Drop for TableBody<'a> {
+    fn drop(&mut self) {
+        self.layout.allocate_rect();
+    }
+}
+
+/// The row of a table.
+/// Is created by [`TableRow`] for each created [`TableBody::row`] or each visible row in rows created by calling [`TableBody::rows`].
+pub struct TableRow<'a, 'b> {
+    layout: &'b mut StripLayout<'a>,
+    columns: &'b [Column],
+    widths: &'b [f32],
+    /// grows during building with the maximum widths
+    max_used_widths: &'b mut [f32],
+    col_index: usize,
+    striped: bool,
+    height: f32,
+}
+
+impl<'a, 'b> TableRow<'a, 'b> {
+    /// Add the contents of a column.
+    ///
+    /// Return the used space (`min_rect`) plus the [`Response`] of the whole cell.
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn col(&mut self, add_cell_contents: impl FnOnce(&mut Ui)) -> (Rect, Response) {
+        let col_index = self.col_index;
+
+        let clip = self.columns.get(col_index).map_or(false, |c| c.clip);
+
+        let width = if let Some(width) = self.widths.get(col_index) {
+            self.col_index += 1;
+            *width
+        } else {
+            crate::log_or_panic!(
+                "Added more `Table` columns than were pre-allocated ({} pre-allocated)",
+                self.widths.len()
+            );
+            8.0 // anything will look wrong, so pick something that is obviously wrong
+        };
+
+        let width = CellSize::Absolute(width);
+        let height = CellSize::Absolute(self.height);
+
+        let (used_rect, response) =
+            self.layout
+                .add(clip, self.striped, width, height, add_cell_contents);
+
+        if let Some(max_w) = self.max_used_widths.get_mut(col_index) {
+            *max_w = max_w.max(used_rect.width());
+        }
+
+        (used_rect, response)
+    }
+}
+
+impl<'a, 'b> Drop for TableRow<'a, 'b> {
+    fn drop(&mut self) {
+        self.layout.end_line();
+    }
+}
diff --git a/egui/crates/egui_glium/CHANGELOG.md b/egui/crates/egui_glium/CHANGELOG.md
new file mode 100644
index 0000000..a34c234
--- /dev/null
+++ b/egui/crates/egui_glium/CHANGELOG.md
@@ -0,0 +1,122 @@
+# Changelog for egui_glium
+All notable changes to the `egui_glium` integration will be noted in this file.
+
+
+## Unreleased
+* Remove the `screen_reader` feature ([#2669](https://github.com/emilk/egui/pull/2669)).
+
+
+## 0.20.1 - 2022-12-11
+* Fix [docs.rs](https://docs.rs/egui_glium) build ([#2420](https://github.com/emilk/egui/pull/2420)).
+
+
+## 0.20.0 - 2022-12-08
+* MSRV (Minimum Supported Rust Version) is now `1.65.0` ([#2314](https://github.com/emilk/egui/pull/2314)).
+
+
+## 0.19.0 - 2022-08-20
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+
+
+## 0.18.0 - 2022-04-30
+* Remove "epi" feature ([#1361](https://github.com/emilk/egui/pull/1361)).
+* Remove need for `trait epi::NativeTexture` to use the `fn register_native_texture/replace_native_texture` ([#1361](https://github.com/emilk/egui/pull/1361)).
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+
+
+## 0.17.0 - 2022-02-22
+* `EguiGlium::run` no longer returns the shapes to paint, but stores them internally until you call `EguiGlium::paint` ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Optimize the painter and texture uploading ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+
+
+## 0.16.0 - 2021-12-29
+* Simplified `EguiGlium` interface ([#871](https://github.com/emilk/egui/pull/871)).
+* Removed `EguiGlium::is_quit_event` ([#881](https://github.com/emilk/egui/pull/881)).
+* Updated `glium` to 0.31 ([#930](https://github.com/emilk/egui/pull/930)).
+* Changed the `Painter` interface slightly ([#999](https://github.com/emilk/egui/pull/999)).
+
+
+## 0.15.0 - 2021-10-24
+* Remove "http" feature (use https://github.com/emilk/ehttp instead!).
+* Implement `epi::NativeTexture` trait for the glium painter.
+* Deprecate 'Painter::register_glium_texture'.
+* Increase scroll speed.
+* Restore window position on startup without flickering.
+* A lot of the code has been moved to the new library [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit).
+* Fixed reactive mode on windows.
+
+
+## 0.14.0 - 2021-08-24
+* Fixed native file dialogs hanging (eg. when using [`rfd`](https://github.com/PolyMeilex/rfd)).
+* Implement drag-and-dropping files into the application.
+* [Fix minimize on Windows](https://github.com/emilk/egui/issues/518).
+* Change `drag_and_drop_support` to `false` by default (Windows only). See <https://github.com/emilk/egui/issues/598>.
+* Don't restore window position on Windows, because the position would sometimes be invalid.
+
+
+## 0.13.1 - 2021-06-24
+* Fixed `http` feature flag and docs
+
+
+## 0.13.0 - 2021-06-24
+* Added `EguiGlium::is_quit_event` to replace `control_flow` argument to `EguiGlium::on_event`.
+* [Fix modifier key for zoom with mouse wheel on Mac](https://github.com/emilk/egui/issues/401)
+* [Fix stuck modifier keys](https://github.com/emilk/egui/pull/479)
+
+
+## 0.12.0 - 2021-05-10
+* Simplify usage with a new `EguiGlium` wrapper type.
+
+
+## 0.11.0 - 2021-04-05
+* [Position IME candidate window next to text cursor](https://github.com/emilk/egui/pull/258).
+* [Register your own glium textures](https://github.com/emilk/egui/pull/226).
+* [Fix cursor icon flickering on Windows(https://github.com/emilk/egui/pull/218).
+
+
+## 0.10.0 - 2021-02-28
+* [Add shaders for GLSL 1.2, GLSL ES 1.0 and 3.0](https://github.com/emilk/egui/pull/187)
+  - now `egui` works well on old hardware which supports OpenGL 2.1 only like Raspberry Pi 1 and Zero.
+
+
+## 0.9.0 - 2021-02-07
+* Nothing new
+
+
+## 0.8.0 - 2021-01-17
+* Fixed a bug where key releases weren't sent to egui
+* Fixed `set_window_size` for non-native `pixels_per_point`.
+
+
+## 0.7.0 - 2021-01-04
+* `http` `persistence` and `time` are now optional (and opt-in) features.
+
+
+## 0.6.0 - 2020-12-26
+### Added ⭐
+* `egui_glium` will auto-save your app state every 30 seconds.
+* `egui_glium` can now set windows as fixed size (e.g. the user can't resize the window). See `egui::App::is_resizable()`.
+
+### Changed 🔧
+* `egui_glium` will now save you app state to [a better directory](https://docs.rs/directories-next/2.0.0/directories_next/struct.ProjectDirs.html#method.data_dir).
+* `egui_glium::run`: the parameter `app` now has signature `Box<dyn App>` (you need to add `Box::new(app)` to your code).
+* Window title is now passed via the `trait` function `egui::App::name()`.
+
+### Fixed 🐛
+* Serialize window size in logical points instead of physical pixels.
+* Window position is now restored on restart.
+
+
+## 0.5.0 - 2020-12-13
+* FileStorage::from_path now takes `Into<Path>` instead of `String`
+
+
+## 0.4.0 - 2020-11-28
+Started changelog. Features:
+
+* Input
+* Painting
+* Clipboard handling
+* Open URL:s
+* Simple JSON-backed storage
diff --git a/egui/crates/egui_glium/Cargo.toml b/egui/crates/egui_glium/Cargo.toml
new file mode 100644
index 0000000..bc36fb3
--- /dev/null
+++ b/egui/crates/egui_glium/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "egui_glium"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "Bindings for using egui natively using the glium library"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/egui_glium"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/egui_glium"
+categories = ["gui", "game-development"]
+keywords = ["glium", "egui", "gui", "gamedev"]
+include = [
+  "../LICENSE-APACHE",
+  "../LICENSE-MIT",
+  "**/*.rs",
+  "Cargo.toml",
+  "src/shader/*.glsl",
+]
+
+[package.metadata.docs.rs]
+all-features = true
+
+
+[features]
+default = ["clipboard", "links"]
+
+## Enable cut/copy/paste to OS clipboard.
+##
+## If disabled a clipboard will be simulated so you can still copy/paste within the egui app.
+clipboard = ["egui-winit/clipboard"]
+
+## Enable opening links in a browser when an egui hyperlink is clicked.
+links = ["egui-winit/links"]
+
+
+[dependencies]
+egui = { version = "0.21.0", path = "../egui", default-features = false, features = [
+  "bytemuck",
+] }
+egui-winit = { version = "0.21.1", path = "../egui-winit", default-features = false }
+
+ahash = { version = "0.8.1", default-features = false, features = [
+  "no-rng", # we don't need DOS-protection, so we let users opt-in to it instead
+  "std",
+] }
+bytemuck = "1.7"
+glium = "0.32"
+
+#! ### Optional dependencies
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+
+[dev-dependencies]
+egui_demo_lib = { version = "0.21.0", path = "../egui_demo_lib", default-features = false }
+image = { version = "0.24", default-features = false, features = ["png"] }
diff --git a/egui/crates/egui_glium/README.md b/egui/crates/egui_glium/README.md
new file mode 100644
index 0000000..1c31de5
--- /dev/null
+++ b/egui/crates/egui_glium/README.md
@@ -0,0 +1,21 @@
+# egui_glium
+
+[![Latest version](https://img.shields.io/crates/v/egui_glium.svg)](https://crates.io/crates/egui_glium)
+[![Documentation](https://docs.rs/egui_glium/badge.svg)](https://docs.rs/egui_glium)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [glium](https://crates.io/crates/glium) which allows you to write GUI code using egui and compile it and run it natively, cross platform.
+
+To use on Linux, first run:
+
+```
+sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev
+```
+
+This crate depends on [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit).
+
+
+## DEPRECATED - Looking for new maintainer
+This crate is no longer being updated. If you are interested in keeping `egui_glium` updated, then fork it to its own repository, make a PR to the egui repo removing it, and then I will give you access to it on crates.io so you can publish new `egui_glium` crates.
diff --git a/egui/crates/egui_glium/examples/native_texture.rs b/egui/crates/egui_glium/examples/native_texture.rs
new file mode 100644
index 0000000..19e4eae
--- /dev/null
+++ b/egui/crates/egui_glium/examples/native_texture.rs
@@ -0,0 +1,139 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use glium::glutin;
+
+fn main() {
+    let event_loop = glutin::event_loop::EventLoopBuilder::with_user_event().build();
+    let display = create_display(&event_loop);
+
+    let mut egui_glium = egui_glium::EguiGlium::new(&display, &event_loop);
+
+    let png_data = include_bytes!("../../../examples/retained_image/src/rust-logo-256x256.png");
+    let image = load_glium_image(png_data);
+    let image_size = egui::vec2(image.width as f32, image.height as f32);
+    // Load to gpu memory
+    let glium_texture = glium::texture::SrgbTexture2d::new(&display, image).unwrap();
+    // Allow us to share the texture with egui:
+    let glium_texture = std::rc::Rc::new(glium_texture);
+    // Allocate egui's texture id for GL texture
+    let texture_id = egui_glium
+        .painter
+        .register_native_texture(glium_texture, Default::default());
+    // Setup button image size for reasonable image size for button container.
+    let button_image_size = egui::vec2(32_f32, 32_f32);
+
+    event_loop.run(move |event, _, control_flow| {
+        let mut redraw = || {
+            let mut quit = false;
+
+            let repaint_after = egui_glium.run(&display, |egui_ctx| {
+                egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
+                    if ui
+                        .add(egui::Button::image_and_text(
+                            texture_id,
+                            button_image_size,
+                            "Quit",
+                        ))
+                        .clicked()
+                    {
+                        quit = true;
+                    }
+                });
+                egui::Window::new("NativeTextureDisplay").show(egui_ctx, |ui| {
+                    ui.image(texture_id, image_size);
+                });
+            });
+
+            *control_flow = if quit {
+                glutin::event_loop::ControlFlow::Exit
+            } else if repaint_after.is_zero() {
+                display.gl_window().window().request_redraw();
+                glutin::event_loop::ControlFlow::Poll
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                glutin::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
+            } else {
+                glutin::event_loop::ControlFlow::Wait
+            };
+
+            {
+                use glium::Surface as _;
+                let mut target = display.draw();
+
+                let color = egui::Rgba::from_rgb(0.1, 0.3, 0.2);
+                target.clear_color(color[0], color[1], color[2], color[3]);
+
+                // draw things behind egui here
+
+                egui_glium.paint(&display, &mut target);
+
+                // draw things on top of egui here
+
+                target.finish().unwrap();
+            }
+        };
+
+        match event {
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            glutin::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
+            glutin::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
+
+            glutin::event::Event::WindowEvent { event, .. } => {
+                use glutin::event::WindowEvent;
+                if matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed) {
+                    *control_flow = glutin::event_loop::ControlFlow::Exit;
+                }
+
+                let event_response = egui_glium.on_event(&event);
+
+                if event_response.repaint {
+                    display.gl_window().window().request_redraw();
+                }
+            }
+            glutin::event::Event::NewEvents(glutin::event::StartCause::ResumeTimeReached {
+                ..
+            }) => {
+                display.gl_window().window().request_redraw();
+            }
+
+            _ => (),
+        }
+    });
+}
+
+fn create_display(event_loop: &glutin::event_loop::EventLoop<()>) -> glium::Display {
+    let window_builder = glutin::window::WindowBuilder::new()
+        .with_resizable(true)
+        .with_inner_size(glutin::dpi::LogicalSize {
+            width: 800.0,
+            height: 600.0,
+        })
+        .with_title("egui_glium example");
+
+    let context_builder = glutin::ContextBuilder::new()
+        .with_depth_buffer(0)
+        .with_stencil_buffer(0)
+        .with_vsync(true);
+
+    glium::Display::new(window_builder, context_builder, event_loop).unwrap()
+}
+
+fn load_glium_image(png_data: &[u8]) -> glium::texture::RawImage2d<'_, u8> {
+    // Load image using the image crate:
+    let image = image::load_from_memory(png_data).unwrap().to_rgba8();
+    let image_dimensions = image.dimensions();
+
+    // Premultiply alpha:
+    let pixels: Vec<_> = image
+        .into_vec()
+        .chunks_exact(4)
+        .map(|p| egui::Color32::from_rgba_unmultiplied(p[0], p[1], p[2], p[3]))
+        .flat_map(|color| color.to_array())
+        .collect();
+
+    // Convert to glium image:
+    glium::texture::RawImage2d::from_raw_rgba(pixels, image_dimensions)
+}
diff --git a/egui/crates/egui_glium/examples/pure_glium.rs b/egui/crates/egui_glium/examples/pure_glium.rs
new file mode 100644
index 0000000..dc7ad58
--- /dev/null
+++ b/egui/crates/egui_glium/examples/pure_glium.rs
@@ -0,0 +1,108 @@
+//! Example how to use `egui_glium`.
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use glium::glutin;
+
+fn main() {
+    let event_loop = glutin::event_loop::EventLoopBuilder::with_user_event().build();
+    let display = create_display(&event_loop);
+
+    let mut egui_glium = egui_glium::EguiGlium::new(&display, &event_loop);
+
+    let mut color_test = egui_demo_lib::ColorTest::default();
+
+    event_loop.run(move |event, _, control_flow| {
+        let mut redraw = || {
+            let mut quit = false;
+
+            let repaint_after = egui_glium.run(&display, |egui_ctx| {
+                egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
+                    ui.heading("Hello World!");
+                    if ui.button("Quit").clicked() {
+                        quit = true;
+                    }
+                });
+
+                egui::CentralPanel::default().show(egui_ctx, |ui| {
+                    egui::ScrollArea::vertical().show(ui, |ui| {
+                        color_test.ui(ui);
+                    });
+                });
+            });
+
+            *control_flow = if quit {
+                glutin::event_loop::ControlFlow::Exit
+            } else if repaint_after.is_zero() {
+                display.gl_window().window().request_redraw();
+                glutin::event_loop::ControlFlow::Poll
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                glutin::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
+            } else {
+                glutin::event_loop::ControlFlow::Wait
+            };
+
+            {
+                use glium::Surface as _;
+                let mut target = display.draw();
+
+                let color = egui::Rgba::from_rgb(0.1, 0.3, 0.2);
+                target.clear_color(color[0], color[1], color[2], color[3]);
+
+                // draw things behind egui here
+
+                egui_glium.paint(&display, &mut target);
+
+                // draw things on top of egui here
+
+                target.finish().unwrap();
+            }
+        };
+
+        match event {
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            glutin::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
+            glutin::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
+
+            glutin::event::Event::WindowEvent { event, .. } => {
+                use glutin::event::WindowEvent;
+                if matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed) {
+                    *control_flow = glutin::event_loop::ControlFlow::Exit;
+                }
+
+                let event_response = egui_glium.on_event(&event);
+
+                if event_response.repaint {
+                    display.gl_window().window().request_redraw();
+                }
+            }
+            glutin::event::Event::NewEvents(glutin::event::StartCause::ResumeTimeReached {
+                ..
+            }) => {
+                display.gl_window().window().request_redraw();
+            }
+            _ => (),
+        }
+    });
+}
+
+fn create_display(event_loop: &glutin::event_loop::EventLoop<()>) -> glium::Display {
+    let window_builder = glutin::window::WindowBuilder::new()
+        .with_resizable(true)
+        .with_inner_size(glutin::dpi::LogicalSize {
+            width: 800.0,
+            height: 600.0,
+        })
+        .with_title("egui_glium example");
+
+    let context_builder = glutin::ContextBuilder::new()
+        .with_depth_buffer(0)
+        .with_stencil_buffer(0)
+        .with_vsync(true);
+
+    glium::Display::new(window_builder, context_builder, event_loop).unwrap()
+}
diff --git a/egui/crates/egui_glium/src/lib.rs b/egui/crates/egui_glium/src/lib.rs
new file mode 100644
index 0000000..da60637
--- /dev/null
+++ b/egui/crates/egui_glium/src/lib.rs
@@ -0,0 +1,100 @@
+//! [`egui`] bindings for [`glium`](https://github.com/glium/glium).
+//!
+//! The main type you want to use is [`EguiGlium`].
+//!
+//! If you are writing an app, you may want to look at [`eframe`](https://docs.rs/eframe) instead.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![allow(clippy::manual_range_contains)]
+#![forbid(unsafe_code)]
+
+mod painter;
+pub use painter::Painter;
+
+pub use egui_winit;
+
+use egui_winit::winit::event_loop::EventLoopWindowTarget;
+pub use egui_winit::EventResponse;
+
+// ----------------------------------------------------------------------------
+
+/// Convenience wrapper for using [`egui`] from a [`glium`] app.
+pub struct EguiGlium {
+    pub egui_ctx: egui::Context,
+    pub egui_winit: egui_winit::State,
+    pub painter: crate::Painter,
+
+    shapes: Vec<egui::epaint::ClippedShape>,
+    textures_delta: egui::TexturesDelta,
+}
+
+impl EguiGlium {
+    pub fn new<E>(display: &glium::Display, event_loop: &EventLoopWindowTarget<E>) -> Self {
+        let painter = crate::Painter::new(display);
+
+        let mut egui_winit = egui_winit::State::new(event_loop);
+        egui_winit.set_max_texture_side(painter.max_texture_side());
+        let pixels_per_point = display.gl_window().window().scale_factor() as f32;
+        egui_winit.set_pixels_per_point(pixels_per_point);
+
+        Self {
+            egui_ctx: Default::default(),
+            egui_winit,
+            painter,
+            shapes: Default::default(),
+            textures_delta: Default::default(),
+        }
+    }
+
+    pub fn on_event(&mut self, event: &glium::glutin::event::WindowEvent<'_>) -> EventResponse {
+        self.egui_winit.on_event(&self.egui_ctx, event)
+    }
+
+    /// Returns `true` if egui requests a repaint.
+    ///
+    /// Call [`Self::paint`] later to paint.
+    pub fn run(
+        &mut self,
+        display: &glium::Display,
+        run_ui: impl FnMut(&egui::Context),
+    ) -> std::time::Duration {
+        let raw_input = self
+            .egui_winit
+            .take_egui_input(display.gl_window().window());
+        let egui::FullOutput {
+            platform_output,
+            repaint_after,
+            textures_delta,
+            shapes,
+        } = self.egui_ctx.run(raw_input, run_ui);
+
+        self.egui_winit.handle_platform_output(
+            display.gl_window().window(),
+            &self.egui_ctx,
+            platform_output,
+        );
+
+        self.shapes = shapes;
+        self.textures_delta.append(textures_delta);
+
+        repaint_after
+    }
+
+    /// Paint the results of the last call to [`Self::run`].
+    pub fn paint<T: glium::Surface>(&mut self, display: &glium::Display, target: &mut T) {
+        let shapes = std::mem::take(&mut self.shapes);
+        let textures_delta = std::mem::take(&mut self.textures_delta);
+        let clipped_primitives = self.egui_ctx.tessellate(shapes);
+        self.painter.paint_and_update_textures(
+            display,
+            target,
+            self.egui_ctx.pixels_per_point(),
+            &clipped_primitives,
+            &textures_delta,
+        );
+    }
+}
diff --git a/egui/crates/egui_glium/src/painter.rs b/egui/crates/egui_glium/src/painter.rs
new file mode 100644
index 0000000..39da163
--- /dev/null
+++ b/egui/crates/egui_glium/src/painter.rs
@@ -0,0 +1,381 @@
+#![allow(deprecated)] // legacy implement_vertex macro
+#![allow(semicolon_in_expressions_from_macros)] // glium::program! macro
+
+use egui::{
+    epaint::{textures::TextureFilter, Primitive},
+    TextureOptions,
+};
+
+use {
+    egui::{emath::Rect, epaint::Mesh},
+    glium::{
+        implement_vertex,
+        index::PrimitiveType,
+        texture::{self, srgb_texture2d::SrgbTexture2d},
+        uniform,
+        uniforms::{MagnifySamplerFilter, MinifySamplerFilter, SamplerWrapFunction},
+    },
+    std::rc::Rc,
+};
+
+pub struct Painter {
+    max_texture_side: usize,
+    program: glium::Program,
+
+    textures: ahash::HashMap<egui::TextureId, EguiTexture>,
+
+    /// [`egui::TextureId::User`] index
+    next_native_tex_id: u64,
+}
+
+fn create_program(
+    facade: &dyn glium::backend::Facade,
+    vertex_shader: &str,
+    fragment_shader: &str,
+) -> glium::program::Program {
+    let input = glium::program::ProgramCreationInput::SourceCode {
+        vertex_shader,
+        tessellation_control_shader: None,
+        tessellation_evaluation_shader: None,
+        geometry_shader: None,
+        fragment_shader,
+        transform_feedback_varyings: None,
+        outputs_srgb: true,
+        uses_point_size: false,
+    };
+
+    glium::program::Program::new(facade, input)
+        .unwrap_or_else(|err| panic!("Failed to compile shader: {}", err))
+}
+
+impl Painter {
+    pub fn new(facade: &dyn glium::backend::Facade) -> Painter {
+        use glium::CapabilitiesSource as _;
+        let max_texture_side = facade.get_capabilities().max_texture_size as _;
+
+        let program = if facade
+            .get_context()
+            .is_glsl_version_supported(&glium::Version(glium::Api::Gl, 1, 4))
+        {
+            eprintln!("Using GL 1.4");
+            create_program(
+                facade,
+                include_str!("shader/vertex_140.glsl"),
+                include_str!("shader/fragment_140.glsl"),
+            )
+        } else if facade
+            .get_context()
+            .is_glsl_version_supported(&glium::Version(glium::Api::Gl, 1, 2))
+        {
+            eprintln!("Using GL 1.2");
+            create_program(
+                facade,
+                include_str!("shader/vertex_120.glsl"),
+                include_str!("shader/fragment_120.glsl"),
+            )
+        } else if facade
+            .get_context()
+            .is_glsl_version_supported(&glium::Version(glium::Api::GlEs, 3, 0))
+        {
+            eprintln!("Using GL ES 3.0");
+            create_program(
+                facade,
+                include_str!("shader/vertex_300es.glsl"),
+                include_str!("shader/fragment_300es.glsl"),
+            )
+        } else if facade
+            .get_context()
+            .is_glsl_version_supported(&glium::Version(glium::Api::GlEs, 1, 0))
+        {
+            eprintln!("Using GL ES 1.0");
+            create_program(
+                facade,
+                include_str!("shader/vertex_100es.glsl"),
+                include_str!("shader/fragment_100es.glsl"),
+            )
+        } else {
+            panic!(
+                "Failed to find a compatible shader for OpenGL version {:?}",
+                facade.get_version()
+            )
+        };
+
+        Painter {
+            max_texture_side,
+            program,
+            textures: Default::default(),
+            next_native_tex_id: 0,
+        }
+    }
+
+    pub fn max_texture_side(&self) -> usize {
+        self.max_texture_side
+    }
+
+    pub fn paint_and_update_textures<T: glium::Surface>(
+        &mut self,
+        display: &glium::Display,
+        target: &mut T,
+        pixels_per_point: f32,
+        clipped_primitives: &[egui::ClippedPrimitive],
+        textures_delta: &egui::TexturesDelta,
+    ) {
+        for (id, image_delta) in &textures_delta.set {
+            self.set_texture(display, *id, image_delta);
+        }
+
+        self.paint_primitives(display, target, pixels_per_point, clipped_primitives);
+
+        for &id in &textures_delta.free {
+            self.free_texture(id);
+        }
+    }
+
+    /// Main entry-point for painting a frame.
+    /// You should call `target.clear_color(..)` before
+    /// and `target.finish()` after this.
+    pub fn paint_primitives<T: glium::Surface>(
+        &mut self,
+        display: &glium::Display,
+        target: &mut T,
+        pixels_per_point: f32,
+        clipped_primitives: &[egui::ClippedPrimitive],
+    ) {
+        for egui::ClippedPrimitive {
+            clip_rect,
+            primitive,
+        } in clipped_primitives
+        {
+            match primitive {
+                Primitive::Mesh(mesh) => {
+                    self.paint_mesh(target, display, pixels_per_point, clip_rect, mesh);
+                }
+                Primitive::Callback(_) => {
+                    panic!("Custom rendering callbacks are not implemented in egui_glium");
+                }
+            }
+        }
+    }
+
+    #[inline(never)] // Easier profiling
+    fn paint_mesh<T: glium::Surface>(
+        &mut self,
+        target: &mut T,
+        display: &glium::Display,
+        pixels_per_point: f32,
+        clip_rect: &Rect,
+        mesh: &Mesh,
+    ) {
+        debug_assert!(mesh.is_valid());
+
+        let vertex_buffer = {
+            #[repr(C)]
+            #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+            struct Vertex {
+                a_pos: [f32; 2],
+                a_tc: [f32; 2],
+                a_srgba: [u8; 4],
+            }
+            implement_vertex!(Vertex, a_pos, a_tc, a_srgba);
+
+            let vertices: &[Vertex] = bytemuck::cast_slice(&mesh.vertices);
+
+            // TODO(emilk): we should probably reuse the [`VertexBuffer`] instead of allocating a new one each frame.
+            glium::VertexBuffer::new(display, vertices).unwrap()
+        };
+
+        // TODO(emilk): we should probably reuse the [`IndexBuffer`] instead of allocating a new one each frame.
+        let index_buffer =
+            glium::IndexBuffer::new(display, PrimitiveType::TrianglesList, &mesh.indices).unwrap();
+
+        let (width_in_pixels, height_in_pixels) = display.get_framebuffer_dimensions();
+        let width_in_points = width_in_pixels as f32 / pixels_per_point;
+        let height_in_points = height_in_pixels as f32 / pixels_per_point;
+
+        if let Some(texture) = self.texture(mesh.texture_id) {
+            // The texture coordinates for text are so that both nearest and linear should work with the egui font texture.
+            let mag_filter = match texture.options.magnification {
+                TextureFilter::Nearest => MagnifySamplerFilter::Nearest,
+                TextureFilter::Linear => MagnifySamplerFilter::Linear,
+            };
+            let min_filter = match texture.options.minification {
+                TextureFilter::Nearest => MinifySamplerFilter::Nearest,
+                TextureFilter::Linear => MinifySamplerFilter::Linear,
+            };
+
+            let sampler = texture
+                .glium_texture
+                .sampled()
+                .magnify_filter(mag_filter)
+                .minify_filter(min_filter)
+                .wrap_function(SamplerWrapFunction::Clamp);
+
+            let uniforms = uniform! {
+                u_screen_size: [width_in_points, height_in_points],
+                u_sampler: sampler,
+            };
+
+            // egui outputs colors with premultiplied alpha:
+            let color_blend_func = glium::BlendingFunction::Addition {
+                source: glium::LinearBlendingFactor::One,
+                destination: glium::LinearBlendingFactor::OneMinusSourceAlpha,
+            };
+
+            // Less important, but this is technically the correct alpha blend function
+            // when you want to make use of the framebuffer alpha (for screenshots, compositing, etc).
+            let alpha_blend_func = glium::BlendingFunction::Addition {
+                source: glium::LinearBlendingFactor::OneMinusDestinationAlpha,
+                destination: glium::LinearBlendingFactor::One,
+            };
+
+            let blend = glium::Blend {
+                color: color_blend_func,
+                alpha: alpha_blend_func,
+                ..Default::default()
+            };
+
+            // egui outputs mesh in both winding orders:
+            let backface_culling = glium::BackfaceCullingMode::CullingDisabled;
+
+            // Transform clip rect to physical pixels:
+            let clip_min_x = pixels_per_point * clip_rect.min.x;
+            let clip_min_y = pixels_per_point * clip_rect.min.y;
+            let clip_max_x = pixels_per_point * clip_rect.max.x;
+            let clip_max_y = pixels_per_point * clip_rect.max.y;
+
+            // Make sure clip rect can fit within a `u32`:
+            let clip_min_x = clip_min_x.clamp(0.0, width_in_pixels as f32);
+            let clip_min_y = clip_min_y.clamp(0.0, height_in_pixels as f32);
+            let clip_max_x = clip_max_x.clamp(clip_min_x, width_in_pixels as f32);
+            let clip_max_y = clip_max_y.clamp(clip_min_y, height_in_pixels as f32);
+
+            let clip_min_x = clip_min_x.round() as u32;
+            let clip_min_y = clip_min_y.round() as u32;
+            let clip_max_x = clip_max_x.round() as u32;
+            let clip_max_y = clip_max_y.round() as u32;
+
+            let params = glium::DrawParameters {
+                blend,
+                backface_culling,
+                scissor: Some(glium::Rect {
+                    left: clip_min_x,
+                    bottom: height_in_pixels - clip_max_y,
+                    width: clip_max_x - clip_min_x,
+                    height: clip_max_y - clip_min_y,
+                }),
+                ..Default::default()
+            };
+
+            target
+                .draw(
+                    &vertex_buffer,
+                    &index_buffer,
+                    &self.program,
+                    &uniforms,
+                    &params,
+                )
+                .unwrap();
+        }
+    }
+
+    // ------------------------------------------------------------------------
+
+    pub fn set_texture(
+        &mut self,
+        facade: &dyn glium::backend::Facade,
+        tex_id: egui::TextureId,
+        delta: &egui::epaint::ImageDelta,
+    ) {
+        let pixels: Vec<(u8, u8, u8, u8)> = match &delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+                image.pixels.iter().map(|color| color.to_tuple()).collect()
+            }
+            egui::ImageData::Font(image) => image
+                .srgba_pixels(None)
+                .map(|color| color.to_tuple())
+                .collect(),
+        };
+        let glium_image = glium::texture::RawImage2d {
+            data: std::borrow::Cow::Owned(pixels),
+            width: delta.image.width() as _,
+            height: delta.image.height() as _,
+            format: glium::texture::ClientFormat::U8U8U8U8,
+        };
+        let format = texture::SrgbFormat::U8U8U8U8;
+        let mipmaps = texture::MipmapsOption::NoMipmap;
+
+        if let Some(pos) = delta.pos {
+            // update a sub-region
+            if let Some(user_texture) = self.textures.get_mut(&tex_id) {
+                let rect = glium::Rect {
+                    left: pos[0] as _,
+                    bottom: pos[1] as _,
+                    width: glium_image.width,
+                    height: glium_image.height,
+                };
+                user_texture
+                    .glium_texture
+                    .main_level()
+                    .write(rect, glium_image);
+
+                user_texture.options = delta.options;
+            }
+        } else {
+            let gl_texture =
+                SrgbTexture2d::with_format(facade, glium_image, format, mipmaps).unwrap();
+
+            let user_texture = EguiTexture::new(gl_texture.into(), delta.options);
+            self.textures.insert(tex_id, user_texture);
+        }
+    }
+
+    pub fn free_texture(&mut self, tex_id: egui::TextureId) {
+        self.textures.remove(&tex_id);
+    }
+
+    fn texture(&self, texture_id: egui::TextureId) -> Option<&EguiTexture> {
+        self.textures.get(&texture_id)
+    }
+
+    pub fn register_native_texture(
+        &mut self,
+        native: Rc<SrgbTexture2d>,
+        options: TextureOptions,
+    ) -> egui::TextureId {
+        let id = egui::TextureId::User(self.next_native_tex_id);
+        self.next_native_tex_id += 1;
+
+        let texture = EguiTexture::new(native, options);
+        self.textures.insert(id, texture);
+        id
+    }
+
+    pub fn replace_native_texture(
+        &mut self,
+        id: egui::TextureId,
+        replacing: Rc<SrgbTexture2d>,
+        options: TextureOptions,
+    ) {
+        let texture = EguiTexture::new(replacing, options);
+        self.textures.insert(id, texture);
+    }
+}
+
+struct EguiTexture {
+    glium_texture: Rc<SrgbTexture2d>,
+    options: TextureOptions,
+}
+
+impl EguiTexture {
+    fn new(glium_texture: Rc<SrgbTexture2d>, options: TextureOptions) -> Self {
+        Self {
+            glium_texture,
+            options,
+        }
+    }
+}
diff --git a/egui/crates/egui_glium/src/shader/fragment_100es.glsl b/egui/crates/egui_glium/src/shader/fragment_100es.glsl
new file mode 100644
index 0000000..912f47f
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/fragment_100es.glsl
@@ -0,0 +1,38 @@
+#version 100
+
+precision mediump float;
+uniform sampler2D u_sampler;
+varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
+varying vec2 v_tc;
+
+// 0-255 sRGB  from  0-1 linear
+vec3 srgb_from_linear(vec3 rgb) {
+    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
+    vec3 lower = rgb * vec3(3294.6);
+    vec3 higher = vec3(269.025) * pow(rgb, vec3(1.0 / 2.4)) - vec3(14.025);
+    return mix(higher, lower, vec3(cutoff));
+}
+
+vec4 srgba_from_linear(vec4 rgba) {
+    return vec4(srgb_from_linear(rgba.rgb), 255.0 * rgba.a);
+}
+
+// 0-1 linear  from  0-255 sRGB
+vec3 linear_from_srgb(vec3 srgb) {
+    bvec3 cutoff = lessThan(srgb, vec3(10.31475));
+    vec3 lower = srgb / vec3(3294.6);
+    vec3 higher = pow((srgb + vec3(14.025)) / vec3(269.025), vec3(2.4));
+    return mix(higher, lower, vec3(cutoff));
+}
+
+vec4 linear_from_srgba(vec4 srgba) {
+    return vec4(linear_from_srgb(srgba.rgb), srgba.a / 255.0);
+}
+
+void main() {
+    // WebGL doesn't come with sRGBA textures:
+    vec4 texture_in_gamma = texture2D(u_sampler, v_tc);
+
+    // Multiply vertex color with texture color (in gamma space).
+    gl_FragColor = v_rgba_gamma * texture_in_gamma;
+}
diff --git a/egui/crates/egui_glium/src/shader/fragment_120.glsl b/egui/crates/egui_glium/src/shader/fragment_120.glsl
new file mode 100644
index 0000000..e697278
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/fragment_120.glsl
@@ -0,0 +1,31 @@
+#version 120
+
+uniform sampler2D u_sampler;
+varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
+varying vec2 v_tc;
+
+// 0-255 sRGB  from  0-1 linear
+vec3 srgb_from_linear(vec3 rgb) {
+    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
+    vec3 lower = rgb * vec3(3294.6);
+    vec3 higher = vec3(269.025) * pow(rgb, vec3(1.0 / 2.4)) - vec3(14.025);
+    return mix(higher, lower, vec3(cutoff));
+}
+
+// 0-255 sRGBA  from  0-1 linear
+vec4 srgba_from_linear(vec4 rgba) {
+    return vec4(srgb_from_linear(rgba.rgb), 255.0 * rgba.a);
+}
+
+// 0-1 gamma  from  0-1 linear
+vec4 gamma_from_linear_rgba(vec4 linear_rgba) {
+    return vec4(srgb_from_linear(linear_rgba.rgb) / 255.0, linear_rgba.a);
+}
+
+void main() {
+    // The texture is set up with `SRGB8_ALPHA8`
+    vec4 texture_in_gamma = gamma_from_linear_rgba(texture2D(u_sampler, v_tc));
+
+    // Multiply vertex color with texture color (in gamma space).
+    gl_FragColor = v_rgba_gamma * texture_in_gamma;
+}
diff --git a/egui/crates/egui_glium/src/shader/fragment_140.glsl b/egui/crates/egui_glium/src/shader/fragment_140.glsl
new file mode 100644
index 0000000..4db357f
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/fragment_140.glsl
@@ -0,0 +1,32 @@
+#version 140
+
+uniform sampler2D u_sampler;
+in vec4 v_rgba_gamma;
+in vec2 v_tc;
+out vec4 f_color;
+
+// 0-255 sRGB  from  0-1 linear
+vec3 srgb_from_linear(vec3 rgb) {
+    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
+    vec3 lower = rgb * vec3(3294.6);
+    vec3 higher = vec3(269.025) * pow(rgb, vec3(1.0 / 2.4)) - vec3(14.025);
+    return mix(higher, lower, vec3(cutoff));
+}
+
+// 0-255 sRGBA  from  0-1 linear
+vec4 srgba_from_linear(vec4 rgba) {
+    return vec4(srgb_from_linear(rgba.rgb), 255.0 * rgba.a);
+}
+
+// 0-1 gamma  from  0-1 linear
+vec4 gamma_from_linear_rgba(vec4 linear_rgba) {
+    return vec4(srgb_from_linear(linear_rgba.rgb) / 255.0, linear_rgba.a);
+}
+
+void main() {
+    // The texture is set up with `SRGB8_ALPHA8`
+    vec4 texture_in_gamma = gamma_from_linear_rgba(texture(u_sampler, v_tc));
+
+    // Multiply vertex color with texture color (in gamma space).
+    f_color = v_rgba_gamma * texture_in_gamma;
+}
diff --git a/egui/crates/egui_glium/src/shader/fragment_300es.glsl b/egui/crates/egui_glium/src/shader/fragment_300es.glsl
new file mode 100644
index 0000000..8d47861
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/fragment_300es.glsl
@@ -0,0 +1,32 @@
+#version 300 es
+
+precision mediump float;
+uniform sampler2D u_sampler;
+varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
+varying vec2 v_tc;
+
+// 0-255 sRGB  from  0-1 linear
+vec3 srgb_from_linear(vec3 rgb) {
+    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
+    vec3 lower = rgb * vec3(3294.6);
+    vec3 higher = vec3(269.025) * pow(rgb, vec3(1.0 / 2.4)) - vec3(14.025);
+    return mix(higher, lower, vec3(cutoff));
+}
+
+// 0-255 sRGBA  from  0-1 linear
+vec4 srgba_from_linear(vec4 rgba) {
+    return vec4(srgb_from_linear(rgba.rgb), 255.0 * rgba.a);
+}
+
+// 0-1 gamma  from  0-1 linear
+vec4 gamma_from_linear_rgba(vec4 linear_rgba) {
+    return vec4(srgb_from_linear(linear_rgba.rgb) / 255.0, linear_rgba.a);
+}
+
+void main() {
+    // The texture is set up with `SRGB8_ALPHA8`
+    vec4 texture_in_gamma = gamma_from_linear_rgba(texture2D(u_sampler, v_tc));
+
+    // Multiply vertex color with texture color (in gamma space).
+    gl_FragColor = v_rgba_gamma * texture_in_gamma;
+}
diff --git a/egui/crates/egui_glium/src/shader/vertex_100es.glsl b/egui/crates/egui_glium/src/shader/vertex_100es.glsl
new file mode 100644
index 0000000..4cc4813
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/vertex_100es.glsl
@@ -0,0 +1,19 @@
+#version 100
+
+precision mediump float;
+uniform vec2 u_screen_size;
+attribute vec2 a_pos;
+attribute vec2 a_tc;
+attribute vec4 a_srgba;
+varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
+varying vec2 v_tc;
+
+void main() {
+    gl_Position = vec4(
+                      2.0 * a_pos.x / u_screen_size.x - 1.0,
+                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
+                      0.0,
+                      1.0);
+    v_rgba_gamma = a_srgba / 255.0;
+    v_tc = a_tc;
+}
diff --git a/egui/crates/egui_glium/src/shader/vertex_120.glsl b/egui/crates/egui_glium/src/shader/vertex_120.glsl
new file mode 100644
index 0000000..2f1a032
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/vertex_120.glsl
@@ -0,0 +1,18 @@
+#version 120
+
+uniform vec2 u_screen_size;
+attribute vec2 a_pos;
+attribute vec4 a_srgba; // 0-255 sRGB
+attribute vec2 a_tc;
+varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
+varying vec2 v_tc;
+
+void main() {
+    gl_Position = vec4(
+                      2.0 * a_pos.x / u_screen_size.x - 1.0,
+                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
+                      0.0,
+                      1.0);
+    v_rgba_gamma = a_srgba / 255.0;
+    v_tc = a_tc;
+}
diff --git a/egui/crates/egui_glium/src/shader/vertex_140.glsl b/egui/crates/egui_glium/src/shader/vertex_140.glsl
new file mode 100644
index 0000000..03d0a8d
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/vertex_140.glsl
@@ -0,0 +1,18 @@
+#version 140
+
+uniform vec2 u_screen_size;
+in vec2 a_pos;
+in vec4 a_srgba; // 0-255 sRGB
+in vec2 a_tc;
+out vec4 v_rgba_gamma;
+out vec2 v_tc;
+
+void main() {
+    gl_Position = vec4(
+                      2.0 * a_pos.x / u_screen_size.x - 1.0,
+                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
+                      0.0,
+                      1.0);
+    v_rgba_gamma = a_srgba / 255.0;
+    v_tc = a_tc;
+}
diff --git a/egui/crates/egui_glium/src/shader/vertex_300es.glsl b/egui/crates/egui_glium/src/shader/vertex_300es.glsl
new file mode 100644
index 0000000..60fdac1
--- /dev/null
+++ b/egui/crates/egui_glium/src/shader/vertex_300es.glsl
@@ -0,0 +1,19 @@
+#version 300 es
+
+precision mediump float;
+uniform vec2 u_screen_size;
+attribute vec2 a_pos;
+attribute vec2 a_tc;
+attribute vec4 a_srgba;
+varying vec4 v_rgba_gamma; // 0-1 gamma sRGBA
+varying vec2 v_tc;
+
+void main() {
+    gl_Position = vec4(
+                      2.0 * a_pos.x / u_screen_size.x - 1.0,
+                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
+                      0.0,
+                      1.0);
+    v_rgba_gamma = a_srgba / 255.0;
+    v_tc = a_tc;
+}
diff --git a/egui/crates/egui_glow/CHANGELOG.md b/egui/crates/egui_glow/CHANGELOG.md
new file mode 100644
index 0000000..cde992f
--- /dev/null
+++ b/egui/crates/egui_glow/CHANGELOG.md
@@ -0,0 +1,64 @@
+# Changelog for egui_glow
+All notable changes to the `egui_glow` integration will be noted in this file.
+
+
+## Unreleased
+
+
+## 0.21.0 - 2023-02-08
+* Update to `glow` 0.12 ([#2695](https://github.com/emilk/egui/pull/2695)).
+* Remove the `screen_reader` feature ([#2669](https://github.com/emilk/egui/pull/2669)).
+
+
+## 0.20.1 - 2022-12-11
+* Fix [docs.rs](https://docs.rs/egui_glow) build ([#2420](https://github.com/emilk/egui/pull/2420)).
+
+
+## 0.20.0 - 2022-12-08
+* Allow empty textures.
+* Added `shader_version` variable on `EguiGlow::new` for easier cross compiling on different OpenGL | ES targets ([#1993](https://github.com/emilk/egui/pull/1993)).
+
+
+## 0.19.0 - 2022-08-20
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* `EguiGlow::new` now takes an `EventLoopWindowTarget<E>` instead of a `winit::Window` ([#1634](https://github.com/emilk/egui/pull/1634)).
+* Use `Arc` for `glow::Context` instead of `Rc` ([#1640](https://github.com/emilk/egui/pull/1640)).
+* Fixed `glClear` on WebGL1 ([#1658](https://github.com/emilk/egui/pull/1658)).
+* Add `Painter::intermediate_fbo` which tells callbacks where to render. This is only needed if the callbacks use their own FBO:s and need to know what to restore to.
+
+
+## 0.18.1 - 2022-05-05
+* Remove calls to `gl.get_error` in release builds to speed up rendering ([#1583](https://github.com/emilk/egui/pull/1583)).
+
+
+## 0.18.0 - 2022-04-30
+* Improved logging on rendering failures.
+* Added new `NativeOptions`: `vsync`, `multisampling`, `depth_buffer`, `stencil_buffer`.
+* Fixed potential scale bug when DPI scaling changes (e.g. when dragging a  window between different displays) ([#1441](https://github.com/emilk/egui/pull/1441)).
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* `clipboard`, `links`, `winit` are now all opt-in features ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Added new feature `puffin` to add [`puffin profiler`](https://github.com/EmbarkStudios/puffin) scopes ([#1483](https://github.com/emilk/egui/pull/1483)).
+* Removed the features `dark-light`, `default_fonts` and `persistence` ([#1542](https://github.com/emilk/egui/pull/1542)).
+
+
+## 0.17.0 - 2022-02-22
+* `EguiGlow::run` no longer returns the shapes to paint, but stores them internally until you call `EguiGlow::paint` ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Added `set_texture_filter` method to `Painter` ([#1041](https://github.com/emilk/egui/pull/1041)).
+* Fixed failure to run in Chrome ([#1092](https://github.com/emilk/egui/pull/1092)).
+* `EguiGlow::new` and `EguiGlow::paint` now takes `&winit::Window` ([#1151](https://github.com/emilk/egui/pull/1151)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+
+
+## 0.16.0 - 2021-12-29
+* Made winit/glutin an optional dependency ([#868](https://github.com/emilk/egui/pull/868)).
+* Simplified `EguiGlow` interface ([#871](https://github.com/emilk/egui/pull/871)).
+* Removed `EguiGlow::is_quit_event` ([#881](https://github.com/emilk/egui/pull/881)).
+* Updated `glutin` to 0.28 ([#930](https://github.com/emilk/egui/pull/930)).
+* Changed the `Painter` interface slightly ([#999](https://github.com/emilk/egui/pull/999)).
+
+
+## 0.15.0 - 2021-10-24
+`egui_glow` has been newly created, with feature parity to `egui_glium`.
+
+As `glow` is a set of lower-level bindings to OpenGL, this crate is potentially less stable than `egui_glium`,
+but hopefully this will one day replace `egui_glium` as the default backend for `eframe`.
diff --git a/egui/crates/egui_glow/Cargo.toml b/egui/crates/egui_glow/Cargo.toml
new file mode 100644
index 0000000..800f114
--- /dev/null
+++ b/egui/crates/egui_glow/Cargo.toml
@@ -0,0 +1,79 @@
+[package]
+name = "egui_glow"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "Bindings for using egui natively using the glow library"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/egui_glow"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/egui_glow"
+categories = ["gui", "game-development"]
+keywords = ["glow", "egui", "gui", "gamedev"]
+include = [
+  "../LICENSE-APACHE",
+  "../LICENSE-MIT",
+  "**/*.rs",
+  "Cargo.toml",
+  "src/shader/*.glsl",
+]
+
+[package.metadata.docs.rs]
+all-features = true
+
+
+[features]
+default = []
+
+## For the `winit` integration:
+## enable cut/copy/paste to os clipboard.
+##
+## if disabled a clipboard will be simulated so you can still copy/paste within the egui app.
+clipboard = ["egui-winit?/clipboard"]
+
+## For the `winit` integration:
+## enable opening links in a browser when an egui hyperlink is clicked.
+links = ["egui-winit?/links"]
+
+## Enable profiling with the [`puffin`](https://docs.rs/puffin) crate.
+puffin = ["dep:puffin", "egui-winit?/puffin"]
+
+## Enable [`winit`](https://docs.rs/winit) integration.
+winit = ["egui-winit"]
+
+
+[dependencies]
+egui = { version = "0.21.0", path = "../egui", default-features = false, features = [
+  "bytemuck",
+] }
+
+bytemuck = "1.7"
+glow = "0.12"
+memoffset = "0.6"
+tracing = { version = "0.1", default-features = false, features = ["std"] }
+
+#! ### Optional dependencies
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+# Native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+egui-winit = { version = "0.21.1", path = "../egui-winit", optional = true, default-features = false }
+puffin = { version = "0.14", optional = true }
+
+# Web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+web-sys = { version = "0.3", features = ["console"] }
+wasm-bindgen = { version = "0.2" }
+
+
+[dev-dependencies]
+glutin = "0.30"             # examples/pure_glow
+raw-window-handle = "0.5.0"
+glutin-winit = "0.3.0"
+
+
+[[example]]
+name = "pure_glow"
+required-features = ["winit", "egui/default_fonts"]
diff --git a/egui/crates/egui_glow/README.md b/egui/crates/egui_glow/README.md
new file mode 100644
index 0000000..93797d8
--- /dev/null
+++ b/egui/crates/egui_glow/README.md
@@ -0,0 +1,26 @@
+# egui_glow
+
+[![Latest version](https://img.shields.io/crates/v/egui_glow.svg)](https://crates.io/crates/egui_glow)
+[![Documentation](https://docs.rs/egui_glow/badge.svg)](https://docs.rs/egui_glow)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [glow](https://crates.io/crates/glow) which allows you to:
+* Render egui using glow on both native and web.
+* Write cross platform native egui apps (with the `winit` feature).
+
+To write web apps using `glow` you can use [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) (which uses `egui_glow` for rendering).
+
+To use on Linux, first run:
+
+```
+sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev
+```
+
+This crate optionally depends on [`egui-winit`](https://github.com/emilk/egui/tree/master/crates/egui-winit).
+
+Text the example with:
+
+``` sh
+cargo run -p egui_glow --example pure_glow --features=winit,egui/default_fonts
+```
diff --git a/egui/crates/egui_glow/examples/pure_glow.rs b/egui/crates/egui_glow/examples/pure_glow.rs
new file mode 100644
index 0000000..574e237
--- /dev/null
+++ b/egui/crates/egui_glow/examples/pure_glow.rs
@@ -0,0 +1,255 @@
+//! Example how to use pure `egui_glow`.
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+#![allow(unsafe_code)]
+
+use egui_winit::winit;
+
+/// The majority of `GlutinWindowContext` is taken from `eframe`
+struct GlutinWindowContext {
+    window: winit::window::Window,
+    gl_context: glutin::context::PossiblyCurrentContext,
+    gl_display: glutin::display::Display,
+    gl_surface: glutin::surface::Surface<glutin::surface::WindowSurface>,
+}
+
+impl GlutinWindowContext {
+    // refactor this function to use `glutin-winit` crate eventually.
+    // preferably add android support at the same time.
+    #[allow(unsafe_code)]
+    unsafe fn new(event_loop: &winit::event_loop::EventLoopWindowTarget<()>) -> Self {
+        use egui::NumExt;
+        use glutin::context::NotCurrentGlContextSurfaceAccessor;
+        use glutin::display::GetGlDisplay;
+        use glutin::display::GlDisplay;
+        use glutin::prelude::GlSurface;
+        use raw_window_handle::HasRawWindowHandle;
+        let winit_window_builder = winit::window::WindowBuilder::new()
+            .with_resizable(true)
+            .with_inner_size(winit::dpi::LogicalSize {
+                width: 800.0,
+                height: 600.0,
+            })
+            .with_title("egui_glow example") // Keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
+            .with_visible(false);
+
+        let config_template_builder = glutin::config::ConfigTemplateBuilder::new()
+            .prefer_hardware_accelerated(None)
+            .with_depth_size(0)
+            .with_stencil_size(0)
+            .with_transparency(false);
+
+        tracing::debug!("trying to get gl_config");
+        let (mut window, gl_config) =
+            glutin_winit::DisplayBuilder::new() // let glutin-winit helper crate handle the complex parts of opengl context creation
+                .with_preference(glutin_winit::ApiPrefence::FallbackEgl) // https://github.com/emilk/egui/issues/2520#issuecomment-1367841150
+                .with_window_builder(Some(winit_window_builder.clone()))
+                .build(
+                    event_loop,
+                    config_template_builder,
+                    |mut config_iterator| {
+                        config_iterator.next().expect(
+                            "failed to find a matching configuration for creating glutin config",
+                        )
+                    },
+                )
+                .expect("failed to create gl_config");
+        let gl_display = gl_config.display();
+        tracing::debug!("found gl_config: {:?}", &gl_config);
+
+        let raw_window_handle = window.as_ref().map(|w| w.raw_window_handle());
+        tracing::debug!("raw window handle: {:?}", raw_window_handle);
+        let context_attributes =
+            glutin::context::ContextAttributesBuilder::new().build(raw_window_handle);
+        // by default, glutin will try to create a core opengl context. but, if it is not available, try to create a gl-es context using this fallback attributes
+        let fallback_context_attributes = glutin::context::ContextAttributesBuilder::new()
+            .with_context_api(glutin::context::ContextApi::Gles(None))
+            .build(raw_window_handle);
+        let not_current_gl_context = unsafe {
+            gl_display
+                    .create_context(&gl_config, &context_attributes)
+                    .unwrap_or_else(|_| {
+                        tracing::debug!("failed to create gl_context with attributes: {:?}. retrying with fallback context attributes: {:?}",
+                            &context_attributes,
+                            &fallback_context_attributes);
+                        gl_config
+                            .display()
+                            .create_context(&gl_config, &fallback_context_attributes)
+                            .expect("failed to create context even with fallback attributes")
+                    })
+        };
+
+        // this is where the window is created, if it has not been created while searching for suitable gl_config
+        let window = window.take().unwrap_or_else(|| {
+            tracing::debug!("window doesn't exist yet. creating one now with finalize_window");
+            glutin_winit::finalize_window(event_loop, winit_window_builder.clone(), &gl_config)
+                .expect("failed to finalize glutin window")
+        });
+        let (width, height): (u32, u32) = window.inner_size().into();
+        let width = std::num::NonZeroU32::new(width.at_least(1)).unwrap();
+        let height = std::num::NonZeroU32::new(height.at_least(1)).unwrap();
+        let surface_attributes =
+            glutin::surface::SurfaceAttributesBuilder::<glutin::surface::WindowSurface>::new()
+                .build(window.raw_window_handle(), width, height);
+        tracing::debug!(
+            "creating surface with attributes: {:?}",
+            &surface_attributes
+        );
+        let gl_surface = unsafe {
+            gl_display
+                .create_window_surface(&gl_config, &surface_attributes)
+                .unwrap()
+        };
+        tracing::debug!("surface created successfully: {gl_surface:?}.making context current");
+        let gl_context = not_current_gl_context.make_current(&gl_surface).unwrap();
+
+        gl_surface
+            .set_swap_interval(
+                &gl_context,
+                glutin::surface::SwapInterval::Wait(std::num::NonZeroU32::new(1).unwrap()),
+            )
+            .unwrap();
+
+        GlutinWindowContext {
+            window,
+            gl_context,
+            gl_display,
+            gl_surface,
+        }
+    }
+
+    fn window(&self) -> &winit::window::Window {
+        &self.window
+    }
+
+    fn resize(&self, physical_size: winit::dpi::PhysicalSize<u32>) {
+        use glutin::surface::GlSurface;
+        self.gl_surface.resize(
+            &self.gl_context,
+            physical_size.width.try_into().unwrap(),
+            physical_size.height.try_into().unwrap(),
+        );
+    }
+
+    fn swap_buffers(&self) -> glutin::error::Result<()> {
+        use glutin::surface::GlSurface;
+        self.gl_surface.swap_buffers(&self.gl_context)
+    }
+
+    fn get_proc_address(&self, addr: &std::ffi::CStr) -> *const std::ffi::c_void {
+        use glutin::display::GlDisplay;
+        self.gl_display.get_proc_address(addr)
+    }
+}
+
+fn main() {
+    let mut clear_color = [0.1, 0.1, 0.1];
+
+    let event_loop = winit::event_loop::EventLoopBuilder::with_user_event().build();
+    let (gl_window, gl) = create_display(&event_loop);
+    let gl = std::sync::Arc::new(gl);
+
+    let mut egui_glow = egui_glow::EguiGlow::new(&event_loop, gl.clone(), None);
+
+    event_loop.run(move |event, _, control_flow| {
+        let mut redraw = || {
+            let mut quit = false;
+
+            let repaint_after = egui_glow.run(gl_window.window(), |egui_ctx| {
+                egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
+                    ui.heading("Hello World!");
+                    if ui.button("Quit").clicked() {
+                        quit = true;
+                    }
+                    ui.color_edit_button_rgb(&mut clear_color);
+                });
+            });
+
+            *control_flow = if quit {
+                winit::event_loop::ControlFlow::Exit
+            } else if repaint_after.is_zero() {
+                gl_window.window().request_redraw();
+                winit::event_loop::ControlFlow::Poll
+            } else if let Some(repaint_after_instant) =
+                std::time::Instant::now().checked_add(repaint_after)
+            {
+                winit::event_loop::ControlFlow::WaitUntil(repaint_after_instant)
+            } else {
+                winit::event_loop::ControlFlow::Wait
+            };
+
+            {
+                unsafe {
+                    use glow::HasContext as _;
+                    gl.clear_color(clear_color[0], clear_color[1], clear_color[2], 1.0);
+                    gl.clear(glow::COLOR_BUFFER_BIT);
+                }
+
+                // draw things behind egui here
+
+                egui_glow.paint(gl_window.window());
+
+                // draw things on top of egui here
+
+                gl_window.swap_buffers().unwrap();
+                gl_window.window().set_visible(true);
+            }
+        };
+
+        match event {
+            // Platform-dependent event handlers to workaround a winit bug
+            // See: https://github.com/rust-windowing/winit/issues/987
+            // See: https://github.com/rust-windowing/winit/issues/1619
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
+
+            winit::event::Event::WindowEvent { event, .. } => {
+                use winit::event::WindowEvent;
+                if matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed) {
+                    *control_flow = winit::event_loop::ControlFlow::Exit;
+                }
+
+                if let winit::event::WindowEvent::Resized(physical_size) = &event {
+                    gl_window.resize(*physical_size);
+                } else if let winit::event::WindowEvent::ScaleFactorChanged {
+                    new_inner_size, ..
+                } = &event
+                {
+                    gl_window.resize(**new_inner_size);
+                }
+
+                let event_response = egui_glow.on_event(&event);
+
+                if event_response.repaint {
+                    gl_window.window().request_redraw();
+                }
+            }
+            winit::event::Event::LoopDestroyed => {
+                egui_glow.destroy();
+            }
+            winit::event::Event::NewEvents(winit::event::StartCause::ResumeTimeReached {
+                ..
+            }) => {
+                gl_window.window().request_redraw();
+            }
+
+            _ => (),
+        }
+    });
+}
+
+fn create_display(
+    event_loop: &winit::event_loop::EventLoopWindowTarget<()>,
+) -> (GlutinWindowContext, glow::Context) {
+    let glutin_window_context = unsafe { GlutinWindowContext::new(event_loop) };
+    let gl = unsafe {
+        glow::Context::from_loader_function(|s| {
+            let s = std::ffi::CString::new(s)
+                .expect("failed to construct C string from string for gl proc address");
+
+            glutin_window_context.get_proc_address(&s)
+        })
+    };
+
+    (glutin_window_context, gl)
+}
diff --git a/egui/crates/egui_glow/src/lib.rs b/egui/crates/egui_glow/src/lib.rs
new file mode 100644
index 0000000..bc149a0
--- /dev/null
+++ b/egui/crates/egui_glow/src/lib.rs
@@ -0,0 +1,133 @@
+//! [`egui`] bindings for [`glow`](https://github.com/grovesNL/glow).
+//!
+//! The main types you want to look are are [`Painter`] and [`EguiGlow`].
+//!
+//! If you are writing an app, you may want to look at [`eframe`](https://docs.rs/eframe) instead.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![allow(clippy::manual_range_contains)]
+
+pub mod painter;
+pub use glow;
+pub use painter::{CallbackFn, Painter};
+mod misc_util;
+mod shader_version;
+mod vao;
+
+pub use shader_version::ShaderVersion;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "winit"))]
+pub mod winit;
+#[cfg(all(not(target_arch = "wasm32"), feature = "winit"))]
+pub use winit::*;
+
+/// Check for OpenGL error and report it using `tracing::error`.
+///
+/// Only active in debug builds!
+///
+/// ``` no_run
+/// # let glow_context = todo!();
+/// use egui_glow::check_for_gl_error;
+/// check_for_gl_error!(glow_context);
+/// check_for_gl_error!(glow_context, "during painting");
+/// ```
+#[macro_export]
+macro_rules! check_for_gl_error {
+    ($gl: expr) => {{
+        if cfg!(debug_assertions) {
+            $crate::check_for_gl_error_impl($gl, file!(), line!(), "")
+        }
+    }};
+    ($gl: expr, $context: literal) => {{
+        if cfg!(debug_assertions) {
+            $crate::check_for_gl_error_impl($gl, file!(), line!(), $context)
+        }
+    }};
+}
+
+/// Check for OpenGL error and report it using `tracing::error`.
+///
+/// WARNING: slow! Only use during setup!
+///
+/// ``` no_run
+/// # let glow_context = todo!();
+/// use egui_glow::check_for_gl_error_even_in_release;
+/// check_for_gl_error_even_in_release!(glow_context);
+/// check_for_gl_error_even_in_release!(glow_context, "during painting");
+/// ```
+#[macro_export]
+macro_rules! check_for_gl_error_even_in_release {
+    ($gl: expr) => {{
+        $crate::check_for_gl_error_impl($gl, file!(), line!(), "")
+    }};
+    ($gl: expr, $context: literal) => {{
+        $crate::check_for_gl_error_impl($gl, file!(), line!(), $context)
+    }};
+}
+
+#[doc(hidden)]
+pub fn check_for_gl_error_impl(gl: &glow::Context, file: &str, line: u32, context: &str) {
+    use glow::HasContext as _;
+    #[allow(unsafe_code)]
+    let error_code = unsafe { gl.get_error() };
+    if error_code != glow::NO_ERROR {
+        let error_str = match error_code {
+            glow::INVALID_ENUM => "GL_INVALID_ENUM",
+            glow::INVALID_VALUE => "GL_INVALID_VALUE",
+            glow::INVALID_OPERATION => "GL_INVALID_OPERATION",
+            glow::STACK_OVERFLOW => "GL_STACK_OVERFLOW",
+            glow::STACK_UNDERFLOW => "GL_STACK_UNDERFLOW",
+            glow::OUT_OF_MEMORY => "GL_OUT_OF_MEMORY",
+            glow::INVALID_FRAMEBUFFER_OPERATION => "GL_INVALID_FRAMEBUFFER_OPERATION",
+            glow::CONTEXT_LOST => "GL_CONTEXT_LOST",
+            0x8031 => "GL_TABLE_TOO_LARGE1",
+            0x9242 => "CONTEXT_LOST_WEBGL",
+            _ => "<unknown>",
+        };
+
+        if context.is_empty() {
+            tracing::error!(
+                "GL error, at {}:{}: {} (0x{:X}). Please file a bug at https://github.com/emilk/egui/issues",
+                file,
+                line,
+                error_str,
+                error_code,
+            );
+        } else {
+            tracing::error!(
+                "GL error, at {}:{} ({}): {} (0x{:X}). Please file a bug at https://github.com/emilk/egui/issues",
+                file,
+                line,
+                context,
+                error_str,
+                error_code,
+            );
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+/// Profiling macro for feature "puffin"
+macro_rules! profile_function {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        #[cfg(not(target_arch = "wasm32"))]
+        puffin::profile_function!($($arg)*);
+    };
+}
+pub(crate) use profile_function;
+
+/// Profiling macro for feature "puffin"
+macro_rules! profile_scope {
+    ($($arg: tt)*) => {
+        #[cfg(feature = "puffin")]
+        #[cfg(not(target_arch = "wasm32"))]
+        puffin::profile_scope!($($arg)*);
+    };
+}
+pub(crate) use profile_scope;
diff --git a/egui/crates/egui_glow/src/misc_util.rs b/egui/crates/egui_glow/src/misc_util.rs
new file mode 100644
index 0000000..ee22f58
--- /dev/null
+++ b/egui/crates/egui_glow/src/misc_util.rs
@@ -0,0 +1,40 @@
+#![allow(unsafe_code)]
+
+use glow::HasContext as _;
+
+pub(crate) unsafe fn compile_shader(
+    gl: &glow::Context,
+    shader_type: u32,
+    source: &str,
+) -> Result<glow::Shader, String> {
+    let shader = gl.create_shader(shader_type)?;
+
+    gl.shader_source(shader, source);
+
+    gl.compile_shader(shader);
+
+    if gl.get_shader_compile_status(shader) {
+        Ok(shader)
+    } else {
+        Err(gl.get_shader_info_log(shader))
+    }
+}
+
+pub(crate) unsafe fn link_program<'a, T: IntoIterator<Item = &'a glow::Shader>>(
+    gl: &glow::Context,
+    shaders: T,
+) -> Result<glow::Program, String> {
+    let program = gl.create_program()?;
+
+    for shader in shaders {
+        gl.attach_shader(program, *shader);
+    }
+
+    gl.link_program(program);
+
+    if gl.get_program_link_status(program) {
+        Ok(program)
+    } else {
+        Err(gl.get_program_info_log(program))
+    }
+}
diff --git a/egui/crates/egui_glow/src/painter.rs b/egui/crates/egui_glow/src/painter.rs
new file mode 100644
index 0000000..4b45a76
--- /dev/null
+++ b/egui/crates/egui_glow/src/painter.rs
@@ -0,0 +1,755 @@
+#![allow(clippy::collapsible_else_if)]
+#![allow(unsafe_code)]
+
+use std::{collections::HashMap, sync::Arc};
+
+use egui::{
+    emath::Rect,
+    epaint::{Mesh, PaintCallbackInfo, Primitive, Vertex},
+};
+use glow::HasContext as _;
+use memoffset::offset_of;
+
+use crate::check_for_gl_error;
+use crate::misc_util::{compile_shader, link_program};
+use crate::shader_version::ShaderVersion;
+use crate::vao;
+
+pub use glow::Context;
+
+const VERT_SRC: &str = include_str!("shader/vertex.glsl");
+const FRAG_SRC: &str = include_str!("shader/fragment.glsl");
+
+trait TextureFilterExt {
+    fn glow_code(&self) -> u32;
+}
+
+impl TextureFilterExt for egui::TextureFilter {
+    fn glow_code(&self) -> u32 {
+        match self {
+            egui::TextureFilter::Linear => glow::LINEAR,
+            egui::TextureFilter::Nearest => glow::NEAREST,
+        }
+    }
+}
+
+/// An OpenGL painter using [`glow`].
+///
+/// This is responsible for painting egui and managing egui textures.
+/// You can access the underlying [`glow::Context`] with [`Self::gl`].
+///
+/// This struct must be destroyed with [`Painter::destroy`] before dropping, to ensure OpenGL
+/// objects have been properly deleted and are not leaked.
+pub struct Painter {
+    gl: Arc<glow::Context>,
+
+    max_texture_side: usize,
+
+    program: glow::Program,
+    u_screen_size: glow::UniformLocation,
+    u_sampler: glow::UniformLocation,
+    is_webgl_1: bool,
+    vao: crate::vao::VertexArrayObject,
+    srgb_textures: bool,
+    vbo: glow::Buffer,
+    element_array_buffer: glow::Buffer,
+
+    textures: HashMap<egui::TextureId, glow::Texture>,
+
+    next_native_tex_id: u64,
+
+    /// Stores outdated OpenGL textures that are yet to be deleted
+    textures_to_destroy: Vec<glow::Texture>,
+
+    /// Used to make sure we are destroyed correctly.
+    destroyed: bool,
+}
+
+/// A callback function that can be used to compose an [`egui::PaintCallback`] for custom rendering
+/// with [`glow`].
+///
+/// The callback is passed, the [`egui::PaintCallbackInfo`] and the [`Painter`] which can be used to
+/// access the OpenGL context.
+///
+/// # Example
+///
+/// See the [`custom3d_glow`](https://github.com/emilk/egui/blob/master/crates/egui_demo_app/src/apps/custom3d_wgpu.rs) demo source for a detailed usage example.
+pub struct CallbackFn {
+    f: Box<dyn Fn(PaintCallbackInfo, &Painter) + Sync + Send>,
+}
+
+impl CallbackFn {
+    pub fn new<F: Fn(PaintCallbackInfo, &Painter) + Sync + Send + 'static>(callback: F) -> Self {
+        let f = Box::new(callback);
+        CallbackFn { f }
+    }
+}
+
+impl Painter {
+    /// Create painter.
+    ///
+    /// Set `pp_fb_extent` to the framebuffer size to enable `sRGB` support on OpenGL ES and WebGL.
+    ///
+    /// Set `shader_prefix` if you want to turn on shader workaround e.g. `"#define APPLY_BRIGHTENING_GAMMA\n"`
+    /// (see <https://github.com/emilk/egui/issues/794>).
+    ///
+    /// # Errors
+    /// will return `Err` below cases
+    /// * failed to compile shader
+    /// * failed to create postprocess on webgl with `sRGB` support
+    /// * failed to create buffer
+    pub fn new(
+        gl: Arc<glow::Context>,
+        shader_prefix: &str,
+        shader_version: Option<ShaderVersion>,
+    ) -> Result<Painter, String> {
+        crate::profile_function!();
+        crate::check_for_gl_error_even_in_release!(&gl, "before Painter::new");
+
+        // some useful debug info. all three of them are present in gl 1.1.
+        unsafe {
+            let version = gl.get_parameter_string(glow::VERSION);
+            let renderer = gl.get_parameter_string(glow::RENDERER);
+            let vendor = gl.get_parameter_string(glow::VENDOR);
+            tracing::debug!(
+                "\nopengl version: {version}\nopengl renderer: {renderer}\nopengl vendor: {vendor}"
+            );
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        if gl.version().major < 2 {
+            // this checks on desktop that we are not using opengl 1.1 microsoft sw rendering context.
+            // ShaderVersion::get fn will segfault due to SHADING_LANGUAGE_VERSION (added in gl2.0)
+            return Err("egui_glow requires opengl 2.0+. ".to_owned());
+        }
+
+        let max_texture_side = unsafe { gl.get_parameter_i32(glow::MAX_TEXTURE_SIZE) } as usize;
+        let shader_version = shader_version.unwrap_or_else(|| ShaderVersion::get(&gl));
+        let is_webgl_1 = shader_version == ShaderVersion::Es100;
+        let shader_version_declaration = shader_version.version_declaration();
+        tracing::debug!("Shader header: {:?}.", shader_version_declaration);
+
+        let supported_extensions = gl.supported_extensions();
+        tracing::trace!("OpenGL extensions: {supported_extensions:?}");
+        let srgb_textures = shader_version == ShaderVersion::Es300 // WebGL2 always support sRGB
+            || supported_extensions.iter().any(|extension| {
+                // EXT_sRGB, GL_ARB_framebuffer_sRGB, GL_EXT_sRGB, GL_EXT_texture_sRGB_decode, …
+                extension.contains("sRGB")
+            });
+        tracing::debug!("SRGB texture Support: {:?}", srgb_textures);
+
+        unsafe {
+            let vert = compile_shader(
+                &gl,
+                glow::VERTEX_SHADER,
+                &format!(
+                    "{}\n#define NEW_SHADER_INTERFACE {}\n{}\n{}",
+                    shader_version_declaration,
+                    shader_version.is_new_shader_interface() as i32,
+                    shader_prefix,
+                    VERT_SRC
+                ),
+            )?;
+            let frag = compile_shader(
+                &gl,
+                glow::FRAGMENT_SHADER,
+                &format!(
+                    "{}\n#define NEW_SHADER_INTERFACE {}\n#define SRGB_TEXTURES {}\n{}\n{}",
+                    shader_version_declaration,
+                    shader_version.is_new_shader_interface() as i32,
+                    srgb_textures as i32,
+                    shader_prefix,
+                    FRAG_SRC
+                ),
+            )?;
+            let program = link_program(&gl, [vert, frag].iter())?;
+            gl.detach_shader(program, vert);
+            gl.detach_shader(program, frag);
+            gl.delete_shader(vert);
+            gl.delete_shader(frag);
+            let u_screen_size = gl.get_uniform_location(program, "u_screen_size").unwrap();
+            let u_sampler = gl.get_uniform_location(program, "u_sampler").unwrap();
+
+            let vbo = gl.create_buffer()?;
+
+            let a_pos_loc = gl.get_attrib_location(program, "a_pos").unwrap();
+            let a_tc_loc = gl.get_attrib_location(program, "a_tc").unwrap();
+            let a_srgba_loc = gl.get_attrib_location(program, "a_srgba").unwrap();
+
+            let stride = std::mem::size_of::<Vertex>() as i32;
+            let buffer_infos = vec![
+                vao::BufferInfo {
+                    location: a_pos_loc,
+                    vector_size: 2,
+                    data_type: glow::FLOAT,
+                    normalized: false,
+                    stride,
+                    offset: offset_of!(Vertex, pos) as i32,
+                },
+                vao::BufferInfo {
+                    location: a_tc_loc,
+                    vector_size: 2,
+                    data_type: glow::FLOAT,
+                    normalized: false,
+                    stride,
+                    offset: offset_of!(Vertex, uv) as i32,
+                },
+                vao::BufferInfo {
+                    location: a_srgba_loc,
+                    vector_size: 4,
+                    data_type: glow::UNSIGNED_BYTE,
+                    normalized: false,
+                    stride,
+                    offset: offset_of!(Vertex, color) as i32,
+                },
+            ];
+            let vao = crate::vao::VertexArrayObject::new(&gl, vbo, buffer_infos);
+
+            let element_array_buffer = gl.create_buffer()?;
+
+            crate::check_for_gl_error_even_in_release!(&gl, "after Painter::new");
+
+            Ok(Painter {
+                gl,
+                max_texture_side,
+                program,
+                u_screen_size,
+                u_sampler,
+                is_webgl_1,
+                vao,
+                srgb_textures,
+                vbo,
+                element_array_buffer,
+                textures: Default::default(),
+                next_native_tex_id: 1 << 32,
+                textures_to_destroy: Vec::new(),
+                destroyed: false,
+            })
+        }
+    }
+
+    /// Access the shared glow context.
+    pub fn gl(&self) -> &Arc<glow::Context> {
+        &self.gl
+    }
+
+    pub fn max_texture_side(&self) -> usize {
+        self.max_texture_side
+    }
+
+    /// The framebuffer we use as an intermediate render target,
+    /// or `None` if we are painting to the screen framebuffer directly.
+    ///
+    /// This is the framebuffer that is bound when [`egui::Shape::Callback`] is called,
+    /// and is where any callbacks should ultimately render onto.
+    ///
+    /// So if in a [`egui::Shape::Callback`] you need to use an offscreen FBO, you should
+    /// then restore to this afterwards with
+    /// `gl.bind_framebuffer(glow::FRAMEBUFFER, painter.intermediate_fbo());`
+    #[allow(clippy::unused_self)]
+    pub fn intermediate_fbo(&self) -> Option<glow::Framebuffer> {
+        // We don't currently ever render to an offscreen buffer,
+        // but we may want to start to in order to do anti-aliasing on web, for instance.
+        None
+    }
+
+    unsafe fn prepare_painting(
+        &mut self,
+        [width_in_pixels, height_in_pixels]: [u32; 2],
+        pixels_per_point: f32,
+    ) -> (u32, u32) {
+        self.gl.enable(glow::SCISSOR_TEST);
+        // egui outputs mesh in both winding orders
+        self.gl.disable(glow::CULL_FACE);
+        self.gl.disable(glow::DEPTH_TEST);
+
+        self.gl.color_mask(true, true, true, true);
+
+        self.gl.enable(glow::BLEND);
+        self.gl
+            .blend_equation_separate(glow::FUNC_ADD, glow::FUNC_ADD);
+        self.gl.blend_func_separate(
+            // egui outputs colors with premultiplied alpha:
+            glow::ONE,
+            glow::ONE_MINUS_SRC_ALPHA,
+            // Less important, but this is technically the correct alpha blend function
+            // when you want to make use of the framebuffer alpha (for screenshots, compositing, etc).
+            glow::ONE_MINUS_DST_ALPHA,
+            glow::ONE,
+        );
+
+        if !cfg!(target_arch = "wasm32") {
+            self.gl.disable(glow::FRAMEBUFFER_SRGB);
+            check_for_gl_error!(&self.gl, "FRAMEBUFFER_SRGB");
+        }
+
+        let width_in_points = width_in_pixels as f32 / pixels_per_point;
+        let height_in_points = height_in_pixels as f32 / pixels_per_point;
+
+        self.gl
+            .viewport(0, 0, width_in_pixels as i32, height_in_pixels as i32);
+        self.gl.use_program(Some(self.program));
+
+        self.gl
+            .uniform_2_f32(Some(&self.u_screen_size), width_in_points, height_in_points);
+        self.gl.uniform_1_i32(Some(&self.u_sampler), 0);
+        self.gl.active_texture(glow::TEXTURE0);
+
+        self.vao.bind(&self.gl);
+        self.gl
+            .bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.element_array_buffer));
+
+        check_for_gl_error!(&self.gl, "prepare_painting");
+
+        (width_in_pixels, height_in_pixels)
+    }
+
+    /// You are expected to have cleared the color buffer before calling this.
+    pub fn paint_and_update_textures(
+        &mut self,
+        screen_size_px: [u32; 2],
+        pixels_per_point: f32,
+        clipped_primitives: &[egui::ClippedPrimitive],
+        textures_delta: &egui::TexturesDelta,
+    ) {
+        crate::profile_function!();
+        for (id, image_delta) in &textures_delta.set {
+            self.set_texture(*id, image_delta);
+        }
+
+        self.paint_primitives(screen_size_px, pixels_per_point, clipped_primitives);
+
+        for &id in &textures_delta.free {
+            self.free_texture(id);
+        }
+    }
+
+    /// Main entry-point for painting a frame.
+    ///
+    /// You should call `target.clear_color(..)` before
+    /// and `target.finish()` after this.
+    ///
+    /// The following OpenGL features will be set:
+    /// - Scissor test will be enabled
+    /// - Cull face will be disabled
+    /// - Blend will be enabled
+    ///
+    /// The scissor area and blend parameters will be changed.
+    ///
+    /// As well as this, the following objects will be unset:
+    /// - Vertex Buffer
+    /// - Element Buffer
+    /// - Texture (and active texture will be set to 0)
+    /// - Program
+    ///
+    /// Please be mindful of these effects when integrating into your program, and also be mindful
+    /// of the effects your program might have on this code. Look at the source if in doubt.
+    pub fn paint_primitives(
+        &mut self,
+        screen_size_px: [u32; 2],
+        pixels_per_point: f32,
+        clipped_primitives: &[egui::ClippedPrimitive],
+    ) {
+        crate::profile_function!();
+        self.assert_not_destroyed();
+
+        let size_in_pixels = unsafe { self.prepare_painting(screen_size_px, pixels_per_point) };
+
+        for egui::ClippedPrimitive {
+            clip_rect,
+            primitive,
+        } in clipped_primitives
+        {
+            set_clip_rect(&self.gl, size_in_pixels, pixels_per_point, *clip_rect);
+
+            match primitive {
+                Primitive::Mesh(mesh) => {
+                    self.paint_mesh(mesh);
+                }
+                Primitive::Callback(callback) => {
+                    if callback.rect.is_positive() {
+                        crate::profile_scope!("callback");
+                        // Transform callback rect to physical pixels:
+                        let rect_min_x = pixels_per_point * callback.rect.min.x;
+                        let rect_min_y = pixels_per_point * callback.rect.min.y;
+                        let rect_max_x = pixels_per_point * callback.rect.max.x;
+                        let rect_max_y = pixels_per_point * callback.rect.max.y;
+
+                        let rect_min_x = rect_min_x.round() as i32;
+                        let rect_min_y = rect_min_y.round() as i32;
+                        let rect_max_x = rect_max_x.round() as i32;
+                        let rect_max_y = rect_max_y.round() as i32;
+
+                        unsafe {
+                            self.gl.viewport(
+                                rect_min_x,
+                                size_in_pixels.1 as i32 - rect_max_y,
+                                rect_max_x - rect_min_x,
+                                rect_max_y - rect_min_y,
+                            );
+                        }
+
+                        let info = egui::PaintCallbackInfo {
+                            viewport: callback.rect,
+                            clip_rect: *clip_rect,
+                            pixels_per_point,
+                            screen_size_px,
+                        };
+
+                        if let Some(callback) = callback.callback.downcast_ref::<CallbackFn>() {
+                            (callback.f)(info, self);
+                        } else {
+                            tracing::warn!("Warning: Unsupported render callback. Expected egui_glow::CallbackFn");
+                        }
+
+                        check_for_gl_error!(&self.gl, "callback");
+
+                        // Restore state:
+                        unsafe { self.prepare_painting(screen_size_px, pixels_per_point) };
+                    }
+                }
+            }
+        }
+
+        unsafe {
+            self.vao.unbind(&self.gl);
+            self.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, None);
+
+            self.gl.disable(glow::SCISSOR_TEST);
+
+            check_for_gl_error!(&self.gl, "painting");
+        }
+    }
+
+    #[inline(never)] // Easier profiling
+    fn paint_mesh(&mut self, mesh: &Mesh) {
+        debug_assert!(mesh.is_valid());
+        if let Some(texture) = self.texture(mesh.texture_id) {
+            unsafe {
+                self.gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vbo));
+                self.gl.buffer_data_u8_slice(
+                    glow::ARRAY_BUFFER,
+                    bytemuck::cast_slice(&mesh.vertices),
+                    glow::STREAM_DRAW,
+                );
+
+                self.gl
+                    .bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.element_array_buffer));
+                self.gl.buffer_data_u8_slice(
+                    glow::ELEMENT_ARRAY_BUFFER,
+                    bytemuck::cast_slice(&mesh.indices),
+                    glow::STREAM_DRAW,
+                );
+
+                self.gl.bind_texture(glow::TEXTURE_2D, Some(texture));
+            }
+
+            unsafe {
+                self.gl.draw_elements(
+                    glow::TRIANGLES,
+                    mesh.indices.len() as i32,
+                    glow::UNSIGNED_INT,
+                    0,
+                );
+            }
+
+            check_for_gl_error!(&self.gl, "paint_mesh");
+        } else {
+            tracing::warn!("Failed to find texture {:?}", mesh.texture_id);
+        }
+    }
+
+    // ------------------------------------------------------------------------
+
+    pub fn set_texture(&mut self, tex_id: egui::TextureId, delta: &egui::epaint::ImageDelta) {
+        crate::profile_function!();
+
+        self.assert_not_destroyed();
+
+        let glow_texture = *self
+            .textures
+            .entry(tex_id)
+            .or_insert_with(|| unsafe { self.gl.create_texture().unwrap() });
+        unsafe {
+            self.gl.bind_texture(glow::TEXTURE_2D, Some(glow_texture));
+        }
+
+        match &delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+
+                let data: &[u8] = bytemuck::cast_slice(image.pixels.as_ref());
+
+                self.upload_texture_srgb(delta.pos, image.size, delta.options, data);
+            }
+            egui::ImageData::Font(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+
+                let data: Vec<u8> = image
+                    .srgba_pixels(None)
+                    .flat_map(|a| a.to_array())
+                    .collect();
+
+                self.upload_texture_srgb(delta.pos, image.size, delta.options, &data);
+            }
+        };
+    }
+
+    fn upload_texture_srgb(
+        &mut self,
+        pos: Option<[usize; 2]>,
+        [w, h]: [usize; 2],
+        options: egui::TextureOptions,
+        data: &[u8],
+    ) {
+        assert_eq!(data.len(), w * h * 4);
+        assert!(
+            w <= self.max_texture_side && h <= self.max_texture_side,
+            "Got a texture image of size {}x{}, but the maximum supported texture side is only {}",
+            w,
+            h,
+            self.max_texture_side
+        );
+
+        unsafe {
+            self.gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_MAG_FILTER,
+                options.magnification.glow_code() as i32,
+            );
+            self.gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_MIN_FILTER,
+                options.minification.glow_code() as i32,
+            );
+
+            self.gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_WRAP_S,
+                glow::CLAMP_TO_EDGE as i32,
+            );
+            self.gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_WRAP_T,
+                glow::CLAMP_TO_EDGE as i32,
+            );
+            check_for_gl_error!(&self.gl, "tex_parameter");
+
+            let (internal_format, src_format) = if self.is_webgl_1 {
+                let format = if self.srgb_textures {
+                    glow::SRGB_ALPHA
+                } else {
+                    glow::RGBA
+                };
+                (format, format)
+            } else if self.srgb_textures {
+                (glow::SRGB8_ALPHA8, glow::RGBA)
+            } else {
+                (glow::RGBA8, glow::RGBA)
+            };
+
+            self.gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1);
+
+            let level = 0;
+            if let Some([x, y]) = pos {
+                self.gl.tex_sub_image_2d(
+                    glow::TEXTURE_2D,
+                    level,
+                    x as _,
+                    y as _,
+                    w as _,
+                    h as _,
+                    src_format,
+                    glow::UNSIGNED_BYTE,
+                    glow::PixelUnpackData::Slice(data),
+                );
+                check_for_gl_error!(&self.gl, "tex_sub_image_2d");
+            } else {
+                let border = 0;
+                self.gl.tex_image_2d(
+                    glow::TEXTURE_2D,
+                    level,
+                    internal_format as _,
+                    w as _,
+                    h as _,
+                    border,
+                    src_format,
+                    glow::UNSIGNED_BYTE,
+                    Some(data),
+                );
+                check_for_gl_error!(&self.gl, "tex_image_2d");
+            }
+        }
+    }
+
+    pub fn free_texture(&mut self, tex_id: egui::TextureId) {
+        if let Some(old_tex) = self.textures.remove(&tex_id) {
+            unsafe { self.gl.delete_texture(old_tex) };
+        }
+    }
+
+    /// Get the [`glow::Texture`] bound to a [`egui::TextureId`].
+    pub fn texture(&self, texture_id: egui::TextureId) -> Option<glow::Texture> {
+        self.textures.get(&texture_id).copied()
+    }
+
+    #[deprecated = "renamed 'texture'"]
+    pub fn get_texture(&self, texture_id: egui::TextureId) -> Option<glow::Texture> {
+        self.texture(texture_id)
+    }
+
+    #[allow(clippy::needless_pass_by_value)] // False positive
+    pub fn register_native_texture(&mut self, native: glow::Texture) -> egui::TextureId {
+        self.assert_not_destroyed();
+        let id = egui::TextureId::User(self.next_native_tex_id);
+        self.next_native_tex_id += 1;
+        self.textures.insert(id, native);
+        id
+    }
+
+    #[allow(clippy::needless_pass_by_value)] // False positive
+    pub fn replace_native_texture(&mut self, id: egui::TextureId, replacing: glow::Texture) {
+        if let Some(old_tex) = self.textures.insert(id, replacing) {
+            self.textures_to_destroy.push(old_tex);
+        }
+    }
+
+    pub fn read_screen_rgba(&self, [w, h]: [u32; 2]) -> egui::ColorImage {
+        let mut pixels = vec![0_u8; (w * h * 4) as usize];
+        unsafe {
+            self.gl.read_pixels(
+                0,
+                0,
+                w as _,
+                h as _,
+                glow::RGBA,
+                glow::UNSIGNED_BYTE,
+                glow::PixelPackData::Slice(&mut pixels),
+            );
+        }
+        let mut flipped = Vec::with_capacity((w * h * 4) as usize);
+        for row in pixels.chunks_exact((w * 4) as usize).rev() {
+            flipped.extend_from_slice(bytemuck::cast_slice(row));
+        }
+        egui::ColorImage {
+            size: [w as usize, h as usize],
+            pixels: flipped,
+        }
+    }
+
+    pub fn read_screen_rgb(&self, [w, h]: [u32; 2]) -> Vec<u8> {
+        let mut pixels = vec![0_u8; (w * h * 3) as usize];
+        unsafe {
+            self.gl.read_pixels(
+                0,
+                0,
+                w as _,
+                h as _,
+                glow::RGB,
+                glow::UNSIGNED_BYTE,
+                glow::PixelPackData::Slice(&mut pixels),
+            );
+        }
+        pixels
+    }
+
+    unsafe fn destroy_gl(&self) {
+        self.gl.delete_program(self.program);
+        for tex in self.textures.values() {
+            self.gl.delete_texture(*tex);
+        }
+        self.gl.delete_buffer(self.vbo);
+        self.gl.delete_buffer(self.element_array_buffer);
+        for t in &self.textures_to_destroy {
+            self.gl.delete_texture(*t);
+        }
+    }
+
+    /// This function must be called before [`Painter`] is dropped, as [`Painter`] has some OpenGL objects
+    /// that should be deleted.
+    pub fn destroy(&mut self) {
+        if !self.destroyed {
+            unsafe {
+                self.destroy_gl();
+            }
+            self.destroyed = true;
+        }
+    }
+
+    fn assert_not_destroyed(&self) {
+        assert!(!self.destroyed, "the egui glow has already been destroyed!");
+    }
+}
+
+pub fn clear(gl: &glow::Context, screen_size_in_pixels: [u32; 2], clear_color: [f32; 4]) {
+    crate::profile_function!();
+    unsafe {
+        gl.disable(glow::SCISSOR_TEST);
+
+        gl.viewport(
+            0,
+            0,
+            screen_size_in_pixels[0] as i32,
+            screen_size_in_pixels[1] as i32,
+        );
+        gl.clear_color(
+            clear_color[0],
+            clear_color[1],
+            clear_color[2],
+            clear_color[3],
+        );
+        gl.clear(glow::COLOR_BUFFER_BIT);
+    }
+}
+
+impl Drop for Painter {
+    fn drop(&mut self) {
+        if !self.destroyed {
+            tracing::warn!(
+                "You forgot to call destroy() on the egui glow painter. Resources will leak!"
+            );
+        }
+    }
+}
+
+fn set_clip_rect(
+    gl: &glow::Context,
+    size_in_pixels: (u32, u32),
+    pixels_per_point: f32,
+    clip_rect: Rect,
+) {
+    // Transform clip rect to physical pixels:
+    let clip_min_x = pixels_per_point * clip_rect.min.x;
+    let clip_min_y = pixels_per_point * clip_rect.min.y;
+    let clip_max_x = pixels_per_point * clip_rect.max.x;
+    let clip_max_y = pixels_per_point * clip_rect.max.y;
+
+    // Round to integer:
+    let clip_min_x = clip_min_x.round() as i32;
+    let clip_min_y = clip_min_y.round() as i32;
+    let clip_max_x = clip_max_x.round() as i32;
+    let clip_max_y = clip_max_y.round() as i32;
+
+    // Clamp:
+    let clip_min_x = clip_min_x.clamp(0, size_in_pixels.0 as i32);
+    let clip_min_y = clip_min_y.clamp(0, size_in_pixels.1 as i32);
+    let clip_max_x = clip_max_x.clamp(clip_min_x, size_in_pixels.0 as i32);
+    let clip_max_y = clip_max_y.clamp(clip_min_y, size_in_pixels.1 as i32);
+
+    unsafe {
+        gl.scissor(
+            clip_min_x,
+            size_in_pixels.1 as i32 - clip_max_y,
+            clip_max_x - clip_min_x,
+            clip_max_y - clip_min_y,
+        );
+    }
+}
diff --git a/egui/crates/egui_glow/src/shader/fragment.glsl b/egui/crates/egui_glow/src/shader/fragment.glsl
new file mode 100644
index 0000000..c1fc174
--- /dev/null
+++ b/egui/crates/egui_glow/src/shader/fragment.glsl
@@ -0,0 +1,41 @@
+#ifdef GL_ES
+    precision mediump float;
+#endif
+
+uniform sampler2D u_sampler;
+
+#if NEW_SHADER_INTERFACE
+    in vec4 v_rgba_in_gamma;
+    in vec2 v_tc;
+    out vec4 f_color;
+    // a dirty hack applied to support webGL2
+    #define gl_FragColor f_color
+    #define texture2D texture
+#else
+    varying vec4 v_rgba_in_gamma;
+    varying vec2 v_tc;
+#endif
+
+// 0-1 sRGB gamma  from  0-1 linear
+vec3 srgb_gamma_from_linear(vec3 rgb) {
+    bvec3 cutoff = lessThan(rgb, vec3(0.0031308));
+    vec3 lower = rgb * vec3(12.92);
+    vec3 higher = vec3(1.055) * pow(rgb, vec3(1.0 / 2.4)) - vec3(0.055);
+    return mix(higher, lower, vec3(cutoff));
+}
+
+// 0-1 sRGBA gamma  from  0-1 linear
+vec4 srgba_gamma_from_linear(vec4 rgba) {
+    return vec4(srgb_gamma_from_linear(rgba.rgb), rgba.a);
+}
+
+void main() {
+#if SRGB_TEXTURES
+    vec4 texture_in_gamma = srgba_gamma_from_linear(texture2D(u_sampler, v_tc));
+#else
+    vec4 texture_in_gamma = texture2D(u_sampler, v_tc);
+#endif
+
+    // We multiply the colors in gamma space, because that's the only way to get text to look right.
+    gl_FragColor = v_rgba_in_gamma * texture_in_gamma;
+}
diff --git a/egui/crates/egui_glow/src/shader/vertex.glsl b/egui/crates/egui_glow/src/shader/vertex.glsl
new file mode 100644
index 0000000..fff3146
--- /dev/null
+++ b/egui/crates/egui_glow/src/shader/vertex.glsl
@@ -0,0 +1,30 @@
+#if NEW_SHADER_INTERFACE
+    #define I in
+    #define O out
+    #define V(x) x
+#else
+    #define I attribute
+    #define O varying
+    #define V(x) vec3(x)
+#endif
+
+#ifdef GL_ES
+    precision mediump float;
+#endif
+
+uniform vec2 u_screen_size;
+I vec2 a_pos;
+I vec4 a_srgba; // 0-255 sRGB
+I vec2 a_tc;
+O vec4 v_rgba_in_gamma;
+O vec2 v_tc;
+
+void main() {
+    gl_Position = vec4(
+                      2.0 * a_pos.x / u_screen_size.x - 1.0,
+                      1.0 - 2.0 * a_pos.y / u_screen_size.y,
+                      0.0,
+                      1.0);
+    v_rgba_in_gamma = a_srgba / 255.0;
+    v_tc = a_tc;
+}
diff --git a/egui/crates/egui_glow/src/shader_version.rs b/egui/crates/egui_glow/src/shader_version.rs
new file mode 100644
index 0000000..c066962
--- /dev/null
+++ b/egui/crates/egui_glow/src/shader_version.rs
@@ -0,0 +1,104 @@
+#![allow(unsafe_code)]
+
+use std::convert::TryInto;
+
+/// Helper for parsing and interpreting the OpenGL shader version.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[allow(dead_code)]
+pub enum ShaderVersion {
+    Gl120,
+
+    /// OpenGL 1.4 or later
+    Gl140,
+
+    /// e.g. WebGL1
+    Es100,
+
+    /// e.g. WebGL2
+    Es300,
+}
+
+impl ShaderVersion {
+    pub fn get(gl: &glow::Context) -> Self {
+        use glow::HasContext as _;
+        let shading_lang_string =
+            unsafe { gl.get_parameter_string(glow::SHADING_LANGUAGE_VERSION) };
+        let shader_version = Self::parse(&shading_lang_string);
+        tracing::debug!(
+            "Shader version: {:?} ({:?}).",
+            shader_version,
+            shading_lang_string
+        );
+        shader_version
+    }
+
+    #[inline]
+    pub(crate) fn parse(glsl_ver: &str) -> Self {
+        let start = glsl_ver.find(|c| char::is_ascii_digit(&c)).unwrap();
+        let es = glsl_ver[..start].contains(" ES ");
+        let ver = glsl_ver[start..]
+            .split_once(' ')
+            .map_or(&glsl_ver[start..], |x| x.0);
+        let [maj, min]: [u8; 2] = ver
+            .splitn(3, '.')
+            .take(2)
+            .map(|x| x.parse().unwrap_or_default())
+            .collect::<Vec<u8>>()
+            .try_into()
+            .unwrap();
+        if es {
+            if maj >= 3 {
+                Self::Es300
+            } else {
+                Self::Es100
+            }
+        } else if maj > 1 || (maj == 1 && min >= 40) {
+            Self::Gl140
+        } else {
+            Self::Gl120
+        }
+    }
+
+    /// Goes on top of the shader.
+    pub fn version_declaration(&self) -> &'static str {
+        match self {
+            Self::Gl120 => "#version 120\n",
+            Self::Gl140 => "#version 140\n",
+            Self::Es100 => "#version 100\n",
+            Self::Es300 => "#version 300 es\n",
+        }
+    }
+
+    /// If true, use `in/out`. If `false`, use `varying` and `gl_FragColor`.
+    pub fn is_new_shader_interface(&self) -> bool {
+        match self {
+            Self::Gl120 | Self::Es100 => false,
+            Self::Es300 | Self::Gl140 => true,
+        }
+    }
+
+    pub fn is_embedded(&self) -> bool {
+        match self {
+            Self::Gl120 | Self::Gl140 => false,
+            Self::Es100 | Self::Es300 => true,
+        }
+    }
+}
+
+#[test]
+fn test_shader_version() {
+    use ShaderVersion::{Es100, Es300, Gl120, Gl140};
+    for (s, v) in [
+        ("1.2 OpenGL foo bar", Gl120),
+        ("3.0", Gl140),
+        ("0.0", Gl120),
+        ("OpenGL ES GLSL 3.00 (WebGL2)", Es300),
+        ("OpenGL ES GLSL 1.00 (WebGL)", Es100),
+        ("OpenGL ES GLSL ES 1.00 foo bar", Es100),
+        ("WebGL GLSL ES 3.00 foo bar", Es300),
+        ("WebGL GLSL ES 3.00", Es300),
+        ("WebGL GLSL ES 1.0 foo bar", Es100),
+    ] {
+        assert_eq!(ShaderVersion::parse(s), v);
+    }
+}
diff --git a/egui/crates/egui_glow/src/vao.rs b/egui/crates/egui_glow/src/vao.rs
new file mode 100644
index 0000000..ac87053
--- /dev/null
+++ b/egui/crates/egui_glow/src/vao.rs
@@ -0,0 +1,157 @@
+#![allow(unsafe_code)]
+
+use glow::HasContext as _;
+
+use crate::check_for_gl_error;
+
+// ----------------------------------------------------------------------------
+
+#[derive(Debug)]
+pub(crate) struct BufferInfo {
+    pub location: u32, //
+    pub vector_size: i32,
+    pub data_type: u32, //GL_FLOAT,GL_UNSIGNED_BYTE
+    pub normalized: bool,
+    pub stride: i32,
+    pub offset: i32,
+}
+
+// ----------------------------------------------------------------------------
+
+/// Wrapper around either Emulated VAO or GL's VAO.
+pub(crate) struct VertexArrayObject {
+    // If `None`, we emulate VAO:s.
+    vao: Option<crate::glow::VertexArray>,
+    vbo: glow::Buffer,
+    buffer_infos: Vec<BufferInfo>,
+}
+
+impl VertexArrayObject {
+    #[allow(clippy::needless_pass_by_value)] // false positive
+    pub(crate) unsafe fn new(
+        gl: &glow::Context,
+        vbo: glow::Buffer,
+        buffer_infos: Vec<BufferInfo>,
+    ) -> Self {
+        let vao = if supports_vao(gl) {
+            let vao = gl.create_vertex_array().unwrap();
+            check_for_gl_error!(gl, "create_vertex_array");
+
+            // Store state in the VAO:
+            gl.bind_vertex_array(Some(vao));
+            gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo));
+
+            for attribute in &buffer_infos {
+                gl.vertex_attrib_pointer_f32(
+                    attribute.location,
+                    attribute.vector_size,
+                    attribute.data_type,
+                    attribute.normalized,
+                    attribute.stride,
+                    attribute.offset,
+                );
+                check_for_gl_error!(gl, "vertex_attrib_pointer_f32");
+                gl.enable_vertex_attrib_array(attribute.location);
+                check_for_gl_error!(gl, "enable_vertex_attrib_array");
+            }
+
+            gl.bind_vertex_array(None);
+
+            Some(vao)
+        } else {
+            tracing::debug!("VAO not supported");
+            None
+        };
+
+        Self {
+            vao,
+            vbo,
+            buffer_infos,
+        }
+    }
+
+    pub(crate) unsafe fn bind(&self, gl: &glow::Context) {
+        if let Some(vao) = self.vao {
+            gl.bind_vertex_array(Some(vao));
+            check_for_gl_error!(gl, "bind_vertex_array");
+        } else {
+            gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vbo));
+            check_for_gl_error!(gl, "bind_buffer");
+
+            for attribute in &self.buffer_infos {
+                gl.vertex_attrib_pointer_f32(
+                    attribute.location,
+                    attribute.vector_size,
+                    attribute.data_type,
+                    attribute.normalized,
+                    attribute.stride,
+                    attribute.offset,
+                );
+                check_for_gl_error!(gl, "vertex_attrib_pointer_f32");
+                gl.enable_vertex_attrib_array(attribute.location);
+                check_for_gl_error!(gl, "enable_vertex_attrib_array");
+            }
+        }
+    }
+
+    pub(crate) unsafe fn unbind(&self, gl: &glow::Context) {
+        if self.vao.is_some() {
+            gl.bind_vertex_array(None);
+        } else {
+            gl.bind_buffer(glow::ARRAY_BUFFER, None);
+            for attribute in &self.buffer_infos {
+                gl.disable_vertex_attrib_array(attribute.location);
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn supports_vao(gl: &glow::Context) -> bool {
+    const WEBGL_PREFIX: &str = "WebGL ";
+    const OPENGL_ES_PREFIX: &str = "OpenGL ES ";
+
+    let version_string = unsafe { gl.get_parameter_string(glow::VERSION) };
+    tracing::debug!("GL version: {:?}.", version_string);
+
+    // Examples:
+    // * "WebGL 2.0 (OpenGL ES 3.0 Chromium)"
+    // * "WebGL 2.0"
+
+    if let Some(pos) = version_string.rfind(WEBGL_PREFIX) {
+        let version_str = &version_string[pos + WEBGL_PREFIX.len()..];
+        if version_str.contains("1.0") {
+            // need to test OES_vertex_array_object .
+            let supported_extensions = gl.supported_extensions();
+            tracing::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            supported_extensions.contains("OES_vertex_array_object")
+                || supported_extensions.contains("GL_OES_vertex_array_object")
+        } else {
+            true
+        }
+    } else if version_string.contains(OPENGL_ES_PREFIX) {
+        // glow targets es2.0+ so we don't concern about OpenGL ES-CM,OpenGL ES-CL
+        if version_string.contains("2.0") {
+            // need to test OES_vertex_array_object .
+            let supported_extensions = gl.supported_extensions();
+            tracing::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            supported_extensions.contains("OES_vertex_array_object")
+                || supported_extensions.contains("GL_OES_vertex_array_object")
+        } else {
+            true
+        }
+    } else {
+        // from OpenGL 3 vao into core
+        if version_string.starts_with('2') {
+            // I found APPLE_vertex_array_object , GL_ATI_vertex_array_object ,ARB_vertex_array_object
+            // but APPLE's and ATI's very old extension.
+            let supported_extensions = gl.supported_extensions();
+            tracing::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            supported_extensions.contains("ARB_vertex_array_object")
+                || supported_extensions.contains("GL_ARB_vertex_array_object")
+        } else {
+            true
+        }
+    }
+}
diff --git a/egui/crates/egui_glow/src/winit.rs b/egui/crates/egui_glow/src/winit.rs
new file mode 100644
index 0000000..8cb9f93
--- /dev/null
+++ b/egui/crates/egui_glow/src/winit.rs
@@ -0,0 +1,92 @@
+use crate::shader_version::ShaderVersion;
+pub use egui_winit;
+use egui_winit::winit;
+pub use egui_winit::EventResponse;
+
+/// Use [`egui`] from a [`glow`] app based on [`winit`].
+pub struct EguiGlow {
+    pub egui_ctx: egui::Context,
+    pub egui_winit: egui_winit::State,
+    pub painter: crate::Painter,
+
+    shapes: Vec<egui::epaint::ClippedShape>,
+    textures_delta: egui::TexturesDelta,
+}
+
+impl EguiGlow {
+    /// For automatic shader version detection set `shader_version` to `None`.
+    pub fn new<E>(
+        event_loop: &winit::event_loop::EventLoopWindowTarget<E>,
+        gl: std::sync::Arc<glow::Context>,
+        shader_version: Option<ShaderVersion>,
+    ) -> Self {
+        let painter = crate::Painter::new(gl, "", shader_version)
+            .map_err(|error| {
+                tracing::error!("error occurred in initializing painter:\n{}", error);
+            })
+            .unwrap();
+
+        Self {
+            egui_ctx: Default::default(),
+            egui_winit: egui_winit::State::new(event_loop),
+            painter,
+            shapes: Default::default(),
+            textures_delta: Default::default(),
+        }
+    }
+
+    pub fn on_event(&mut self, event: &winit::event::WindowEvent<'_>) -> EventResponse {
+        self.egui_winit.on_event(&self.egui_ctx, event)
+    }
+
+    /// Returns the `Duration` of the timeout after which egui should be repainted even if there's no new events.
+    ///
+    /// Call [`Self::paint`] later to paint.
+    pub fn run(
+        &mut self,
+        window: &winit::window::Window,
+        run_ui: impl FnMut(&egui::Context),
+    ) -> std::time::Duration {
+        let raw_input = self.egui_winit.take_egui_input(window);
+        let egui::FullOutput {
+            platform_output,
+            repaint_after,
+            textures_delta,
+            shapes,
+        } = self.egui_ctx.run(raw_input, run_ui);
+
+        self.egui_winit
+            .handle_platform_output(window, &self.egui_ctx, platform_output);
+
+        self.shapes = shapes;
+        self.textures_delta.append(textures_delta);
+        repaint_after
+    }
+
+    /// Paint the results of the last call to [`Self::run`].
+    pub fn paint(&mut self, window: &winit::window::Window) {
+        let shapes = std::mem::take(&mut self.shapes);
+        let mut textures_delta = std::mem::take(&mut self.textures_delta);
+
+        for (id, image_delta) in textures_delta.set {
+            self.painter.set_texture(id, &image_delta);
+        }
+
+        let clipped_primitives = self.egui_ctx.tessellate(shapes);
+        let dimensions: [u32; 2] = window.inner_size().into();
+        self.painter.paint_primitives(
+            dimensions,
+            self.egui_ctx.pixels_per_point(),
+            &clipped_primitives,
+        );
+
+        for id in textures_delta.free.drain(..) {
+            self.painter.free_texture(id);
+        }
+    }
+
+    /// Call to release the allocated graphics resources.
+    pub fn destroy(&mut self) {
+        self.painter.destroy();
+    }
+}
diff --git a/egui/crates/egui_web/CHANGELOG.md b/egui/crates/egui_web/CHANGELOG.md
new file mode 100644
index 0000000..95481d7
--- /dev/null
+++ b/egui/crates/egui_web/CHANGELOG.md
@@ -0,0 +1,120 @@
+# Legacy changelog for egui_web
+Between versions 0.17 and 0.18, `egui_web` was absorbed into `eframe`. Most of this changelog was then merged into [the `eframe` changelog](../eframe/CHANGELOG.md). This changelog is now only kept for historical reasons.
+
+
+
+## 0.17.0 - 2022-02-22
+* The default painter is now glow instead of WebGL ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Made the WebGL painter opt-in ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Fixed glow failure on Chromium ([#1092](https://github.com/emilk/egui/pull/1092)).
+* Shift-scroll will now result in horizontal scrolling ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Updated `epi::IntegrationInfo::web_location_hash` on `hashchange` event ([#1140](https://github.com/emilk/egui/pull/1140)).
+* Parse and percent-decode the web location query string ([#1258](https://github.com/emilk/egui/pull/1258)).
+
+
+## 0.16.0 - 2021-12-29
+* Fixed [dark rendering in WebKitGTK](https://github.com/emilk/egui/issues/794) ([#888](https://github.com/emilk/egui/pull/888/)).
+* Added feature `glow` to switch to a [`glow`](https://github.com/grovesNL/glow) based painter ([#868](https://github.com/emilk/egui/pull/868)).
+
+
+## 0.15.0 - 2021-10-24
+### Added
+* Remove "http" feature (use https://github.com/emilk/ehttp instead!).
+* Implement `epi::NativeTexture` trait for the WebGL painter.
+* Deprecate `Painter::register_webgl_texture.
+
+### Fixed 🐛
+* Fixed multiline paste.
+* Fixed painting with non-opaque backgrounds.
+* Improve text input on mobile and for IME.
+
+
+## 0.14.1 - 2021-08-28
+### Fixed 🐛
+* Fixed alpha blending for WebGL2 and WebGL1 with sRGB support backends, now having identical results as egui_glium.
+* Fixed use of egui on devices with both touch and mouse.
+
+
+## 0.14.0 - 2021-08-24
+### Added ⭐
+* Added support for dragging and dropping files into the browser window.
+
+### Fixed 🐛
+* Made text thicker and less pixelated.
+
+
+## 0.13.0 - 2021-06-24
+### Changed 🔧
+* Default to light visuals unless the system reports a preference for dark mode.
+
+### Fixed 🐛
+* Improve alpha blending, making fonts look much better (especially in light mode)
+* Fixed double-paste bug
+
+
+## 0.12.0 - 2021-05-10
+### Fixed 🐛
+* Scroll faster when scrolling with mouse wheel.
+
+
+## 0.11.0 - 2021-04-05
+### Added ⭐
+* [Fix mobile and IME text input](https://github.com/emilk/egui/pull/253)
+* Hold down a modifier key when clicking a link to open it in a new tab.
+
+Contributors: [n2](https://github.com/n2)
+
+
+## 0.10.0 - 2021-02-28
+### Added ⭐
+* You can control the maximum egui canvas size with `App::max_size_points`.
+
+
+## 0.9.0 - 2021-02-07
+### Added ⭐
+* Right-clicks will no longer open browser context menu.
+
+### Fixed 🐛
+* Fixed a bug where one couldn't select items in a combo box on a touch screen.
+
+
+## 0.8.0 - 2021-01-17
+### Added ⭐
+* WebGL2 is now supported, with improved texture sampler. WebGL1 will be used as a fallback.
+
+### Changed 🔧
+* Slightly improved alpha-blending (work-around for non-existing linear-space blending).
+
+### Fixed 🐛
+* Call prevent_default for arrow keys when entering text
+
+
+## 0.7.0 - 2021-01-04
+### Changed 🔧
+* `http` and `persistence` are now optional (and opt-in) features.
+
+### Fixed 🐛
+* egui_web now compiled without `RUSTFLAGS=--cfg=web_sys_unstable_apis`, but copy/paste won't work.
+
+
+## 0.6.0 - 2020-12-26
+### Added ⭐
+* Auto-save of app state to local storage
+
+### Changed 🔧
+* Set a maximum canvas size to alleviate performance issues on some machines
+* Simplify `egui_web::start` arguments
+
+
+## 0.4.0 - 2020-11-28
+### Added ⭐
+* A simple HTTP fetch API (wraps `web_sys`).
+* Added ability to request a repaint
+* Copy/cut/paste support
+
+### Changed 🔧
+* Automatic repaint every second
+
+### Fixed 🐛
+* Web browser zooming should now work as expected
+* A bunch of bug fixes related to keyboard events
diff --git a/egui/crates/egui_web/README.md b/egui/crates/egui_web/README.md
new file mode 100644
index 0000000..feb8625
--- /dev/null
+++ b/egui/crates/egui_web/README.md
@@ -0,0 +1 @@
+`egui_web` used to be a standalone crate, but has now been moved into [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
diff --git a/egui/crates/emath/Cargo.toml b/egui/crates/emath/Cargo.toml
new file mode 100644
index 0000000..b176439
--- /dev/null
+++ b/egui/crates/emath/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "emath"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "Minimal 2D math library for GUI work"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/emath"
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/emath"
+categories = ["mathematics", "gui"]
+keywords = ["math", "gui"]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = []
+
+## Enable additional checks if debug assertions are enabled (debug builds).
+extra_debug_asserts = []
+## Always enable additional checks.
+extra_asserts = []
+
+
+[dependencies]
+#! ### Optional dependencies
+
+## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast `emath` types to `&[u8]`.
+bytemuck = { version = "1.7.2", optional = true, features = ["derive"] }
+
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+## [`mint`](https://docs.rs/mint) enables interoperability with other math libraries such as [`glam`](https://docs.rs/glam) and [`nalgebra`](https://docs.rs/nalgebra).
+mint = { version = "0.5.6", optional = true }
+
+## Allow serialization using [`serde`](https://docs.rs/serde).
+serde = { version = "1", optional = true, features = ["derive"] }
diff --git a/egui/crates/emath/README.md b/egui/crates/emath/README.md
new file mode 100644
index 0000000..af22459
--- /dev/null
+++ b/egui/crates/emath/README.md
@@ -0,0 +1,11 @@
+# emath - egui math library
+
+[![Latest version](https://img.shields.io/crates/v/emath.svg)](https://crates.io/crates/emath)
+[![Documentation](https://docs.rs/emath/badge.svg)](https://docs.rs/emath)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+A bare-bones 2D math library with types and functions useful for GUI building.
+
+Made for [`egui`](https://github.com/emilk/egui/).
diff --git a/egui/crates/emath/src/align.rs b/egui/crates/emath/src/align.rs
new file mode 100644
index 0000000..5a09f8a
--- /dev/null
+++ b/egui/crates/emath/src/align.rs
@@ -0,0 +1,265 @@
+//! One- and two-dimensional alignment ([`Align::Center`], [`Align2::LEFT_TOP`] etc).
+
+use crate::*;
+
+/// left/center/right or top/center/bottom alignment for e.g. anchors and layouts.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum Align {
+    /// Left or top.
+    Min,
+
+    /// Horizontal or vertical center.
+    Center,
+
+    /// Right or bottom.
+    Max,
+}
+
+impl Align {
+    /// Convenience for [`Self::Min`]
+    pub const LEFT: Self = Self::Min;
+
+    /// Convenience for [`Self::Max`]
+    pub const RIGHT: Self = Self::Max;
+
+    /// Convenience for [`Self::Min`]
+    pub const TOP: Self = Self::Min;
+
+    /// Convenience for [`Self::Max`]
+    pub const BOTTOM: Self = Self::Max;
+
+    /// Convert `Min => 0.0`, `Center => 0.5` or `Max => 1.0`.
+    #[inline(always)]
+    pub fn to_factor(self) -> f32 {
+        match self {
+            Self::Min => 0.0,
+            Self::Center => 0.5,
+            Self::Max => 1.0,
+        }
+    }
+
+    /// Convert `Min => -1.0`, `Center => 0.0` or `Max => 1.0`.
+    #[inline(always)]
+    pub fn to_sign(self) -> f32 {
+        match self {
+            Self::Min => -1.0,
+            Self::Center => 0.0,
+            Self::Max => 1.0,
+        }
+    }
+
+    /// Returns a range of given size within a specified range.
+    ///
+    /// If the requested `size` is bigger than the size of `range`, then the returned
+    /// range will not fit into the available `range`. The extra space will be allocated
+    /// from:
+    ///
+    /// |Align |Side        |
+    /// |------|------------|
+    /// |Min   |right (end) |
+    /// |Center|both        |
+    /// |Max   |left (start)|
+    ///
+    /// # Examples
+    /// ```
+    /// use std::f32::{INFINITY, NEG_INFINITY};
+    /// use emath::Align::*;
+    ///
+    /// // The size is smaller than a range
+    /// assert_eq!(Min   .align_size_within_range(2.0, 10.0..=20.0), 10.0..=12.0);
+    /// assert_eq!(Center.align_size_within_range(2.0, 10.0..=20.0), 14.0..=16.0);
+    /// assert_eq!(Max   .align_size_within_range(2.0, 10.0..=20.0), 18.0..=20.0);
+    ///
+    /// // The size is bigger than a range
+    /// assert_eq!(Min   .align_size_within_range(20.0, 10.0..=20.0), 10.0..=30.0);
+    /// assert_eq!(Center.align_size_within_range(20.0, 10.0..=20.0),  5.0..=25.0);
+    /// assert_eq!(Max   .align_size_within_range(20.0, 10.0..=20.0),  0.0..=20.0);
+    ///
+    /// // The size is infinity, but range is finite - a special case of a previous example
+    /// assert_eq!(Min   .align_size_within_range(INFINITY, 10.0..=20.0),         10.0..=INFINITY);
+    /// assert_eq!(Center.align_size_within_range(INFINITY, 10.0..=20.0), NEG_INFINITY..=INFINITY);
+    /// assert_eq!(Max   .align_size_within_range(INFINITY, 10.0..=20.0), NEG_INFINITY..=20.0);
+    /// ```
+    ///
+    /// The infinity-sized ranges can produce a surprising results, if the size is also infinity,
+    /// use such ranges with carefully!
+    ///
+    /// ```
+    /// use std::f32::{INFINITY, NEG_INFINITY};
+    /// use emath::Align::*;
+    ///
+    /// // Allocating a size aligned for infinity bound will lead to empty ranges!
+    /// assert_eq!(Min   .align_size_within_range(2.0, 10.0..=INFINITY),     10.0..=12.0);
+    /// assert_eq!(Center.align_size_within_range(2.0, 10.0..=INFINITY), INFINITY..=INFINITY);// (!)
+    /// assert_eq!(Max   .align_size_within_range(2.0, 10.0..=INFINITY), INFINITY..=INFINITY);// (!)
+    ///
+    /// assert_eq!(Min   .align_size_within_range(2.0, NEG_INFINITY..=20.0), NEG_INFINITY..=NEG_INFINITY);// (!)
+    /// assert_eq!(Center.align_size_within_range(2.0, NEG_INFINITY..=20.0), NEG_INFINITY..=NEG_INFINITY);// (!)
+    /// assert_eq!(Max   .align_size_within_range(2.0, NEG_INFINITY..=20.0),         18.0..=20.0);
+    ///
+    ///
+    /// // The infinity size will always return the given range if it has at least one infinity bound
+    /// assert_eq!(Min   .align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
+    /// assert_eq!(Center.align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
+    /// assert_eq!(Max   .align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
+    ///
+    /// assert_eq!(Min   .align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
+    /// assert_eq!(Center.align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
+    /// assert_eq!(Max   .align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
+    /// ```
+    #[inline]
+    pub fn align_size_within_range(
+        self,
+        size: f32,
+        range: RangeInclusive<f32>,
+    ) -> RangeInclusive<f32> {
+        let min = *range.start();
+        let max = *range.end();
+
+        if max - min == f32::INFINITY && size == f32::INFINITY {
+            return range;
+        }
+
+        match self {
+            Self::Min => min..=min + size,
+            Self::Center => {
+                if size == f32::INFINITY {
+                    f32::NEG_INFINITY..=f32::INFINITY
+                } else {
+                    let left = (min + max) / 2.0 - size / 2.0;
+                    left..=left + size
+                }
+            }
+            Self::Max => max - size..=max,
+        }
+    }
+}
+
+impl Default for Align {
+    #[inline(always)]
+    fn default() -> Align {
+        Align::Min
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Two-dimension alignment, e.g. [`Align2::LEFT_TOP`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Align2(pub [Align; 2]);
+
+impl Align2 {
+    pub const LEFT_BOTTOM: Align2 = Align2([Align::Min, Align::Max]);
+    pub const LEFT_CENTER: Align2 = Align2([Align::Min, Align::Center]);
+    pub const LEFT_TOP: Align2 = Align2([Align::Min, Align::Min]);
+    pub const CENTER_BOTTOM: Align2 = Align2([Align::Center, Align::Max]);
+    pub const CENTER_CENTER: Align2 = Align2([Align::Center, Align::Center]);
+    pub const CENTER_TOP: Align2 = Align2([Align::Center, Align::Min]);
+    pub const RIGHT_BOTTOM: Align2 = Align2([Align::Max, Align::Max]);
+    pub const RIGHT_CENTER: Align2 = Align2([Align::Max, Align::Center]);
+    pub const RIGHT_TOP: Align2 = Align2([Align::Max, Align::Min]);
+}
+
+impl Align2 {
+    /// Returns an alignment by the X (horizontal) axis
+    #[inline(always)]
+    pub fn x(self) -> Align {
+        self.0[0]
+    }
+
+    /// Returns an alignment by the Y (vertical) axis
+    #[inline(always)]
+    pub fn y(self) -> Align {
+        self.0[1]
+    }
+
+    /// -1, 0, or +1 for each axis
+    pub fn to_sign(self) -> Vec2 {
+        vec2(self.x().to_sign(), self.y().to_sign())
+    }
+
+    /// Used e.g. to anchor a piece of text to a part of the rectangle.
+    /// Give a position within the rect, specified by the aligns
+    pub fn anchor_rect(self, rect: Rect) -> Rect {
+        let x = match self.x() {
+            Align::Min => rect.left(),
+            Align::Center => rect.left() - 0.5 * rect.width(),
+            Align::Max => rect.left() - rect.width(),
+        };
+        let y = match self.y() {
+            Align::Min => rect.top(),
+            Align::Center => rect.top() - 0.5 * rect.height(),
+            Align::Max => rect.top() - rect.height(),
+        };
+        Rect::from_min_size(pos2(x, y), rect.size())
+    }
+
+    /// e.g. center a size within a given frame
+    pub fn align_size_within_rect(self, size: Vec2, frame: Rect) -> Rect {
+        let x_range = self.x().align_size_within_range(size.x, frame.x_range());
+        let y_range = self.y().align_size_within_range(size.y, frame.y_range());
+        Rect::from_x_y_ranges(x_range, y_range)
+    }
+
+    /// Returns the point on the rect's frame or in the center of a rect according
+    /// to the alignments of this object.
+    ///
+    /// ```text
+    /// (*)-----------+------(*)------+-----------(*)--> X
+    ///  |            |               |            |
+    ///  |  Min, Min  |  Center, Min  |  Max, Min  |
+    ///  |            |               |            |
+    ///  +------------+---------------+------------+
+    ///  |            |               |            |
+    /// (*)Min, Center|Center(*)Center|Max, Center(*)
+    ///  |            |               |            |
+    ///  +------------+---------------+------------+
+    ///  |            |               |            |
+    ///  |  Min, Max  | Center, Max   |  Max, Max  |
+    ///  |            |               |            |
+    /// (*)-----------+------(*)------+-----------(*)
+    ///  |
+    ///  Y
+    /// ```
+    pub fn pos_in_rect(self, frame: &Rect) -> Pos2 {
+        let x = match self.x() {
+            Align::Min => frame.left(),
+            Align::Center => frame.center().x,
+            Align::Max => frame.right(),
+        };
+        let y = match self.y() {
+            Align::Min => frame.top(),
+            Align::Center => frame.center().y,
+            Align::Max => frame.bottom(),
+        };
+
+        pos2(x, y)
+    }
+}
+
+impl std::ops::Index<usize> for Align2 {
+    type Output = Align;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &Align {
+        &self.0[index]
+    }
+}
+
+impl std::ops::IndexMut<usize> for Align2 {
+    #[inline(always)]
+    fn index_mut(&mut self, index: usize) -> &mut Align {
+        &mut self.0[index]
+    }
+}
+
+/// Allocates a rectangle of the specified `size` inside the `frame` rectangle
+/// around of its center.
+///
+/// If `size` is bigger than the `frame`s size the returned rect will bounce out
+/// of the `frame`.
+pub fn center_size_in_rect(size: Vec2, frame: Rect) -> Rect {
+    Align2::CENTER_CENTER.align_size_within_rect(size, frame)
+}
diff --git a/egui/crates/emath/src/history.rs b/egui/crates/emath/src/history.rs
new file mode 100644
index 0000000..482db92
--- /dev/null
+++ b/egui/crates/emath/src/history.rs
@@ -0,0 +1,229 @@
+use std::collections::VecDeque;
+
+/// This struct tracks recent values of some time series.
+///
+/// It can be used as a smoothing filter for e.g. latency, fps etc,
+/// or to show a log or graph of recent events.
+///
+/// It has a minimum and maximum length, as well as a maximum storage time.
+/// * The minimum length is to ensure you have enough data for an estimate.
+/// * The maximum length is to make sure the history doesn't take up too much space.
+/// * The maximum age is to make sure the estimate isn't outdated.
+///
+/// Time difference between values can be zero, but never negative.
+///
+/// This can be used for things like smoothed averages (for e.g. FPS)
+/// or for smoothed velocity (e.g. mouse pointer speed).
+/// All times are in seconds.
+#[derive(Clone, Debug)]
+pub struct History<T> {
+    /// In elements, i.e. of `values.len()`.
+    /// The length is initially zero, but once past `min_len` will not shrink below it.
+    min_len: usize,
+
+    /// In elements, i.e. of `values.len()`.
+    max_len: usize,
+
+    /// In seconds.
+    max_age: f32,
+
+    /// Total number of elements seen ever
+    total_count: u64,
+
+    /// (time, value) pairs, oldest front, newest back.
+    /// Time difference between values can be zero, but never negative.
+    values: VecDeque<(f64, T)>,
+}
+
+impl<T> History<T>
+where
+    T: Copy,
+{
+    /// Example:
+    /// ```
+    /// # use emath::History;
+    /// # fn now() -> f64 { 0.0 }
+    /// // Drop events that are older than one second,
+    /// // as long we keep at least two events. Never keep more than a hundred events.
+    /// let mut history = History::new(2..100, 1.0);
+    /// assert_eq!(history.average(), None);
+    /// history.add(now(), 40.0_f32);
+    /// history.add(now(), 44.0_f32);
+    /// assert_eq!(history.average(), Some(42.0));
+    /// ```
+    pub fn new(length_range: std::ops::Range<usize>, max_age: f32) -> Self {
+        Self {
+            min_len: length_range.start,
+            max_len: length_range.end,
+            max_age,
+            total_count: 0,
+            values: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn max_len(&self) -> usize {
+        self.max_len
+    }
+
+    #[inline]
+    pub fn max_age(&self) -> f32 {
+        self.max_age
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    /// Current number of values kept in history
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    /// Total number of values seen.
+    /// Includes those that have been discarded due to `max_len` or `max_age`.
+    #[inline]
+    pub fn total_count(&self) -> u64 {
+        self.total_count
+    }
+
+    pub fn latest(&self) -> Option<T> {
+        self.values.back().map(|(_, value)| *value)
+    }
+
+    pub fn latest_mut(&mut self) -> Option<&mut T> {
+        self.values.back_mut().map(|(_, value)| value)
+    }
+
+    /// Amount of time contained from start to end in this [`History`].
+    pub fn duration(&self) -> f32 {
+        if let (Some(front), Some(back)) = (self.values.front(), self.values.back()) {
+            (back.0 - front.0) as f32
+        } else {
+            0.0
+        }
+    }
+
+    /// `(time, value)` pairs
+    /// Time difference between values can be zero, but never negative.
+    // TODO(emilk): impl IntoIter
+    pub fn iter(&'_ self) -> impl ExactSizeIterator<Item = (f64, T)> + '_ {
+        self.values.iter().map(|(time, value)| (*time, *value))
+    }
+
+    pub fn values(&'_ self) -> impl ExactSizeIterator<Item = T> + '_ {
+        self.values.iter().map(|(_time, value)| *value)
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.values.clear();
+    }
+
+    /// Values must be added with a monotonically increasing time, or at least not decreasing.
+    pub fn add(&mut self, now: f64, value: T) {
+        if let Some((last_time, _)) = self.values.back() {
+            crate::emath_assert!(now >= *last_time, "Time shouldn't move backwards");
+        }
+        self.total_count += 1;
+        self.values.push_back((now, value));
+        self.flush(now);
+    }
+
+    /// Mean time difference between values in this [`History`].
+    pub fn mean_time_interval(&self) -> Option<f32> {
+        if let (Some(first), Some(last)) = (self.values.front(), self.values.back()) {
+            let n = self.len();
+            if n >= 2 {
+                Some((last.0 - first.0) as f32 / ((n - 1) as f32))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    // Mean number of events per second.
+    pub fn rate(&self) -> Option<f32> {
+        self.mean_time_interval().map(|time| 1.0 / time)
+    }
+
+    /// Remove samples that are too old.
+    pub fn flush(&mut self, now: f64) {
+        while self.values.len() > self.max_len {
+            self.values.pop_front();
+        }
+        while self.values.len() > self.min_len {
+            if let Some((front_time, _)) = self.values.front() {
+                if *front_time < now - (self.max_age as f64) {
+                    self.values.pop_front();
+                } else {
+                    break;
+                }
+            } else {
+                break;
+            }
+        }
+    }
+}
+
+impl<T> History<T>
+where
+    T: Copy,
+    T: std::iter::Sum,
+    T: std::ops::Div<f32, Output = T>,
+{
+    #[inline]
+    pub fn sum(&self) -> T {
+        self.values().sum()
+    }
+
+    pub fn average(&self) -> Option<T> {
+        let num = self.len();
+        if num > 0 {
+            Some(self.sum() / (num as f32))
+        } else {
+            None
+        }
+    }
+}
+
+impl<T> History<T>
+where
+    T: Copy,
+    T: std::iter::Sum,
+    T: std::ops::Div<f32, Output = T>,
+    T: std::ops::Mul<f32, Output = T>,
+{
+    /// Average times rate.
+    /// If you are keeping track of individual sizes of things (e.g. bytes),
+    /// this will estimate the bandwidth (bytes per second).
+    pub fn bandwidth(&self) -> Option<T> {
+        Some(self.average()? * self.rate()?)
+    }
+}
+
+impl<T, Vel> History<T>
+where
+    T: Copy,
+    T: std::ops::Sub<Output = Vel>,
+    Vel: std::ops::Div<f32, Output = Vel>,
+{
+    /// Calculate a smooth velocity (per second) over the entire time span.
+    /// Calculated as the last value minus the first value over the elapsed time between them.
+    pub fn velocity(&self) -> Option<Vel> {
+        if let (Some(first), Some(last)) = (self.values.front(), self.values.back()) {
+            let dt = (last.0 - first.0) as f32;
+            if dt > 0.0 {
+                Some((last.1 - first.1) / dt)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+}
diff --git a/egui/crates/emath/src/lib.rs b/egui/crates/emath/src/lib.rs
new file mode 100644
index 0000000..95552af
--- /dev/null
+++ b/egui/crates/emath/src/lib.rs
@@ -0,0 +1,392 @@
+//! Opinionated 2D math library for building GUIs.
+//!
+//! Includes vectors, positions, rectangles etc.
+//!
+//! Conventions (unless otherwise specified):
+//!
+//! * All angles are in radians
+//! * X+ is right and Y+ is down.
+//! * (0,0) is left top.
+//! * Dimension order is always `x y`
+//!
+//! ## Integrating with other math libraries.
+//! `emath` does not strive to become a general purpose or all-powerful math library.
+//!
+//! For that, use something else ([`glam`](https://docs.rs/glam), [`nalgebra`](https://docs.rs/nalgebra), …)
+//! and enable the `mint` feature flag in `emath` to enable implicit conversion to/from `emath`.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![forbid(unsafe_code)]
+
+use std::ops::{Add, Div, Mul, RangeInclusive, Sub};
+
+// ----------------------------------------------------------------------------
+
+pub mod align;
+mod history;
+mod numeric;
+mod pos2;
+mod rect;
+mod rect_transform;
+mod rot2;
+pub mod smart_aim;
+mod vec2;
+
+pub use {
+    align::{Align, Align2},
+    history::History,
+    numeric::*,
+    pos2::*,
+    rect::*,
+    rect_transform::*,
+    rot2::*,
+    vec2::*,
+};
+
+// ----------------------------------------------------------------------------
+
+/// Helper trait to implement [`lerp`] and [`remap`].
+pub trait One {
+    fn one() -> Self;
+}
+
+impl One for f32 {
+    #[inline(always)]
+    fn one() -> Self {
+        1.0
+    }
+}
+
+impl One for f64 {
+    #[inline(always)]
+    fn one() -> Self {
+        1.0
+    }
+}
+
+/// Helper trait to implement [`lerp`] and [`remap`].
+pub trait Real:
+    Copy
+    + PartialEq
+    + PartialOrd
+    + One
+    + Add<Self, Output = Self>
+    + Sub<Self, Output = Self>
+    + Mul<Self, Output = Self>
+    + Div<Self, Output = Self>
+{
+}
+
+impl Real for f32 {}
+
+impl Real for f64 {}
+
+// ----------------------------------------------------------------------------
+
+/// Linear interpolation.
+///
+/// ```
+/// # use emath::lerp;
+/// assert_eq!(lerp(1.0..=5.0, 0.0), 1.0);
+/// assert_eq!(lerp(1.0..=5.0, 0.5), 3.0);
+/// assert_eq!(lerp(1.0..=5.0, 1.0), 5.0);
+/// assert_eq!(lerp(1.0..=5.0, 2.0), 9.0);
+/// ```
+#[inline(always)]
+pub fn lerp<R, T>(range: RangeInclusive<R>, t: T) -> R
+where
+    T: Real + Mul<R, Output = R>,
+    R: Copy + Add<R, Output = R>,
+{
+    (T::one() - t) * *range.start() + t * *range.end()
+}
+
+/// Where in the range is this value? Returns 0-1 if within the range.
+///
+/// Returns <0 if before and >1 if after.
+///
+/// Returns `None` if the input range is zero-width.
+///
+/// ```
+/// # use emath::inverse_lerp;
+/// assert_eq!(inverse_lerp(1.0..=5.0, 1.0), Some(0.0));
+/// assert_eq!(inverse_lerp(1.0..=5.0, 3.0), Some(0.5));
+/// assert_eq!(inverse_lerp(1.0..=5.0, 5.0), Some(1.0));
+/// assert_eq!(inverse_lerp(1.0..=5.0, 9.0), Some(2.0));
+/// assert_eq!(inverse_lerp(1.0..=1.0, 3.0), None);
+/// ```
+#[inline]
+pub fn inverse_lerp<R>(range: RangeInclusive<R>, value: R) -> Option<R>
+where
+    R: Copy + PartialEq + Sub<R, Output = R> + Div<R, Output = R>,
+{
+    let min = *range.start();
+    let max = *range.end();
+    if min == max {
+        None
+    } else {
+        Some((value - min) / (max - min))
+    }
+}
+
+/// Linearly remap a value from one range to another,
+/// so that when `x == from.start()` returns `to.start()`
+/// and when `x == from.end()` returns `to.end()`.
+pub fn remap<T>(x: T, from: RangeInclusive<T>, to: RangeInclusive<T>) -> T
+where
+    T: Real,
+{
+    crate::emath_assert!(from.start() != from.end());
+    let t = (x - *from.start()) / (*from.end() - *from.start());
+    lerp(to, t)
+}
+
+/// Like [`remap`], but also clamps the value so that the returned value is always in the `to` range.
+pub fn remap_clamp<T>(x: T, from: RangeInclusive<T>, to: RangeInclusive<T>) -> T
+where
+    T: Real,
+{
+    if from.end() < from.start() {
+        return remap_clamp(x, *from.end()..=*from.start(), *to.end()..=*to.start());
+    }
+    if x <= *from.start() {
+        *to.start()
+    } else if *from.end() <= x {
+        *to.end()
+    } else {
+        crate::emath_assert!(from.start() != from.end());
+        let t = (x - *from.start()) / (*from.end() - *from.start());
+        // Ensure no numerical inaccuracies sneak in:
+        if T::one() <= t {
+            *to.end()
+        } else {
+            lerp(to, t)
+        }
+    }
+}
+
+/// Round a value to the given number of decimal places.
+pub fn round_to_decimals(value: f64, decimal_places: usize) -> f64 {
+    // This is a stupid way of doing this, but stupid works.
+    format!("{:.*}", decimal_places, value)
+        .parse()
+        .unwrap_or(value)
+}
+
+pub fn format_with_minimum_decimals(value: f64, decimals: usize) -> String {
+    format_with_decimals_in_range(value, decimals..=6)
+}
+
+pub fn format_with_decimals_in_range(value: f64, decimal_range: RangeInclusive<usize>) -> String {
+    let min_decimals = *decimal_range.start();
+    let max_decimals = *decimal_range.end();
+    crate::emath_assert!(min_decimals <= max_decimals);
+    crate::emath_assert!(max_decimals < 100);
+    let max_decimals = max_decimals.min(16);
+    let min_decimals = min_decimals.min(max_decimals);
+
+    if min_decimals != max_decimals {
+        // Ugly/slow way of doing this. TODO(emilk): clean up precision.
+        for decimals in min_decimals..max_decimals {
+            let text = format!("{:.*}", decimals, value);
+            let epsilon = 16.0 * f32::EPSILON; // margin large enough to handle most peoples round-tripping needs
+            if almost_equal(text.parse::<f32>().unwrap(), value as f32, epsilon) {
+                // Enough precision to show the value accurately - good!
+                return text;
+            }
+        }
+        // The value has more precision than we expected.
+        // Probably the value was set not by the slider, but from outside.
+        // In any case: show the full value
+    }
+    format!("{:.*}", max_decimals, value)
+}
+
+/// Return true when arguments are the same within some rounding error.
+///
+/// For instance `almost_equal(x, x.to_degrees().to_radians(), f32::EPSILON)` should hold true for all x.
+/// The `epsilon`  can be `f32::EPSILON` to handle simple transforms (like degrees -> radians)
+/// but should be higher to handle more complex transformations.
+pub fn almost_equal(a: f32, b: f32, epsilon: f32) -> bool {
+    if a == b {
+        true // handle infinites
+    } else {
+        let abs_max = a.abs().max(b.abs());
+        abs_max <= epsilon || ((a - b).abs() / abs_max) <= epsilon
+    }
+}
+
+#[allow(clippy::approx_constant)]
+#[test]
+fn test_format() {
+    assert_eq!(format_with_minimum_decimals(1_234_567.0, 0), "1234567");
+    assert_eq!(format_with_minimum_decimals(1_234_567.0, 1), "1234567.0");
+    assert_eq!(format_with_minimum_decimals(3.14, 2), "3.14");
+    assert_eq!(format_with_minimum_decimals(3.14, 3), "3.140");
+    assert_eq!(
+        format_with_minimum_decimals(std::f64::consts::PI, 2),
+        "3.14159"
+    );
+}
+
+#[test]
+fn test_almost_equal() {
+    for &x in &[
+        0.0_f32,
+        f32::MIN_POSITIVE,
+        1e-20,
+        1e-10,
+        f32::EPSILON,
+        0.1,
+        0.99,
+        1.0,
+        1.001,
+        1e10,
+        f32::MAX / 100.0,
+        // f32::MAX, // overflows in rad<->deg test
+        f32::INFINITY,
+    ] {
+        for &x in &[-x, x] {
+            for roundtrip in &[
+                |x: f32| x.to_degrees().to_radians(),
+                |x: f32| x.to_radians().to_degrees(),
+            ] {
+                let epsilon = f32::EPSILON;
+                assert!(
+                    almost_equal(x, roundtrip(x), epsilon),
+                    "{} vs {}",
+                    x,
+                    roundtrip(x)
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn test_remap() {
+    assert_eq!(remap_clamp(1.0, 0.0..=1.0, 0.0..=16.0), 16.0);
+    assert_eq!(remap_clamp(1.0, 1.0..=0.0, 16.0..=0.0), 16.0);
+    assert_eq!(remap_clamp(0.5, 1.0..=0.0, 16.0..=0.0), 8.0);
+}
+
+// ----------------------------------------------------------------------------
+
+/// Extends `f32`, [`Vec2`] etc with `at_least` and `at_most` as aliases for `max` and `min`.
+pub trait NumExt {
+    /// More readable version of `self.max(lower_limit)`
+    #[must_use]
+    fn at_least(self, lower_limit: Self) -> Self;
+
+    /// More readable version of `self.min(upper_limit)`
+    #[must_use]
+    fn at_most(self, upper_limit: Self) -> Self;
+}
+
+macro_rules! impl_num_ext {
+    ($t: ty) => {
+        impl NumExt for $t {
+            #[inline(always)]
+            fn at_least(self, lower_limit: Self) -> Self {
+                self.max(lower_limit)
+            }
+
+            #[inline(always)]
+            fn at_most(self, upper_limit: Self) -> Self {
+                self.min(upper_limit)
+            }
+        }
+    };
+}
+
+impl_num_ext!(u8);
+impl_num_ext!(u16);
+impl_num_ext!(u32);
+impl_num_ext!(u64);
+impl_num_ext!(u128);
+impl_num_ext!(usize);
+impl_num_ext!(i8);
+impl_num_ext!(i16);
+impl_num_ext!(i32);
+impl_num_ext!(i64);
+impl_num_ext!(i128);
+impl_num_ext!(isize);
+impl_num_ext!(f32);
+impl_num_ext!(f64);
+impl_num_ext!(Vec2);
+impl_num_ext!(Pos2);
+
+// ----------------------------------------------------------------------------
+
+/// Wrap angle to `[-PI, PI]` range.
+pub fn normalized_angle(mut angle: f32) -> f32 {
+    use std::f32::consts::{PI, TAU};
+    angle %= TAU;
+    if angle > PI {
+        angle -= TAU;
+    } else if angle < -PI {
+        angle += TAU;
+    }
+    angle
+}
+
+#[test]
+fn test_normalized_angle() {
+    macro_rules! almost_eq {
+        ($left: expr, $right: expr) => {
+            let left = $left;
+            let right = $right;
+            assert!((left - right).abs() < 1e-6, "{} != {}", left, right);
+        };
+    }
+
+    use std::f32::consts::TAU;
+    almost_eq!(normalized_angle(-3.0 * TAU), 0.0);
+    almost_eq!(normalized_angle(-2.3 * TAU), -0.3 * TAU);
+    almost_eq!(normalized_angle(-TAU), 0.0);
+    almost_eq!(normalized_angle(0.0), 0.0);
+    almost_eq!(normalized_angle(TAU), 0.0);
+    almost_eq!(normalized_angle(2.7 * TAU), -0.3 * TAU);
+}
+
+// ----------------------------------------------------------------------------
+
+/// Calculate a lerp-factor for exponential smoothing using a time step.
+///
+/// * `exponential_smooth_factor(0.90, 1.0, dt)`: reach 90% in 1.0 seconds
+/// * `exponential_smooth_factor(0.50, 0.2, dt)`: reach 50% in 0.2 seconds
+///
+/// Example:
+/// ```
+/// # use emath::{lerp, exponential_smooth_factor};
+/// # let (mut smoothed_value, target_value, dt) = (0.0_f32, 1.0_f32, 0.01_f32);
+/// let t = exponential_smooth_factor(0.90, 0.2, dt); // reach 90% in 0.2 seconds
+/// smoothed_value = lerp(smoothed_value..=target_value, t);
+/// ```
+pub fn exponential_smooth_factor(
+    reach_this_fraction: f32,
+    in_this_many_seconds: f32,
+    dt: f32,
+) -> f32 {
+    1.0 - (1.0 - reach_this_fraction).powf(dt / in_this_many_seconds)
+}
+
+// ----------------------------------------------------------------------------
+
+/// An assert that is only active when `emath` is compiled with the `extra_asserts` feature
+/// or with the `extra_debug_asserts` feature in debug builds.
+#[macro_export]
+macro_rules! emath_assert {
+    ($($arg: tt)*) => {
+        if cfg!(any(
+            feature = "extra_asserts",
+            all(feature = "extra_debug_asserts", debug_assertions),
+        )) {
+            assert!($($arg)*);
+        }
+    }
+}
diff --git a/egui/crates/emath/src/numeric.rs b/egui/crates/emath/src/numeric.rs
new file mode 100644
index 0000000..4689ecc
--- /dev/null
+++ b/egui/crates/emath/src/numeric.rs
@@ -0,0 +1,74 @@
+/// Implemented for all builtin numeric types
+pub trait Numeric: Clone + Copy + PartialEq + PartialOrd + 'static {
+    /// Is this an integer type?
+    const INTEGRAL: bool;
+
+    /// Smallest finite value
+    const MIN: Self;
+
+    /// Largest finite value
+    const MAX: Self;
+
+    fn to_f64(self) -> f64;
+
+    fn from_f64(num: f64) -> Self;
+}
+
+macro_rules! impl_numeric_float {
+    ($t: ident) => {
+        impl Numeric for $t {
+            const INTEGRAL: bool = false;
+            const MIN: Self = std::$t::MIN;
+            const MAX: Self = std::$t::MAX;
+
+            #[inline(always)]
+            fn to_f64(self) -> f64 {
+                #[allow(trivial_numeric_casts)]
+                {
+                    self as f64
+                }
+            }
+
+            #[inline(always)]
+            fn from_f64(num: f64) -> Self {
+                #[allow(trivial_numeric_casts)]
+                {
+                    num as Self
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_numeric_integer {
+    ($t: ident) => {
+        impl Numeric for $t {
+            const INTEGRAL: bool = true;
+            const MIN: Self = std::$t::MIN;
+            const MAX: Self = std::$t::MAX;
+
+            #[inline(always)]
+            fn to_f64(self) -> f64 {
+                self as f64
+            }
+
+            #[inline(always)]
+            fn from_f64(num: f64) -> Self {
+                num as Self
+            }
+        }
+    };
+}
+
+impl_numeric_float!(f32);
+impl_numeric_float!(f64);
+impl_numeric_integer!(i8);
+impl_numeric_integer!(u8);
+impl_numeric_integer!(i16);
+impl_numeric_integer!(u16);
+impl_numeric_integer!(i32);
+impl_numeric_integer!(u32);
+impl_numeric_integer!(i64);
+impl_numeric_integer!(u64);
+impl_numeric_integer!(isize);
+impl_numeric_integer!(usize);
diff --git a/egui/crates/emath/src/pos2.rs b/egui/crates/emath/src/pos2.rs
new file mode 100644
index 0000000..bafbcf4
--- /dev/null
+++ b/egui/crates/emath/src/pos2.rs
@@ -0,0 +1,279 @@
+use std::ops::{Add, AddAssign, Sub, SubAssign};
+
+use crate::*;
+
+/// A position on screen.
+///
+/// Normally given in points (logical pixels).
+///
+/// Mathematically this is known as a "point", but the term position was chosen so not to
+/// conflict with the unit (one point = X physical pixels).
+#[repr(C)]
+#[derive(Clone, Copy, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Pos2 {
+    /// How far to the right.
+    pub x: f32,
+
+    /// How far down.
+    pub y: f32,
+    // implicit w = 1
+}
+
+/// `pos2(x, y) == Pos2::new(x, y)`
+#[inline(always)]
+pub const fn pos2(x: f32, y: f32) -> Pos2 {
+    Pos2 { x, y }
+}
+
+// ----------------------------------------------------------------------------
+// Compatibility and convenience conversions to and from [f32; 2]:
+
+impl From<[f32; 2]> for Pos2 {
+    #[inline(always)]
+    fn from(v: [f32; 2]) -> Self {
+        Self { x: v[0], y: v[1] }
+    }
+}
+
+impl From<&[f32; 2]> for Pos2 {
+    #[inline(always)]
+    fn from(v: &[f32; 2]) -> Self {
+        Self { x: v[0], y: v[1] }
+    }
+}
+
+impl From<Pos2> for [f32; 2] {
+    #[inline(always)]
+    fn from(v: Pos2) -> Self {
+        [v.x, v.y]
+    }
+}
+
+impl From<&Pos2> for [f32; 2] {
+    #[inline(always)]
+    fn from(v: &Pos2) -> Self {
+        [v.x, v.y]
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Compatibility and convenience conversions to and from (f32, f32):
+
+impl From<(f32, f32)> for Pos2 {
+    #[inline(always)]
+    fn from(v: (f32, f32)) -> Self {
+        Self { x: v.0, y: v.1 }
+    }
+}
+
+impl From<&(f32, f32)> for Pos2 {
+    #[inline(always)]
+    fn from(v: &(f32, f32)) -> Self {
+        Self { x: v.0, y: v.1 }
+    }
+}
+
+impl From<Pos2> for (f32, f32) {
+    #[inline(always)]
+    fn from(v: Pos2) -> Self {
+        (v.x, v.y)
+    }
+}
+
+impl From<&Pos2> for (f32, f32) {
+    #[inline(always)]
+    fn from(v: &Pos2) -> Self {
+        (v.x, v.y)
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Mint compatibility and convenience conversions
+
+#[cfg(feature = "mint")]
+impl From<mint::Point2<f32>> for Pos2 {
+    #[inline(always)]
+    fn from(v: mint::Point2<f32>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl From<Pos2> for mint::Point2<f32> {
+    #[inline(always)]
+    fn from(v: Pos2) -> Self {
+        Self { x: v.x, y: v.y }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+impl Pos2 {
+    /// The zero position, the origin.
+    /// The top left corner in a GUI.
+    /// Same as `Pos2::default()`.
+    pub const ZERO: Self = Self { x: 0.0, y: 0.0 };
+
+    #[inline(always)]
+    pub const fn new(x: f32, y: f32) -> Self {
+        Self { x, y }
+    }
+
+    /// The vector from origin to this position.
+    /// `p.to_vec2()` is equivalent to `p - Pos2::default()`.
+    #[inline(always)]
+    pub fn to_vec2(self) -> Vec2 {
+        Vec2 {
+            x: self.x,
+            y: self.y,
+        }
+    }
+
+    #[inline]
+    pub fn distance(self, other: Self) -> f32 {
+        (self - other).length()
+    }
+
+    #[inline]
+    pub fn distance_sq(self, other: Self) -> f32 {
+        (self - other).length_sq()
+    }
+
+    #[inline(always)]
+    pub fn floor(self) -> Self {
+        pos2(self.x.floor(), self.y.floor())
+    }
+
+    #[inline(always)]
+    pub fn round(self) -> Self {
+        pos2(self.x.round(), self.y.round())
+    }
+
+    #[inline(always)]
+    pub fn ceil(self) -> Self {
+        pos2(self.x.ceil(), self.y.ceil())
+    }
+
+    /// True if all members are also finite.
+    #[inline(always)]
+    pub fn is_finite(self) -> bool {
+        self.x.is_finite() && self.y.is_finite()
+    }
+
+    /// True if any member is NaN.
+    #[inline(always)]
+    pub fn any_nan(self) -> bool {
+        self.x.is_nan() || self.y.is_nan()
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn min(self, other: Self) -> Self {
+        pos2(self.x.min(other.x), self.y.min(other.y))
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn max(self, other: Self) -> Self {
+        pos2(self.x.max(other.x), self.y.max(other.y))
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn clamp(self, min: Self, max: Self) -> Self {
+        Self {
+            x: self.x.clamp(min.x, max.x),
+            y: self.y.clamp(min.y, max.y),
+        }
+    }
+}
+
+impl std::ops::Index<usize> for Pos2 {
+    type Output = f32;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &f32 {
+        match index {
+            0 => &self.x,
+            1 => &self.y,
+            _ => panic!("Pos2 index out of bounds: {}", index),
+        }
+    }
+}
+
+impl std::ops::IndexMut<usize> for Pos2 {
+    #[inline(always)]
+    fn index_mut(&mut self, index: usize) -> &mut f32 {
+        match index {
+            0 => &mut self.x,
+            1 => &mut self.y,
+            _ => panic!("Pos2 index out of bounds: {}", index),
+        }
+    }
+}
+
+impl Eq for Pos2 {}
+
+impl AddAssign<Vec2> for Pos2 {
+    #[inline(always)]
+    fn add_assign(&mut self, rhs: Vec2) {
+        *self = Pos2 {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        };
+    }
+}
+
+impl SubAssign<Vec2> for Pos2 {
+    #[inline(always)]
+    fn sub_assign(&mut self, rhs: Vec2) {
+        *self = Pos2 {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        };
+    }
+}
+
+impl Add<Vec2> for Pos2 {
+    type Output = Pos2;
+
+    #[inline(always)]
+    fn add(self, rhs: Vec2) -> Pos2 {
+        Pos2 {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        }
+    }
+}
+
+impl Sub for Pos2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn sub(self, rhs: Pos2) -> Vec2 {
+        Vec2 {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+impl Sub<Vec2> for Pos2 {
+    type Output = Pos2;
+
+    #[inline(always)]
+    fn sub(self, rhs: Vec2) -> Pos2 {
+        Pos2 {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+impl std::fmt::Debug for Pos2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[{:.1} {:.1}]", self.x, self.y)
+    }
+}
diff --git a/egui/crates/emath/src/rect.rs b/egui/crates/emath/src/rect.rs
new file mode 100644
index 0000000..6300bb1
--- /dev/null
+++ b/egui/crates/emath/src/rect.rs
@@ -0,0 +1,537 @@
+use std::f32::INFINITY;
+use std::ops::RangeInclusive;
+
+use crate::*;
+
+/// A rectangular region of space.
+///
+/// Usually a [`Rect`] has a positive (or zero) size,
+/// and then [`Self::min`] `<=` [`Self::max`].
+/// In these cases [`Self::min`] is the left-top corner
+/// and [`Self::max`] is the right-bottom corner.
+///
+/// A rectangle is allowed to have a negative size, which happens when the order
+/// of `min` and `max` are swapped. These are usually a sign of an error.
+///
+/// Normally the unit is points (logical pixels) in screen space coordinates.
+#[repr(C)]
+#[derive(Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Rect {
+    /// One of the corners of the rectangle, usually the left top one.
+    pub min: Pos2,
+
+    /// The other corner, opposing [`Self::min`]. Usually the right bottom one.
+    pub max: Pos2,
+}
+
+impl Rect {
+    /// Infinite rectangle that contains every point.
+    pub const EVERYTHING: Self = Self {
+        min: pos2(-INFINITY, -INFINITY),
+        max: pos2(INFINITY, INFINITY),
+    };
+
+    /// The inverse of [`Self::EVERYTHING`]: stretches from positive infinity to negative infinity.
+    /// Contains no points.
+    ///
+    /// This is useful as the seed for bounding boxes.
+    ///
+    /// # Example:
+    /// ```
+    /// # use emath::*;
+    /// let mut rect = Rect::NOTHING;
+    /// assert!(rect.size() == Vec2::splat(-f32::INFINITY));
+    /// assert!(rect.contains(pos2(0.0, 0.0)) == false);
+    /// rect.extend_with(pos2(2.0, 1.0));
+    /// rect.extend_with(pos2(0.0, 3.0));
+    /// assert_eq!(rect, Rect::from_min_max(pos2(0.0, 1.0), pos2(2.0, 3.0)))
+    /// ```
+    pub const NOTHING: Self = Self {
+        min: pos2(INFINITY, INFINITY),
+        max: pos2(-INFINITY, -INFINITY),
+    };
+
+    /// An invalid [`Rect`] filled with [`f32::NAN`];
+    pub const NAN: Self = Self {
+        min: pos2(f32::NAN, f32::NAN),
+        max: pos2(f32::NAN, f32::NAN),
+    };
+
+    #[inline(always)]
+    pub const fn from_min_max(min: Pos2, max: Pos2) -> Self {
+        Rect { min, max }
+    }
+
+    /// left-top corner plus a size (stretching right-down).
+    #[inline(always)]
+    pub fn from_min_size(min: Pos2, size: Vec2) -> Self {
+        Rect {
+            min,
+            max: min + size,
+        }
+    }
+
+    #[inline(always)]
+    pub fn from_center_size(center: Pos2, size: Vec2) -> Self {
+        Rect {
+            min: center - size * 0.5,
+            max: center + size * 0.5,
+        }
+    }
+
+    #[inline(always)]
+    pub fn from_x_y_ranges(x_range: RangeInclusive<f32>, y_range: RangeInclusive<f32>) -> Self {
+        Rect {
+            min: pos2(*x_range.start(), *y_range.start()),
+            max: pos2(*x_range.end(), *y_range.end()),
+        }
+    }
+
+    /// Returns the bounding rectangle of the two points.
+    #[inline]
+    pub fn from_two_pos(a: Pos2, b: Pos2) -> Self {
+        Rect {
+            min: pos2(a.x.min(b.x), a.y.min(b.y)),
+            max: pos2(a.x.max(b.x), a.y.max(b.y)),
+        }
+    }
+
+    /// Bounding-box around the points.
+    pub fn from_points(points: &[Pos2]) -> Self {
+        let mut rect = Rect::NOTHING;
+        for &p in points {
+            rect.extend_with(p);
+        }
+        rect
+    }
+
+    /// A [`Rect`] that contains every point to the right of the given X coordinate.
+    #[inline]
+    pub fn everything_right_of(left_x: f32) -> Self {
+        let mut rect = Self::EVERYTHING;
+        rect.set_left(left_x);
+        rect
+    }
+
+    /// A [`Rect`] that contains every point to the left of the given X coordinate.
+    #[inline]
+    pub fn everything_left_of(right_x: f32) -> Self {
+        let mut rect = Self::EVERYTHING;
+        rect.set_right(right_x);
+        rect
+    }
+
+    /// A [`Rect`] that contains every point below a certain y coordinate
+    #[inline]
+    pub fn everything_below(top_y: f32) -> Self {
+        let mut rect = Self::EVERYTHING;
+        rect.set_top(top_y);
+        rect
+    }
+
+    /// A [`Rect`] that contains every point above a certain y coordinate
+    #[inline]
+    pub fn everything_above(bottom_y: f32) -> Self {
+        let mut rect = Self::EVERYTHING;
+        rect.set_bottom(bottom_y);
+        rect
+    }
+
+    /// Expand by this much in each direction, keeping the center
+    #[must_use]
+    pub fn expand(self, amnt: f32) -> Self {
+        self.expand2(Vec2::splat(amnt))
+    }
+
+    /// Expand by this much in each direction, keeping the center
+    #[must_use]
+    pub fn expand2(self, amnt: Vec2) -> Self {
+        Rect::from_min_max(self.min - amnt, self.max + amnt)
+    }
+
+    /// Shrink by this much in each direction, keeping the center
+    #[must_use]
+    pub fn shrink(self, amnt: f32) -> Self {
+        self.shrink2(Vec2::splat(amnt))
+    }
+
+    /// Shrink by this much in each direction, keeping the center
+    #[must_use]
+    pub fn shrink2(self, amnt: Vec2) -> Self {
+        Rect::from_min_max(self.min + amnt, self.max - amnt)
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn translate(self, amnt: Vec2) -> Self {
+        Rect::from_min_size(self.min + amnt, self.size())
+    }
+
+    /// Rotate the bounds (will expand the [`Rect`])
+    #[must_use]
+    #[inline]
+    pub fn rotate_bb(self, rot: Rot2) -> Self {
+        let a = rot * self.left_top().to_vec2();
+        let b = rot * self.right_top().to_vec2();
+        let c = rot * self.left_bottom().to_vec2();
+        let d = rot * self.right_bottom().to_vec2();
+
+        Self::from_min_max(
+            a.min(b).min(c).min(d).to_pos2(),
+            a.max(b).max(c).max(d).to_pos2(),
+        )
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn intersects(self, other: Rect) -> bool {
+        self.min.x <= other.max.x
+            && other.min.x <= self.max.x
+            && self.min.y <= other.max.y
+            && other.min.y <= self.max.y
+    }
+
+    /// keep min
+    pub fn set_width(&mut self, w: f32) {
+        self.max.x = self.min.x + w;
+    }
+
+    /// keep min
+    pub fn set_height(&mut self, h: f32) {
+        self.max.y = self.min.y + h;
+    }
+
+    /// Keep size
+    pub fn set_center(&mut self, center: Pos2) {
+        *self = self.translate(center - self.center());
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn contains(&self, p: Pos2) -> bool {
+        self.min.x <= p.x && p.x <= self.max.x && self.min.y <= p.y && p.y <= self.max.y
+    }
+
+    #[must_use]
+    pub fn contains_rect(&self, other: Rect) -> bool {
+        self.contains(other.min) && self.contains(other.max)
+    }
+
+    /// Return the given points clamped to be inside the rectangle
+    /// Panics if [`Self::is_negative`].
+    #[must_use]
+    pub fn clamp(&self, p: Pos2) -> Pos2 {
+        p.clamp(self.min, self.max)
+    }
+
+    #[inline(always)]
+    pub fn extend_with(&mut self, p: Pos2) {
+        self.min = self.min.min(p);
+        self.max = self.max.max(p);
+    }
+
+    #[inline(always)]
+    /// Expand to include the given x coordinate
+    pub fn extend_with_x(&mut self, x: f32) {
+        self.min.x = self.min.x.min(x);
+        self.max.x = self.max.x.max(x);
+    }
+
+    #[inline(always)]
+    /// Expand to include the given y coordinate
+    pub fn extend_with_y(&mut self, y: f32) {
+        self.min.y = self.min.y.min(y);
+        self.max.y = self.max.y.max(y);
+    }
+
+    /// The union of two bounding rectangle, i.e. the minimum [`Rect`]
+    /// that contains both input rectangles.
+    #[inline(always)]
+    #[must_use]
+    pub fn union(self, other: Rect) -> Rect {
+        Rect {
+            min: self.min.min(other.min),
+            max: self.max.max(other.max),
+        }
+    }
+
+    /// The intersection of two [`Rect`], i.e. the area covered by both.
+    #[inline]
+    #[must_use]
+    pub fn intersect(self, other: Rect) -> Self {
+        Self {
+            min: self.min.max(other.min),
+            max: self.max.min(other.max),
+        }
+    }
+
+    #[inline(always)]
+    pub fn center(&self) -> Pos2 {
+        Pos2 {
+            x: (self.min.x + self.max.x) / 2.0,
+            y: (self.min.y + self.max.y) / 2.0,
+        }
+    }
+
+    #[inline(always)]
+    pub fn size(&self) -> Vec2 {
+        self.max - self.min
+    }
+
+    #[inline(always)]
+    pub fn width(&self) -> f32 {
+        self.max.x - self.min.x
+    }
+
+    #[inline(always)]
+    pub fn height(&self) -> f32 {
+        self.max.y - self.min.y
+    }
+
+    /// Width / height
+    ///
+    /// * `aspect_ratio < 1`: portrait / high
+    /// * `aspect_ratio = 1`: square
+    /// * `aspect_ratio > 1`: landscape / wide
+    pub fn aspect_ratio(&self) -> f32 {
+        self.width() / self.height()
+    }
+
+    /// `[2, 1]` for wide screen, and `[1, 2]` for portrait, etc.
+    /// At least one dimension = 1, the other >= 1
+    /// Returns the proportions required to letter-box a square view area.
+    pub fn square_proportions(&self) -> Vec2 {
+        let w = self.width();
+        let h = self.height();
+        if w > h {
+            vec2(w / h, 1.0)
+        } else {
+            vec2(1.0, h / w)
+        }
+    }
+
+    #[inline(always)]
+    pub fn area(&self) -> f32 {
+        self.width() * self.height()
+    }
+
+    /// The distance from the rect to the position.
+    ///
+    /// The distance is zero when the position is in the interior of the rectangle.
+    #[inline]
+    pub fn distance_to_pos(&self, pos: Pos2) -> f32 {
+        self.distance_sq_to_pos(pos).sqrt()
+    }
+
+    /// The distance from the rect to the position, squared.
+    ///
+    /// The distance is zero when the position is in the interior of the rectangle.
+    #[inline]
+    pub fn distance_sq_to_pos(&self, pos: Pos2) -> f32 {
+        let dx = if self.min.x > pos.x {
+            self.min.x - pos.x
+        } else if pos.x > self.max.x {
+            pos.x - self.max.x
+        } else {
+            0.0
+        };
+
+        let dy = if self.min.y > pos.y {
+            self.min.y - pos.y
+        } else if pos.y > self.max.y {
+            pos.y - self.max.y
+        } else {
+            0.0
+        };
+
+        dx * dx + dy * dy
+    }
+
+    /// Signed distance to the edge of the box.
+    ///
+    /// Negative inside the box.
+    pub fn signed_distance_to_pos(&self, pos: Pos2) -> f32 {
+        let edge_distances = (pos - self.center()).abs() - self.size() * 0.5;
+        let inside_dist = edge_distances.x.max(edge_distances.y).min(0.0);
+        let outside_dist = edge_distances.max(Vec2::ZERO).length();
+        inside_dist + outside_dist
+    }
+
+    /// Linearly interpolate so that `[0, 0]` is [`Self::min`] and
+    /// `[1, 1]` is [`Self::max`].
+    pub fn lerp(&self, t: Vec2) -> Pos2 {
+        Pos2 {
+            x: lerp(self.min.x..=self.max.x, t.x),
+            y: lerp(self.min.y..=self.max.y, t.y),
+        }
+    }
+
+    #[inline(always)]
+    pub fn x_range(&self) -> RangeInclusive<f32> {
+        self.min.x..=self.max.x
+    }
+
+    #[inline(always)]
+    pub fn y_range(&self) -> RangeInclusive<f32> {
+        self.min.y..=self.max.y
+    }
+
+    #[inline(always)]
+    pub fn bottom_up_range(&self) -> RangeInclusive<f32> {
+        self.max.y..=self.min.y
+    }
+
+    /// `width < 0 || height < 0`
+    #[inline(always)]
+    pub fn is_negative(&self) -> bool {
+        self.max.x < self.min.x || self.max.y < self.min.y
+    }
+
+    /// `width > 0 && height > 0`
+    #[inline(always)]
+    pub fn is_positive(&self) -> bool {
+        self.min.x < self.max.x && self.min.y < self.max.y
+    }
+
+    /// True if all members are also finite.
+    #[inline(always)]
+    pub fn is_finite(&self) -> bool {
+        self.min.is_finite() && self.max.is_finite()
+    }
+
+    /// True if any member is NaN.
+    #[inline(always)]
+    pub fn any_nan(self) -> bool {
+        self.min.any_nan() || self.max.any_nan()
+    }
+}
+
+/// ## Convenience functions (assumes origin is towards left top):
+impl Rect {
+    /// `min.x`
+    #[inline(always)]
+    pub fn left(&self) -> f32 {
+        self.min.x
+    }
+
+    /// `min.x`
+    #[inline(always)]
+    pub fn left_mut(&mut self) -> &mut f32 {
+        &mut self.min.x
+    }
+
+    /// `min.x`
+    #[inline(always)]
+    pub fn set_left(&mut self, x: f32) {
+        self.min.x = x;
+    }
+
+    /// `max.x`
+    #[inline(always)]
+    pub fn right(&self) -> f32 {
+        self.max.x
+    }
+
+    /// `max.x`
+    #[inline(always)]
+    pub fn right_mut(&mut self) -> &mut f32 {
+        &mut self.max.x
+    }
+
+    /// `max.x`
+    #[inline(always)]
+    pub fn set_right(&mut self, x: f32) {
+        self.max.x = x;
+    }
+
+    /// `min.y`
+    #[inline(always)]
+    pub fn top(&self) -> f32 {
+        self.min.y
+    }
+
+    /// `min.y`
+    #[inline(always)]
+    pub fn top_mut(&mut self) -> &mut f32 {
+        &mut self.min.y
+    }
+
+    /// `min.y`
+    #[inline(always)]
+    pub fn set_top(&mut self, y: f32) {
+        self.min.y = y;
+    }
+
+    /// `max.y`
+    #[inline(always)]
+    pub fn bottom(&self) -> f32 {
+        self.max.y
+    }
+
+    /// `max.y`
+    #[inline(always)]
+    pub fn bottom_mut(&mut self) -> &mut f32 {
+        &mut self.max.y
+    }
+
+    /// `max.y`
+    #[inline(always)]
+    pub fn set_bottom(&mut self, y: f32) {
+        self.max.y = y;
+    }
+
+    #[inline(always)]
+    pub fn left_top(&self) -> Pos2 {
+        pos2(self.left(), self.top())
+    }
+
+    #[inline(always)]
+    pub fn center_top(&self) -> Pos2 {
+        pos2(self.center().x, self.top())
+    }
+
+    #[inline(always)]
+    pub fn right_top(&self) -> Pos2 {
+        pos2(self.right(), self.top())
+    }
+
+    #[inline(always)]
+    pub fn left_center(&self) -> Pos2 {
+        pos2(self.left(), self.center().y)
+    }
+
+    #[inline(always)]
+    pub fn right_center(&self) -> Pos2 {
+        pos2(self.right(), self.center().y)
+    }
+
+    #[inline(always)]
+    pub fn left_bottom(&self) -> Pos2 {
+        pos2(self.left(), self.bottom())
+    }
+
+    #[inline(always)]
+    pub fn center_bottom(&self) -> Pos2 {
+        pos2(self.center().x, self.bottom())
+    }
+
+    #[inline(always)]
+    pub fn right_bottom(&self) -> Pos2 {
+        pos2(self.right(), self.bottom())
+    }
+}
+
+impl std::fmt::Debug for Rect {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[{:?} - {:?}]", self.min, self.max)
+    }
+}
+
+/// from (min, max) or (left top, right bottom)
+impl From<[Pos2; 2]> for Rect {
+    fn from([min, max]: [Pos2; 2]) -> Self {
+        Self { min, max }
+    }
+}
diff --git a/egui/crates/emath/src/rect_transform.rs b/egui/crates/emath/src/rect_transform.rs
new file mode 100644
index 0000000..de19fb6
--- /dev/null
+++ b/egui/crates/emath/src/rect_transform.rs
@@ -0,0 +1,83 @@
+use crate::{pos2, remap, remap_clamp, Pos2, Rect, Vec2};
+
+/// Linearly transforms positions from one [`Rect`] to another.
+///
+/// [`RectTransform`] stores the rectangles, and therefore supports clamping and culling.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct RectTransform {
+    from: Rect,
+    to: Rect,
+}
+
+impl RectTransform {
+    pub fn identity(from_and_to: Rect) -> Self {
+        Self::from_to(from_and_to, from_and_to)
+    }
+
+    pub fn from_to(from: Rect, to: Rect) -> Self {
+        Self { from, to }
+    }
+
+    pub fn from(&self) -> &Rect {
+        &self.from
+    }
+
+    pub fn to(&self) -> &Rect {
+        &self.to
+    }
+
+    /// The scale factors.
+    pub fn scale(&self) -> Vec2 {
+        self.to.size() / self.from.size()
+    }
+
+    pub fn inverse(&self) -> RectTransform {
+        Self::from_to(self.to, self.from)
+    }
+
+    /// Transforms the given coordinate in the `from` space to the `to` space.
+    pub fn transform_pos(&self, pos: Pos2) -> Pos2 {
+        pos2(
+            remap(pos.x, self.from.x_range(), self.to.x_range()),
+            remap(pos.y, self.from.y_range(), self.to.y_range()),
+        )
+    }
+
+    /// Transforms the given rectangle in the `in`-space to a rectangle in the `out`-space.
+    pub fn transform_rect(&self, rect: Rect) -> Rect {
+        Rect {
+            min: self.transform_pos(rect.min),
+            max: self.transform_pos(rect.max),
+        }
+    }
+
+    /// Transforms the given coordinate in the `from` space to the `to` space,
+    /// clamping if necessary.
+    pub fn transform_pos_clamped(&self, pos: Pos2) -> Pos2 {
+        pos2(
+            remap_clamp(pos.x, self.from.x_range(), self.to.x_range()),
+            remap_clamp(pos.y, self.from.y_range(), self.to.y_range()),
+        )
+    }
+}
+
+/// Transforms the position.
+impl std::ops::Mul<Pos2> for RectTransform {
+    type Output = Pos2;
+
+    fn mul(self, pos: Pos2) -> Pos2 {
+        self.transform_pos(pos)
+    }
+}
+
+/// Transforms the position.
+impl std::ops::Mul<Pos2> for &RectTransform {
+    type Output = Pos2;
+
+    fn mul(self, pos: Pos2) -> Pos2 {
+        self.transform_pos(pos)
+    }
+}
diff --git a/egui/crates/emath/src/rot2.rs b/egui/crates/emath/src/rot2.rs
new file mode 100644
index 0000000..e29f18f
--- /dev/null
+++ b/egui/crates/emath/src/rot2.rs
@@ -0,0 +1,198 @@
+use super::Vec2;
+
+// {s,c} represents the rotation matrix:
+//
+// | c -s |
+// | s  c |
+//
+// `vec2(c,s)` represents where the X axis will end up after rotation.
+//
+/// Represents a rotation in the 2D plane.
+//
+/// A rotation of 𝞃/4 = 90° rotates the X axis to the Y axis.
+//
+/// Normally a [`Rot2`] is normalized (unit-length).
+/// If not, it will also scale vectors.
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Rot2 {
+    /// angle.sin()
+    s: f32,
+
+    /// angle.cos()
+    c: f32,
+}
+
+/// Identity rotation
+impl Default for Rot2 {
+    /// Identity rotation
+    fn default() -> Self {
+        Self { s: 0.0, c: 1.0 }
+    }
+}
+
+impl Rot2 {
+    /// The identity rotation: nothing rotates
+    pub const IDENTITY: Self = Self { s: 0.0, c: 1.0 };
+
+    /// Angle is clockwise in radians.
+    /// A 𝞃/4 = 90° rotation means rotating the X axis to the Y axis.
+    pub fn from_angle(angle: f32) -> Self {
+        let (s, c) = angle.sin_cos();
+        Self { s, c }
+    }
+
+    pub fn angle(self) -> f32 {
+        self.s.atan2(self.c)
+    }
+
+    /// The factor by which vectors will be scaled.
+    pub fn length(self) -> f32 {
+        self.c.hypot(self.s)
+    }
+
+    pub fn length_squared(self) -> f32 {
+        self.c.powi(2) + self.s.powi(2)
+    }
+
+    pub fn is_finite(self) -> bool {
+        self.c.is_finite() && self.s.is_finite()
+    }
+
+    #[must_use]
+    pub fn inverse(self) -> Rot2 {
+        Self {
+            s: -self.s,
+            c: self.c,
+        } / self.length_squared()
+    }
+
+    #[must_use]
+    pub fn normalized(self) -> Self {
+        let l = self.length();
+        let ret = Self {
+            c: self.c / l,
+            s: self.s / l,
+        };
+        crate::emath_assert!(ret.is_finite());
+        ret
+    }
+}
+
+impl std::fmt::Debug for Rot2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Rot2 {{ angle: {:.1}°, length: {} }}",
+            self.angle().to_degrees(),
+            self.length()
+        )
+    }
+}
+
+impl std::ops::Mul<Rot2> for Rot2 {
+    type Output = Rot2;
+
+    fn mul(self, r: Rot2) -> Rot2 {
+        /*
+        |lc -ls| * |rc -rs|
+        |ls  lc|   |rs  rc|
+        */
+        Rot2 {
+            c: self.c * r.c - self.s * r.s,
+            s: self.s * r.c + self.c * r.s,
+        }
+    }
+}
+
+/// Rotates (and maybe scales) the vector.
+impl std::ops::Mul<Vec2> for Rot2 {
+    type Output = Vec2;
+
+    fn mul(self, v: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.c * v.x - self.s * v.y,
+            y: self.s * v.x + self.c * v.y,
+        }
+    }
+}
+
+/// Scales the rotor.
+impl std::ops::Mul<Rot2> for f32 {
+    type Output = Rot2;
+
+    fn mul(self, r: Rot2) -> Rot2 {
+        Rot2 {
+            c: self * r.c,
+            s: self * r.s,
+        }
+    }
+}
+
+/// Scales the rotor.
+impl std::ops::Mul<f32> for Rot2 {
+    type Output = Rot2;
+
+    fn mul(self, r: f32) -> Rot2 {
+        Rot2 {
+            c: self.c * r,
+            s: self.s * r,
+        }
+    }
+}
+
+/// Scales the rotor.
+impl std::ops::Div<f32> for Rot2 {
+    type Output = Rot2;
+
+    fn div(self, r: f32) -> Rot2 {
+        Rot2 {
+            c: self.c / r,
+            s: self.s / r,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Rot2;
+    use crate::vec2;
+
+    #[test]
+    fn test_rotation2() {
+        {
+            let angle = std::f32::consts::TAU / 6.0;
+            let rot = Rot2::from_angle(angle);
+            assert!((rot.angle() - angle).abs() < 1e-5);
+            assert!((rot * rot.inverse()).angle().abs() < 1e-5);
+            assert!((rot.inverse() * rot).angle().abs() < 1e-5);
+        }
+
+        {
+            let angle = std::f32::consts::TAU / 4.0;
+            let rot = Rot2::from_angle(angle);
+            assert!(((rot * vec2(1.0, 0.0)) - vec2(0.0, 1.0)).length() < 1e-5);
+        }
+
+        {
+            // Test rotation and scaling
+            let angle = std::f32::consts::TAU / 4.0;
+            let rot = 3.0 * Rot2::from_angle(angle);
+            let rotated = rot * vec2(1.0, 0.0);
+            let expected = vec2(0.0, 3.0);
+            assert!(
+                (rotated - expected).length() < 1e-5,
+                "Expected {:?} to equal {:?}. rot: {:?}",
+                rotated,
+                expected,
+                rot,
+            );
+
+            let undone = rot.inverse() * rot;
+            assert!(undone.angle().abs() < 1e-5);
+            assert!((undone.length() - 1.0).abs() < 1e-5,);
+        }
+    }
+}
diff --git a/egui/crates/emath/src/smart_aim.rs b/egui/crates/emath/src/smart_aim.rs
new file mode 100644
index 0000000..bd0f7b6
--- /dev/null
+++ b/egui/crates/emath/src/smart_aim.rs
@@ -0,0 +1,157 @@
+//! Find "simple" numbers is some range. Used by sliders.
+
+const NUM_DECIMALS: usize = 15;
+
+/// Find the "simplest" number in a closed range [min, max], i.e. the one with the fewest decimal digits.
+///
+/// So in the range `[0.83, 1.354]` you will get `1.0`, and for `[0.37, 0.48]` you will get `0.4`.
+/// This is used when dragging sliders etc to get the values that users are most likely to desire.
+/// This assumes a decimal centric user.
+pub fn best_in_range_f64(min: f64, max: f64) -> f64 {
+    // Avoid NaN if we can:
+    if min.is_nan() {
+        return max;
+    }
+    if max.is_nan() {
+        return min;
+    }
+
+    if max < min {
+        return best_in_range_f64(max, min);
+    }
+    if min == max {
+        return min;
+    }
+    if min <= 0.0 && 0.0 <= max {
+        return 0.0; // always prefer zero
+    }
+    if min < 0.0 {
+        return -best_in_range_f64(-max, -min);
+    }
+
+    // Prefer finite numbers:
+    if !max.is_finite() {
+        return min;
+    }
+    crate::emath_assert!(min.is_finite() && max.is_finite());
+
+    let min_exponent = min.log10();
+    let max_exponent = max.log10();
+
+    if min_exponent.floor() != max_exponent.floor() {
+        // pick the geometric center of the two:
+        let exponent = (min_exponent + max_exponent) / 2.0;
+        return 10.0_f64.powi(exponent.round() as i32);
+    }
+
+    if is_integer(min_exponent) {
+        return 10.0_f64.powf(min_exponent);
+    }
+    if is_integer(max_exponent) {
+        return 10.0_f64.powf(max_exponent);
+    }
+
+    let exp_factor = 10.0_f64.powi(max_exponent.floor() as i32);
+
+    let min_str = to_decimal_string(min / exp_factor);
+    let max_str = to_decimal_string(max / exp_factor);
+
+    // eprintln!("min_str: {:?}", min_str);
+    // eprintln!("max_str: {:?}", max_str);
+
+    let mut ret_str = [0; NUM_DECIMALS];
+
+    // Select the common prefix:
+    let mut i = 0;
+    while i < NUM_DECIMALS && max_str[i] == min_str[i] {
+        ret_str[i] = max_str[i];
+        i += 1;
+    }
+
+    if i < NUM_DECIMALS {
+        // Pick the deciding digit.
+        // Note that "to_decimal_string" rounds down, so we that's why we add 1 here
+        ret_str[i] = simplest_digit_closed_range(min_str[i] + 1, max_str[i]);
+    }
+
+    from_decimal_string(&ret_str) * exp_factor
+}
+
+fn is_integer(f: f64) -> bool {
+    f.round() == f
+}
+
+fn to_decimal_string(v: f64) -> [i32; NUM_DECIMALS] {
+    crate::emath_assert!(v < 10.0, "{:?}", v);
+    let mut digits = [0; NUM_DECIMALS];
+    let mut v = v.abs();
+    for r in &mut digits {
+        let digit = v.floor();
+        *r = digit as i32;
+        v -= digit;
+        v *= 10.0;
+    }
+    digits
+}
+
+fn from_decimal_string(s: &[i32]) -> f64 {
+    let mut ret: f64 = 0.0;
+    for (i, &digit) in s.iter().enumerate() {
+        ret += (digit as f64) * 10.0_f64.powi(-(i as i32));
+    }
+    ret
+}
+
+/// Find the simplest integer in the range [min, max]
+fn simplest_digit_closed_range(min: i32, max: i32) -> i32 {
+    crate::emath_assert!(1 <= min && min <= max && max <= 9);
+    if min <= 5 && 5 <= max {
+        5
+    } else {
+        (min + max) / 2
+    }
+}
+
+#[allow(clippy::approx_constant)]
+#[test]
+fn test_aim() {
+    assert_eq!(best_in_range_f64(-0.2, 0.0), 0.0, "Prefer zero");
+    assert_eq!(best_in_range_f64(-10_004.23, 3.14), 0.0, "Prefer zero");
+    assert_eq!(best_in_range_f64(-0.2, 100.0), 0.0, "Prefer zero");
+    assert_eq!(best_in_range_f64(0.2, 0.0), 0.0, "Prefer zero");
+    assert_eq!(best_in_range_f64(7.8, 17.8), 10.0);
+    assert_eq!(best_in_range_f64(99.0, 300.0), 100.0);
+    assert_eq!(best_in_range_f64(-99.0, -300.0), -100.0);
+    assert_eq!(best_in_range_f64(0.4, 0.9), 0.5, "Prefer ending on 5");
+    assert_eq!(best_in_range_f64(14.1, 19.99), 15.0, "Prefer ending on 5");
+    assert_eq!(best_in_range_f64(12.3, 65.9), 50.0, "Prefer leading 5");
+    assert_eq!(best_in_range_f64(493.0, 879.0), 500.0, "Prefer leading 5");
+    assert_eq!(best_in_range_f64(0.37, 0.48), 0.40);
+    // assert_eq!(best_in_range_f64(123.71, 123.76), 123.75); // TODO(emilk): we get 123.74999999999999 here
+    // assert_eq!(best_in_range_f32(123.71, 123.76), 123.75);
+    assert_eq!(best_in_range_f64(7.5, 16.3), 10.0);
+    assert_eq!(best_in_range_f64(7.5, 76.3), 10.0);
+    assert_eq!(best_in_range_f64(7.5, 763.3), 100.0);
+    assert_eq!(best_in_range_f64(7.5, 1_345.0), 100.0);
+    assert_eq!(best_in_range_f64(7.5, 123_456.0), 1000.0, "Geometric mean");
+    assert_eq!(best_in_range_f64(9.9999, 99.999), 10.0);
+    assert_eq!(best_in_range_f64(10.000, 99.999), 10.0);
+    assert_eq!(best_in_range_f64(10.001, 99.999), 50.0);
+    assert_eq!(best_in_range_f64(10.001, 100.000), 100.0);
+    assert_eq!(best_in_range_f64(99.999, 100.000), 100.0);
+    assert_eq!(best_in_range_f64(10.001, 100.001), 100.0);
+
+    use std::f64::{INFINITY, NAN, NEG_INFINITY};
+    assert!(best_in_range_f64(NAN, NAN).is_nan());
+    assert_eq!(best_in_range_f64(NAN, 1.2), 1.2);
+    assert_eq!(best_in_range_f64(NAN, INFINITY), INFINITY);
+    assert_eq!(best_in_range_f64(1.2, NAN), 1.2);
+    assert_eq!(best_in_range_f64(1.2, INFINITY), 1.2);
+    assert_eq!(best_in_range_f64(INFINITY, 1.2), 1.2);
+    assert_eq!(best_in_range_f64(NEG_INFINITY, 1.2), 0.0);
+    assert_eq!(best_in_range_f64(NEG_INFINITY, -2.7), -2.7);
+    assert_eq!(best_in_range_f64(INFINITY, INFINITY), INFINITY);
+    assert_eq!(best_in_range_f64(NEG_INFINITY, NEG_INFINITY), NEG_INFINITY);
+    assert_eq!(best_in_range_f64(NEG_INFINITY, INFINITY), 0.0);
+    assert_eq!(best_in_range_f64(INFINITY, NEG_INFINITY), 0.0);
+}
diff --git a/egui/crates/emath/src/vec2.rs b/egui/crates/emath/src/vec2.rs
new file mode 100644
index 0000000..ac70f9b
--- /dev/null
+++ b/egui/crates/emath/src/vec2.rs
@@ -0,0 +1,463 @@
+use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};
+
+/// A vector has a direction and length.
+/// A [`Vec2`] is often used to represent a size.
+///
+/// emath represents positions using [`crate::Pos2`].
+///
+/// Normally the units are points (logical pixels).
+#[repr(C)]
+#[derive(Clone, Copy, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Vec2 {
+    /// Rightwards. Width.
+    pub x: f32,
+
+    /// Downwards. Height.
+    pub y: f32,
+}
+
+/// `vec2(x, y) == Vec2::new(x, y)`
+#[inline(always)]
+pub const fn vec2(x: f32, y: f32) -> Vec2 {
+    Vec2 { x, y }
+}
+
+// ----------------------------------------------------------------------------
+// Compatibility and convenience conversions to and from [f32; 2]:
+
+impl From<[f32; 2]> for Vec2 {
+    #[inline(always)]
+    fn from(v: [f32; 2]) -> Self {
+        Self { x: v[0], y: v[1] }
+    }
+}
+
+impl From<&[f32; 2]> for Vec2 {
+    #[inline(always)]
+    fn from(v: &[f32; 2]) -> Self {
+        Self { x: v[0], y: v[1] }
+    }
+}
+
+impl From<Vec2> for [f32; 2] {
+    #[inline(always)]
+    fn from(v: Vec2) -> Self {
+        [v.x, v.y]
+    }
+}
+
+impl From<&Vec2> for [f32; 2] {
+    #[inline(always)]
+    fn from(v: &Vec2) -> Self {
+        [v.x, v.y]
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Compatibility and convenience conversions to and from (f32, f32):
+
+impl From<(f32, f32)> for Vec2 {
+    #[inline(always)]
+    fn from(v: (f32, f32)) -> Self {
+        Self { x: v.0, y: v.1 }
+    }
+}
+
+impl From<&(f32, f32)> for Vec2 {
+    #[inline(always)]
+    fn from(v: &(f32, f32)) -> Self {
+        Self { x: v.0, y: v.1 }
+    }
+}
+
+impl From<Vec2> for (f32, f32) {
+    #[inline(always)]
+    fn from(v: Vec2) -> Self {
+        (v.x, v.y)
+    }
+}
+
+impl From<&Vec2> for (f32, f32) {
+    #[inline(always)]
+    fn from(v: &Vec2) -> Self {
+        (v.x, v.y)
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Mint compatibility and convenience conversions
+
+#[cfg(feature = "mint")]
+impl From<mint::Vector2<f32>> for Vec2 {
+    #[inline]
+    fn from(v: mint::Vector2<f32>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl From<Vec2> for mint::Vector2<f32> {
+    #[inline]
+    fn from(v: Vec2) -> Self {
+        Self { x: v.x, y: v.y }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+impl Vec2 {
+    pub const X: Vec2 = Vec2 { x: 1.0, y: 0.0 };
+    pub const Y: Vec2 = Vec2 { x: 0.0, y: 1.0 };
+
+    pub const RIGHT: Vec2 = Vec2 { x: 1.0, y: 0.0 };
+    pub const LEFT: Vec2 = Vec2 { x: -1.0, y: 0.0 };
+    pub const UP: Vec2 = Vec2 { x: 0.0, y: -1.0 };
+    pub const DOWN: Vec2 = Vec2 { x: 0.0, y: 1.0 };
+
+    pub const ZERO: Self = Self { x: 0.0, y: 0.0 };
+    pub const INFINITY: Self = Self::splat(f32::INFINITY);
+
+    #[inline(always)]
+    pub const fn new(x: f32, y: f32) -> Self {
+        Self { x, y }
+    }
+
+    /// Set both `x` and `y` to the same value.
+    #[inline(always)]
+    pub const fn splat(v: f32) -> Self {
+        Self { x: v, y: v }
+    }
+
+    /// Treat this vector as a position.
+    /// `v.to_pos2()` is equivalent to `Pos2::default() + v`.
+    #[inline(always)]
+    pub fn to_pos2(self) -> crate::Pos2 {
+        crate::Pos2 {
+            x: self.x,
+            y: self.y,
+        }
+    }
+
+    /// Safe normalize: returns zero if input is zero.
+    #[must_use]
+    #[inline(always)]
+    pub fn normalized(self) -> Self {
+        let len = self.length();
+        if len <= 0.0 {
+            self
+        } else {
+            self / len
+        }
+    }
+
+    /// Rotates the vector by 90°, i.e positive X to positive Y
+    /// (clockwise in egui coordinates).
+    #[inline(always)]
+    pub fn rot90(self) -> Self {
+        vec2(self.y, -self.x)
+    }
+
+    #[inline(always)]
+    pub fn length(self) -> f32 {
+        self.x.hypot(self.y)
+    }
+
+    #[inline(always)]
+    pub fn length_sq(self) -> f32 {
+        self.x * self.x + self.y * self.y
+    }
+
+    /// Measures the angle of the vector.
+    ///
+    /// ```
+    /// # use emath::Vec2;
+    /// use std::f32::consts::TAU;
+    ///
+    /// assert_eq!(Vec2::ZERO.angle(), 0.0);
+    /// assert_eq!(Vec2::angled(0.0).angle(), 0.0);
+    /// assert_eq!(Vec2::angled(1.0).angle(), 1.0);
+    /// assert_eq!(Vec2::X.angle(), 0.0);
+    /// assert_eq!(Vec2::Y.angle(), 0.25 * TAU);
+    ///
+    /// assert_eq!(Vec2::RIGHT.angle(), 0.0);
+    /// assert_eq!(Vec2::DOWN.angle(), 0.25 * TAU);
+    /// assert_eq!(Vec2::UP.angle(), -0.25 * TAU);
+    /// ```
+    #[inline(always)]
+    pub fn angle(self) -> f32 {
+        self.y.atan2(self.x)
+    }
+
+    /// Create a unit vector with the given CW angle (in radians).
+    /// * An angle of zero gives the unit X axis.
+    /// * An angle of 𝞃/4 = 90° gives the unit Y axis.
+    ///
+    /// ```
+    /// # use emath::Vec2;
+    /// use std::f32::consts::TAU;
+    ///
+    /// assert_eq!(Vec2::angled(0.0), Vec2::X);
+    /// assert!((Vec2::angled(0.25 * TAU) - Vec2::Y).length() < 1e-5);
+    /// ```
+    #[inline(always)]
+    pub fn angled(angle: f32) -> Self {
+        vec2(angle.cos(), angle.sin())
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn floor(self) -> Self {
+        vec2(self.x.floor(), self.y.floor())
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn round(self) -> Self {
+        vec2(self.x.round(), self.y.round())
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn ceil(self) -> Self {
+        vec2(self.x.ceil(), self.y.ceil())
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn abs(self) -> Self {
+        vec2(self.x.abs(), self.y.abs())
+    }
+
+    /// True if all members are also finite.
+    #[inline(always)]
+    pub fn is_finite(self) -> bool {
+        self.x.is_finite() && self.y.is_finite()
+    }
+
+    /// True if any member is NaN.
+    #[inline(always)]
+    pub fn any_nan(self) -> bool {
+        self.x.is_nan() || self.y.is_nan()
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn min(self, other: Self) -> Self {
+        vec2(self.x.min(other.x), self.y.min(other.y))
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn max(self, other: Self) -> Self {
+        vec2(self.x.max(other.x), self.y.max(other.y))
+    }
+
+    /// The dot-product of two vectors.
+    #[inline]
+    pub fn dot(self, other: Self) -> f32 {
+        self.x * other.x + self.y * other.y
+    }
+
+    /// Returns the minimum of `self.x` and `self.y`.
+    #[must_use]
+    #[inline(always)]
+    pub fn min_elem(self) -> f32 {
+        self.x.min(self.y)
+    }
+
+    /// Returns the maximum of `self.x` and `self.y`.
+    #[inline(always)]
+    #[must_use]
+    pub fn max_elem(self) -> f32 {
+        self.x.max(self.y)
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn clamp(self, min: Self, max: Self) -> Self {
+        Self {
+            x: self.x.clamp(min.x, max.x),
+            y: self.y.clamp(min.y, max.y),
+        }
+    }
+}
+
+impl std::ops::Index<usize> for Vec2 {
+    type Output = f32;
+
+    #[inline(always)]
+    fn index(&self, index: usize) -> &f32 {
+        match index {
+            0 => &self.x,
+            1 => &self.y,
+            _ => panic!("Vec2 index out of bounds: {}", index),
+        }
+    }
+}
+
+impl std::ops::IndexMut<usize> for Vec2 {
+    #[inline(always)]
+    fn index_mut(&mut self, index: usize) -> &mut f32 {
+        match index {
+            0 => &mut self.x,
+            1 => &mut self.y,
+            _ => panic!("Vec2 index out of bounds: {}", index),
+        }
+    }
+}
+
+impl Eq for Vec2 {}
+
+impl Neg for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn neg(self) -> Vec2 {
+        vec2(-self.x, -self.y)
+    }
+}
+
+impl AddAssign for Vec2 {
+    #[inline(always)]
+    fn add_assign(&mut self, rhs: Vec2) {
+        *self = Vec2 {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        };
+    }
+}
+
+impl SubAssign for Vec2 {
+    #[inline(always)]
+    fn sub_assign(&mut self, rhs: Vec2) {
+        *self = Vec2 {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        };
+    }
+}
+
+impl Add for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn add(self, rhs: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        }
+    }
+}
+
+impl Sub for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn sub(self, rhs: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+/// Element-wise multiplication
+impl Mul<Vec2> for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn mul(self, vec: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.x * vec.x,
+            y: self.y * vec.y,
+        }
+    }
+}
+
+/// Element-wise division
+impl Div<Vec2> for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn div(self, rhs: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.x / rhs.x,
+            y: self.y / rhs.y,
+        }
+    }
+}
+
+impl MulAssign<f32> for Vec2 {
+    #[inline(always)]
+    fn mul_assign(&mut self, rhs: f32) {
+        self.x *= rhs;
+        self.y *= rhs;
+    }
+}
+
+impl Mul<f32> for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn mul(self, factor: f32) -> Vec2 {
+        Vec2 {
+            x: self.x * factor,
+            y: self.y * factor,
+        }
+    }
+}
+
+impl Mul<Vec2> for f32 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn mul(self, vec: Vec2) -> Vec2 {
+        Vec2 {
+            x: self * vec.x,
+            y: self * vec.y,
+        }
+    }
+}
+
+impl Div<f32> for Vec2 {
+    type Output = Vec2;
+
+    #[inline(always)]
+    fn div(self, factor: f32) -> Vec2 {
+        Vec2 {
+            x: self.x / factor,
+            y: self.y / factor,
+        }
+    }
+}
+
+impl std::fmt::Debug for Vec2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[{:.1} {:.1}]", self.x, self.y)
+    }
+}
+
+#[test]
+fn test_vec2() {
+    macro_rules! almost_eq {
+        ($left: expr, $right: expr) => {
+            let left = $left;
+            let right = $right;
+            assert!((left - right).abs() < 1e-6, "{} != {}", left, right);
+        };
+    }
+    use std::f32::consts::TAU;
+
+    assert_eq!(Vec2::ZERO.angle(), 0.0);
+    assert_eq!(Vec2::angled(0.0).angle(), 0.0);
+    assert_eq!(Vec2::angled(1.0).angle(), 1.0);
+    assert_eq!(Vec2::X.angle(), 0.0);
+    assert_eq!(Vec2::Y.angle(), 0.25 * TAU);
+
+    assert_eq!(Vec2::RIGHT.angle(), 0.0);
+    assert_eq!(Vec2::DOWN.angle(), 0.25 * TAU);
+    almost_eq!(Vec2::LEFT.angle(), 0.50 * TAU);
+    assert_eq!(Vec2::UP.angle(), -0.25 * TAU);
+}
diff --git a/egui/crates/epaint/CHANGELOG.md b/egui/crates/epaint/CHANGELOG.md
new file mode 100644
index 0000000..3d9574d
--- /dev/null
+++ b/egui/crates/epaint/CHANGELOG.md
@@ -0,0 +1,81 @@
+# epaint changelog
+All notable changes to the epaint crate will be documented in this file.
+
+
+## Unreleased
+
+
+## 0.21.0 - 2023-02-08
+* Improve the look of thin white lines ([#2437](https://github.com/emilk/egui/pull/2437)).
+* Don't render `\r` (Carriage Return) ([#2452](https://github.com/emilk/egui/pull/2452)).
+* Fix bug in `Mesh::split_to_u16` ([#2459](https://github.com/emilk/egui/pull/2459)).
+* Improve rendering of very thin rectangles.
+
+
+## 0.20.0 - 2022-12-08
+* ⚠️ BREAKING: Fix text being too small ([#2069](https://github.com/emilk/egui/pull/2069)).
+* ⚠️ BREAKING: epaint now expects integrations to do all color blending in gamma space ([#2071](https://github.com/emilk/egui/pull/2071)).
+* Improve mixed CJK/Latin line-breaking ([#1986](https://github.com/emilk/egui/pull/1986)).
+* Added `Fonts::has_glyph(s)` for querying if a glyph is supported ([#2202](https://github.com/emilk/egui/pull/2202)).
+* Added support for [thin space](https://en.wikipedia.org/wiki/Thin_space).
+* Split out color into its own crate, `ecolor` ([#2399](https://github.com/emilk/egui/pull/2399)).
+
+
+## 0.19.0 - 2022-08-20
+* MSRV (Minimum Supported Rust Version) is now `1.61.0` ([#1846](https://github.com/emilk/egui/pull/1846)).
+* Added `epaint::hex_color!` to create `Color32`'s from hex strings under the `color-hex` feature ([#1596](https://github.com/emilk/egui/pull/1596)).
+* Optimize tessellation of filled circles by 10x or more ([#1616](https://github.com/emilk/egui/pull/1616)).
+* Added opt-in feature `deadlock_detection` to detect double-lock of mutexes on the same thread ([#1619](https://github.com/emilk/egui/pull/1619)).
+* Texture loading now takes a `TextureOptions` with minification and magnification filters ([#2224](https://github.com/emilk/egui/pull/2224)).
+
+
+## 0.18.1 - 2022-05-01
+* Change `Shape::Callback` from `&dyn Any` to `&mut dyn Any` to support more backends.
+
+
+## 0.18.0 - 2022-04-30
+* MSRV (Minimum Supported Rust Version) is now `1.60.0` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Added `Shape::Callback` for backend-specific painting ([#1351](https://github.com/emilk/egui/pull/1351)).
+* Added more text wrapping options ([#1291](https://github.com/emilk/egui/pull/1291)):
+  * Added `TextWrapping` struct containing all wrapping options.
+  * Added `LayoutJob::wrap` field containing these options.
+  * Moved `LayoutJob::wrap_width` to `TextWrapping::max_width`.
+  * Added `TextWrapping::max_rows` to limit amount of rows the text should have.
+  * Added `TextWrapping::break_anywhere` to control should the text break at appropriate places or not.
+  * Added `TextWrapping::overflow_character` to specify what character should be used to represent clipped text.
+* Removed the `single_threaded/multi_threaded` flags - epaint is now always thread-safe ([#1390](https://github.com/emilk/egui/pull/1390)).
+* `Tessellator::from_options` is now `Tessellator::new` ([#1408](https://github.com/emilk/egui/pull/1408)).
+* Renamed `TessellationOptions::anti_alias` to `feathering` ([#1408](https://github.com/emilk/egui/pull/1408)).
+* Renamed `AlphaImage` to `FontImage` to discourage any other use for it ([#1412](https://github.com/emilk/egui/pull/1412)).
+* Dark text is darker and more readable on bright backgrounds ([#1412](https://github.com/emilk/egui/pull/1412)).
+* Fixed panic when tessellating a `Shape::Vec` containing meshes with differing `TextureId`s ([#1445](https://github.com/emilk/egui/pull/1445)).
+* Added `Shape::galley_with_color` which adds the functionality of `Painter::galley_with_color` into the Shape enum ([#1461](https://github.com/emilk/egui/pull/1461)).
+* Renamed the feature `convert_bytemuck` to `bytemuck` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Renamed the feature `serialize` to `serde` ([#1467](https://github.com/emilk/egui/pull/1467)).
+* Added line breaking rules for Japanese text ([#1498](https://github.com/emilk/egui/pull/1498)).
+* Optimize tessellation of circles and boxes with rounded corners ([#1547](https://github.com/emilk/egui/pull/1547)).
+
+
+## 0.17.0 - 2022-02-22
+* Much improved font selection ([#1154](https://github.com/emilk/egui/pull/1154)):
+  * Replaced `TextStyle` with `FontId` which lets you pick any font size and font family.
+  * Replaced `Fonts::font_image` with `font_image_delta` for partial font atlas updates.
+* Made the v-align and scale of user fonts tweakable ([#1241](https://github.com/emilk/egui/pull/1027)).
+* Added `ImageData` and `TextureManager` for loading images into textures ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Added `Shape::dashed_line_many` ([#1027](https://github.com/emilk/egui/pull/1027)).
+* Replaced `corner_radius: f32` with `rounding: Rounding`, allowing per-corner rounding settings ([#1206](https://github.com/emilk/egui/pull/1206)).
+* Fixed anti-aliasing of filled paths with counter-clockwise winding order.
+* Improve the anti-aliasing of filled paths with sharp corners, at the cost of these corners sometimes becoming badly extruded instead (see https://github.com/emilk/egui/issues/1226).
+
+
+## 0.16.0 - 2021-12-29
+* Anti-alias path ends ([#893](https://github.com/emilk/egui/pull/893)).
+* `Rgba` now implements `Hash` ([#886](https://github.com/emilk/egui/pull/886)).
+* Renamed `Texture` to `FontImage`.
+
+
+## 0.15.0 - 2021-10-24
+* `Fonts::layout_job`: New text layout engine allowing mixing fonts, colors and styles, with underlining and strikethrough.
+* New `CircleShape`, `PathShape`, `RectShape` and `TextShape` used in `enum Shape`.
+* Added support for rotated text (see `TextShape`).
+* Added `"convert_bytemuck"` feature.
diff --git a/egui/crates/epaint/Cargo.toml b/egui/crates/epaint/Cargo.toml
new file mode 100644
index 0000000..9c81bb6
--- /dev/null
+++ b/egui/crates/epaint/Cargo.toml
@@ -0,0 +1,105 @@
+[package]
+name = "epaint"
+version = "0.21.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+description = "Minimal 2D graphics library for GUI work"
+edition = "2021"
+rust-version = "1.65"
+homepage = "https://github.com/emilk/egui/tree/master/crates/epaint"
+license = "(MIT OR Apache-2.0) AND OFL-1.1 AND LicenseRef-UFL-1.0" # OFL and UFL used by default_fonts. See https://github.com/emilk/egui/issues/2321
+readme = "README.md"
+repository = "https://github.com/emilk/egui/tree/master/crates/epaint"
+categories = ["graphics", "gui"]
+keywords = ["graphics", "gui", "egui"]
+include = [
+  "../LICENSE-APACHE",
+  "../LICENSE-MIT",
+  "**/*.rs",
+  "Cargo.toml",
+  "fonts/*.ttf",
+  "fonts/*.txt",
+  "fonts/OFL.txt",
+  "fonts/UFL.txt",
+]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+
+
+[features]
+default = ["default_fonts"]
+
+## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast [`Vertex`] to `&[u8]`.
+bytemuck = ["dep:bytemuck", "emath/bytemuck", "ecolor/bytemuck"]
+
+## [`cint`](https://docs.rs/cint) enables interoperability with other color libraries.
+cint = ["ecolor/cint"]
+
+## Enable the [`hex_color`] macro.
+color-hex = ["ecolor/color-hex"]
+
+## This will automatically detect deadlocks due to double-locking on the same thread.
+## If your app freezes, you may want to enable this!
+## Only affects [`mutex::RwLock`] (which epaint and egui uses a lot).
+deadlock_detection = ["dep:backtrace"]
+
+## If set, epaint will use `include_bytes!` to bundle some fonts.
+## If you plan on specifying your own fonts you may disable this feature.
+default_fonts = []
+
+## Enable additional checks if debug assertions are enabled (debug builds).
+extra_debug_asserts = [
+  "emath/extra_debug_asserts",
+  "ecolor/extra_debug_asserts",
+]
+## Always enable additional checks.
+extra_asserts = ["emath/extra_asserts", "ecolor/extra_asserts"]
+
+## [`mint`](https://docs.rs/mint) enables interoperability with other math libraries such as [`glam`](https://docs.rs/glam) and [`nalgebra`](https://docs.rs/nalgebra).
+mint = ["emath/mint"]
+
+## Allow serialization using [`serde`](https://docs.rs/serde).
+serde = ["dep:serde", "ahash/serde", "emath/serde", "ecolor/serde"]
+
+## Change Vertex layout to be compatible with unity
+unity = []
+
+[dependencies]
+emath = { version = "0.21.0", path = "../emath" }
+ecolor = { version = "0.21.0", path = "../ecolor" }
+
+ab_glyph = "0.2.11"
+ahash = { version = "0.8.1", default-features = false, features = [
+  "no-rng", # we don't need DOS-protection, so we let users opt-in to it instead
+  "std",
+] }
+nohash-hasher = "0.2"
+
+#! ### Optional dependencies
+bytemuck = { version = "1.7.2", optional = true, features = ["derive"] }
+
+## Enable this when generating docs.
+document-features = { version = "0.2", optional = true }
+
+## Allow serialization using [`serde`](https://docs.rs/serde) .
+serde = { version = "1", optional = true, features = ["derive", "rc"] }
+
+# native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+backtrace = { version = "0.3", optional = true }
+parking_lot = "0.12"                             # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
+
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+atomic_refcell = "0.1" # Used instead of parking_lot on on wasm. See https://github.com/emilk/egui/issues/1401
+
+
+[dev-dependencies]
+criterion = { version = "0.4", default-features = false }
+
+
+[[bench]]
+name = "benchmark"
+harness = false
diff --git a/egui/crates/epaint/README.md b/egui/crates/epaint/README.md
new file mode 100644
index 0000000..fb5d9c1
--- /dev/null
+++ b/egui/crates/epaint/README.md
@@ -0,0 +1,11 @@
+# epaint - egui paint library
+
+[![Latest version](https://img.shields.io/crates/v/epaint.svg)](https://crates.io/crates/epaint)
+[![Documentation](https://docs.rs/epaint/badge.svg)](https://docs.rs/epaint)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
+A bare-bones 2D graphics library for turning simple 2D shapes and text into textured triangles.
+
+Made for [`egui`](https://github.com/emilk/egui/).
diff --git a/egui/crates/epaint/benches/benchmark.rs b/egui/crates/epaint/benches/benchmark.rs
new file mode 100644
index 0000000..126ec2b
--- /dev/null
+++ b/egui/crates/epaint/benches/benchmark.rs
@@ -0,0 +1,81 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use epaint::*;
+
+fn single_dashed_lines(c: &mut Criterion) {
+    c.bench_function("single_dashed_lines", move |b| {
+        b.iter(|| {
+            let mut v = Vec::new();
+
+            let line = [pos2(0.0, 0.0), pos2(50.0, 0.0), pos2(100.0, 1.0)];
+
+            for _ in 0..100 {
+                v.extend(Shape::dashed_line(
+                    &line,
+                    Stroke::new(1.5, Color32::RED),
+                    10.0,
+                    2.5,
+                ));
+            }
+
+            black_box(v);
+        });
+    });
+}
+
+fn many_dashed_lines(c: &mut Criterion) {
+    c.bench_function("many_dashed_lines", move |b| {
+        b.iter(|| {
+            let mut v = Vec::new();
+
+            let line = [pos2(0.0, 0.0), pos2(50.0, 0.0), pos2(100.0, 1.0)];
+
+            for _ in 0..100 {
+                Shape::dashed_line_many(&line, Stroke::new(1.5, Color32::RED), 10.0, 2.5, &mut v);
+            }
+
+            black_box(v);
+        });
+    });
+}
+
+fn tessellate_circles(c: &mut Criterion) {
+    c.bench_function("tessellate_circles_100k", move |b| {
+        let radii: [f32; 10] = [1.0, 2.0, 3.6, 4.0, 5.7, 8.0, 10.0, 13.0, 15.0, 17.0];
+        let mut clipped_shapes = vec![];
+        for r in radii {
+            for _ in 0..10_000 {
+                let clip_rect = Rect::from_min_size(Pos2::ZERO, Vec2::splat(1024.0));
+                let shape = Shape::circle_filled(Pos2::new(10.0, 10.0), r, Color32::WHITE);
+                clipped_shapes.push(ClippedShape(clip_rect, shape));
+            }
+        }
+        assert_eq!(clipped_shapes.len(), 100_000);
+
+        let pixels_per_point = 2.0;
+        let options = TessellationOptions::default();
+
+        let atlas = TextureAtlas::new([4096, 256]);
+        let font_tex_size = atlas.size();
+        let prepared_discs = atlas.prepared_discs();
+
+        b.iter(|| {
+            let clipped_primitive = tessellate_shapes(
+                pixels_per_point,
+                options,
+                font_tex_size,
+                prepared_discs.clone(),
+                clipped_shapes.clone(),
+            );
+            black_box(clipped_primitive);
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    single_dashed_lines,
+    many_dashed_lines,
+    tessellate_circles
+);
+criterion_main!(benches);
diff --git a/egui/crates/epaint/fonts/Hack-Regular.ttf b/egui/crates/epaint/fonts/Hack-Regular.ttf
new file mode 100644
index 0000000..92a90cb
Binary files /dev/null and b/egui/crates/epaint/fonts/Hack-Regular.ttf differ
diff --git a/egui/crates/epaint/fonts/Hack-Regular.txt b/egui/crates/epaint/fonts/Hack-Regular.txt
new file mode 100644
index 0000000..b0ec744
--- /dev/null
+++ b/egui/crates/epaint/fonts/Hack-Regular.txt
@@ -0,0 +1,31 @@
+The work in the Hack project is Copyright 2018 Source Foundry Authors and licensed under the MIT License
+
+The work in the DejaVu project was committed to the public domain.
+
+Bitstream Vera Sans Mono Copyright 2003 Bitstream Inc. and licensed under the Bitstream Vera License with Reserved Font Names "Bitstream" and "Vera"
+MIT License
+
+Copyright (c) 2018 Source Foundry Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+BITSTREAM VERA LICENSE
+
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the fonts accompanying this license ("Fonts") and associated documentation files (the "Font Software"), to reproduce and distribute the Font Software, including without limitation the rights to use, copy, merge, publish, distribute, and/or sell copies of the Font Software, and to permit persons to whom the Font Software is furnished to do so, subject to the following conditions:
+
+The above copyright and trademark notices and this permission notice shall be included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular the designs of glyphs or characters in the Fonts may be modified and additional glyphs or characters may be added to the Fonts, only if the fonts are renamed to names not containing either the words "Bitstream" or the word "Vera".
+
+This License becomes null and void to the extent applicable to Fonts or Font Software that has been modified and is distributed under the "Bitstream Vera" names.
+
+The Font Software may be sold as part of a larger software package but no copy of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
+
+Except as contained in this notice, the names of Gnome, the Gnome Foundation, and Bitstream Inc., shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Font Software without prior written authorization from the Gnome Foundation or Bitstream Inc., respectively. For further information, contact: fonts at gnome dot org.
diff --git a/egui/crates/epaint/fonts/NotoEmoji-Regular.ttf b/egui/crates/epaint/fonts/NotoEmoji-Regular.ttf
new file mode 100644
index 0000000..19b7bad
Binary files /dev/null and b/egui/crates/epaint/fonts/NotoEmoji-Regular.ttf differ
diff --git a/egui/crates/epaint/fonts/OFL.txt b/egui/crates/epaint/fonts/OFL.txt
new file mode 100644
index 0000000..d952d62
--- /dev/null
+++ b/egui/crates/epaint/fonts/OFL.txt
@@ -0,0 +1,92 @@
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to
+provide a free and open framework in which fonts may be shared and
+improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply to
+any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software
+components as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to,
+deleting, or substituting -- in part or in whole -- any of the
+components of the Original Version, by changing formats or by porting
+the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed,
+modify, redistribute, and sell modified and unmodified copies of the
+Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in
+Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the
+corresponding Copyright Holder. This restriction only applies to the
+primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created using
+the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/egui/crates/epaint/fonts/UFL.txt b/egui/crates/epaint/fonts/UFL.txt
new file mode 100755
index 0000000..6e722c8
--- /dev/null
+++ b/egui/crates/epaint/fonts/UFL.txt
@@ -0,0 +1,96 @@
+-------------------------------
+UBUNTU FONT LICENCE Version 1.0
+-------------------------------
+
+PREAMBLE
+This licence allows the licensed fonts to be used, studied, modified and
+redistributed freely. The fonts, including any derivative works, can be
+bundled, embedded, and redistributed provided the terms of this licence
+are met. The fonts and derivatives, however, cannot be released under
+any other licence. The requirement for fonts to remain under this
+licence does not require any document created using the fonts or their
+derivatives to be published under this licence, as long as the primary
+purpose of the document is not to be a vehicle for the distribution of
+the fonts.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this licence and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Original Version" refers to the collection of Font Software components
+as received under this licence.
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to
+a new environment.
+
+"Copyright Holder(s)" refers to all individuals and companies who have a
+copyright ownership of the Font Software.
+
+"Substantially Changed" refers to Modified Versions which can be easily
+identified as dissimilar to the Font Software by users of the Font
+Software comparing the Original Version with the Modified Version.
+
+To "Propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification and with or without charging
+a redistribution fee), making available to the public, and in some
+countries other activities as well.
+
+PERMISSION & CONDITIONS
+This licence does not grant any rights under trademark law and all such
+rights are reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to propagate the Font Software, subject to
+the below conditions:
+
+1) Each copy of the Font Software must contain the above copyright
+notice and this licence. These can be included either as stand-alone
+text files, human-readable headers or in the appropriate machine-
+readable metadata fields within text or binary files as long as those
+fields can be easily viewed by the user.
+
+2) The font name complies with the following:
+(a) The Original Version must retain its name, unmodified.
+(b) Modified Versions which are Substantially Changed must be renamed to
+avoid use of the name of the Original Version or similar names entirely.
+(c) Modified Versions which are not Substantially Changed must be
+renamed to both (i) retain the name of the Original Version and (ii) add
+additional naming elements to distinguish the Modified Version from the
+Original Version. The name of such Modified Versions must be the name of
+the Original Version, with "derivative X" where X represents the name of
+the new work, appended to that name.
+
+3) The name(s) of the Copyright Holder(s) and any contributor to the
+Font Software shall not be used to promote, endorse or advertise any
+Modified Version, except (i) as required by this licence, (ii) to
+acknowledge the contribution(s) of the Copyright Holder(s) or (iii) with
+their explicit written permission.
+
+4) The Font Software, modified or unmodified, in part or in whole, must
+be distributed entirely under this licence, and must not be distributed
+under any other licence. The requirement for fonts to remain under this
+licence does not affect any document created using the Font Software,
+except any version of the Font Software extracted from a document
+created using the Font Software may only be distributed under this
+licence.
+
+TERMINATION
+This licence becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.
diff --git a/egui/crates/epaint/fonts/Ubuntu-Light.ttf b/egui/crates/epaint/fonts/Ubuntu-Light.ttf
new file mode 100755
index 0000000..0e9f90d
Binary files /dev/null and b/egui/crates/epaint/fonts/Ubuntu-Light.ttf differ
diff --git a/egui/crates/epaint/fonts/emoji-icon-font-mit-license.txt b/egui/crates/epaint/fonts/emoji-icon-font-mit-license.txt
new file mode 100644
index 0000000..99016e1
--- /dev/null
+++ b/egui/crates/epaint/fonts/emoji-icon-font-mit-license.txt
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2014 John Slegers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/egui/crates/epaint/fonts/emoji-icon-font.ttf b/egui/crates/epaint/fonts/emoji-icon-font.ttf
new file mode 100644
index 0000000..8064083
Binary files /dev/null and b/egui/crates/epaint/fonts/emoji-icon-font.ttf differ
diff --git a/egui/crates/epaint/fonts/list_fonts.py b/egui/crates/epaint/fonts/list_fonts.py
new file mode 100644
index 0000000..de1a1e7
--- /dev/null
+++ b/egui/crates/epaint/fonts/list_fonts.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+from fontTools.ttLib import TTFont
+from fontTools.unicode import Unicode
+from itertools import chain
+import sys
+
+ttf = TTFont(sys.argv[1], 0, verbose=0, allowVID=0,
+             ignoreDecompileErrors=True,
+             fontNumber=-1)
+
+chars = chain.from_iterable([y + (Unicode[y[0]],)
+                             for y in x.cmap.items()] for x in ttf["cmap"].tables)
+
+
+all_codepoints = {}
+
+for entry in chars:
+    codepoint = entry[0]
+    short_name = entry[1]
+    long_name = entry[2].lower()
+    if False:
+        print(f'(0x{codepoint:02X}, "{short_name}", "{long_name}"),')
+    else:
+        name = short_name if long_name == "????" else long_name
+        # print(f'(0x{codepoint:02X}, "{name}"),')
+        all_codepoints[codepoint] = name
+
+for codepoint in sorted(all_codepoints.keys()):
+    name = all_codepoints[codepoint]
+    print(f'(0x{codepoint:02X}, \'{chr(codepoint)}\', "{name}"),')
+
+ttf.close()
diff --git a/egui/crates/epaint/src/bezier.rs b/egui/crates/epaint/src/bezier.rs
new file mode 100644
index 0000000..d379a17
--- /dev/null
+++ b/egui/crates/epaint/src/bezier.rs
@@ -0,0 +1,1124 @@
+#![allow(clippy::many_single_char_names)]
+use std::ops::Range;
+
+use crate::{shape::Shape, Color32, PathShape, Stroke};
+use emath::*;
+
+// ----------------------------------------------------------------------------
+
+/// A cubic [Bézier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+///
+/// See also [`QuadraticBezierShape`].
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct CubicBezierShape {
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle points are the control points.
+    pub points: [Pos2; 4],
+    pub closed: bool,
+
+    pub fill: Color32,
+    pub stroke: Stroke,
+}
+
+impl CubicBezierShape {
+    /// Creates a cubic Bézier curve based on 4 points and stroke.
+    ///
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle points are the control points.
+    pub fn from_points_stroke(
+        points: [Pos2; 4],
+        closed: bool,
+        fill: Color32,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        Self {
+            points,
+            closed,
+            fill,
+            stroke: stroke.into(),
+        }
+    }
+
+    /// Transform the curve with the given transform.
+    pub fn transform(&self, transform: &RectTransform) -> Self {
+        let mut points = [Pos2::default(); 4];
+        for (i, origin_point) in self.points.iter().enumerate() {
+            points[i] = transform * *origin_point;
+        }
+        CubicBezierShape {
+            points,
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    /// Convert the cubic Bézier curve to one or two [`PathShape`]'s.
+    /// When the curve is closed and it has to intersect with the base line, it will be converted into two shapes.
+    /// Otherwise, it will be converted into one shape.
+    /// The `tolerance` will be used to control the max distance between the curve and the base line.
+    /// The `epsilon` is used when comparing two floats.
+    pub fn to_path_shapes(&self, tolerance: Option<f32>, epsilon: Option<f32>) -> Vec<PathShape> {
+        let mut pathshapes = Vec::new();
+        let mut points_vec = self.flatten_closed(tolerance, epsilon);
+        for points in points_vec.drain(..) {
+            let pathshape = PathShape {
+                points,
+                closed: self.closed,
+                fill: self.fill,
+                stroke: self.stroke,
+            };
+            pathshapes.push(pathshape);
+        }
+        pathshapes
+    }
+
+    /// The visual bounding rectangle (includes stroke width)
+    pub fn visual_bounding_rect(&self) -> Rect {
+        if self.fill == Color32::TRANSPARENT && self.stroke.is_empty() {
+            Rect::NOTHING
+        } else {
+            self.logical_bounding_rect().expand(self.stroke.width / 2.0)
+        }
+    }
+
+    /// Logical bounding rectangle (ignoring stroke width)
+    pub fn logical_bounding_rect(&self) -> Rect {
+        //temporary solution
+        let (mut min_x, mut max_x) = if self.points[0].x < self.points[3].x {
+            (self.points[0].x, self.points[3].x)
+        } else {
+            (self.points[3].x, self.points[0].x)
+        };
+        let (mut min_y, mut max_y) = if self.points[0].y < self.points[3].y {
+            (self.points[0].y, self.points[3].y)
+        } else {
+            (self.points[3].y, self.points[0].y)
+        };
+
+        // find the inflection points and get the x value
+        cubic_for_each_local_extremum(
+            self.points[0].x,
+            self.points[1].x,
+            self.points[2].x,
+            self.points[3].x,
+            &mut |t| {
+                let x = self.sample(t).x;
+                if x < min_x {
+                    min_x = x;
+                }
+                if x > max_x {
+                    max_x = x;
+                }
+            },
+        );
+
+        // find the inflection points and get the y value
+        cubic_for_each_local_extremum(
+            self.points[0].y,
+            self.points[1].y,
+            self.points[2].y,
+            self.points[3].y,
+            &mut |t| {
+                let y = self.sample(t).y;
+                if y < min_y {
+                    min_y = y;
+                }
+                if y > max_y {
+                    max_y = y;
+                }
+            },
+        );
+
+        Rect {
+            min: Pos2 { x: min_x, y: min_y },
+            max: Pos2 { x: max_x, y: max_y },
+        }
+    }
+
+    /// split the original cubic curve into a new one within a range.
+    pub fn split_range(&self, t_range: Range<f32>) -> Self {
+        crate::epaint_assert!(
+            t_range.start >= 0.0 && t_range.end <= 1.0 && t_range.start <= t_range.end,
+            "range should be in [0.0,1.0]"
+        );
+
+        let from = self.sample(t_range.start);
+        let to = self.sample(t_range.end);
+
+        let d_from = self.points[1] - self.points[0].to_vec2();
+        let d_ctrl = self.points[2] - self.points[1].to_vec2();
+        let d_to = self.points[3] - self.points[2].to_vec2();
+        let q = QuadraticBezierShape {
+            points: [d_from, d_ctrl, d_to],
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        };
+        let delta_t = t_range.end - t_range.start;
+        let q_start = q.sample(t_range.start);
+        let q_end = q.sample(t_range.end);
+        let ctrl1 = from + q_start.to_vec2() * delta_t;
+        let ctrl2 = to - q_end.to_vec2() * delta_t;
+        CubicBezierShape {
+            points: [from, ctrl1, ctrl2, to],
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    // copied from lyon::geom::flattern_cubic.rs
+    // Computes the number of quadratic bézier segments to approximate a cubic one.
+    // Derived by Raph Levien from section 10.6 of Sedeberg's CAGD notes
+    // https://scholarsarchive.byu.edu/cgi/viewcontent.cgi?article=1000&context=facpub#section.10.6
+    // and the error metric from the caffein owl blog post http://caffeineowl.com/graphics/2d/vectorial/cubic2quad01.html
+    pub fn num_quadratics(&self, tolerance: f32) -> u32 {
+        crate::epaint_assert!(tolerance > 0.0, "the tolerance should be positive");
+
+        let x =
+            self.points[0].x - 3.0 * self.points[1].x + 3.0 * self.points[2].x - self.points[3].x;
+        let y =
+            self.points[0].y - 3.0 * self.points[1].y + 3.0 * self.points[2].y - self.points[3].y;
+        let err = x * x + y * y;
+
+        (err / (432.0 * tolerance * tolerance))
+            .powf(1.0 / 6.0)
+            .ceil()
+            .max(1.0) as u32
+    }
+
+    /// Find out the t value for the point where the curve is intersected with the base line.
+    /// The base line is the line from P0 to P3.
+    /// If the curve only has two intersection points with the base line, they should be 0.0 and 1.0.
+    /// In this case, the "fill" will be simple since the curve is a convex line.
+    /// If the curve has more than two intersection points with the base line, the "fill" will be a problem.
+    /// We need to find out where is the 3rd t value (0<t<1)
+    /// And the original cubic curve will be split into two curves (0.0..t and t..1.0).
+    /// B(t) = (1-t)^3*P0 + 3*t*(1-t)^2*P1 + 3*t^2*(1-t)*P2 + t^3*P3
+    /// or B(t) = (P3 - 3*P2 + 3*P1 - P0)*t^3 + (3*P2 - 6*P1 + 3*P0)*t^2 + (3*P1 - 3*P0)*t + P0
+    /// this B(t) should be on the line between P0 and P3. Therefore:
+    /// (B.x - P0.x)/(P3.x - P0.x) = (B.y - P0.y)/(P3.y - P0.y), or:
+    /// B.x * (P3.y - P0.y) - B.y * (P3.x - P0.x) + P0.x * (P0.y - P3.y) + P0.y * (P3.x - P0.x) = 0
+    /// B.x = (P3.x - 3 * P2.x + 3 * P1.x - P0.x) * t^3 + (3 * P2.x - 6 * P1.x + 3 * P0.x) * t^2 + (3 * P1.x - 3 * P0.x) * t + P0.x
+    /// B.y = (P3.y - 3 * P2.y + 3 * P1.y - P0.y) * t^3 + (3 * P2.y - 6 * P1.y + 3 * P0.y) * t^2 + (3 * P1.y - 3 * P0.y) * t + P0.y
+    /// Combine the above three equations and iliminate B.x and B.y, we get:
+    /// t^3 * ( (P3.x - 3*P2.x + 3*P1.x - P0.x) * (P3.y - P0.y) - (P3.y - 3*P2.y + 3*P1.y - P0.y) * (P3.x - P0.x))
+    /// + t^2 * ( (3 * P2.x - 6 * P1.x + 3 * P0.x) * (P3.y - P0.y) - (3 * P2.y - 6 * P1.y + 3 * P0.y) * (P3.x - P0.x))
+    /// + t^1 * ( (3 * P1.x - 3 * P0.x) * (P3.y - P0.y) - (3 * P1.y - 3 * P0.y) * (P3.x - P0.x))
+    /// + (P0.x * (P3.y - P0.y) - P0.y * (P3.x - P0.x)) + P0.x * (P0.y - P3.y) + P0.y * (P3.x - P0.x)
+    /// = 0
+    /// or a * t^3 + b * t^2 + c * t + d = 0
+    ///
+    /// let x = t - b / (3 * a), then we have:
+    /// x^3 + p * x + q = 0, where:
+    /// p = (3.0 * a * c - b^2) / (3.0 * a^2)
+    /// q = (2.0 * b^3 - 9.0 * a * b * c + 27.0 * a^2 * d) / (27.0 * a^3)
+    ///
+    /// when p > 0, there will be one real root, two complex roots
+    /// when p = 0, there will be two real roots, when p=q=0, there will be three real roots but all 0.
+    /// when p < 0, there will be three unique real roots. this is what we need. (x1, x2, x3)
+    ///  t = x + b / (3 * a), then we have: t1, t2, t3.
+    /// the one between 0.0 and 1.0 is what we need.
+    /// <`https://baike.baidu.com/item/%E4%B8%80%E5%85%83%E4%B8%89%E6%AC%A1%E6%96%B9%E7%A8%8B/8388473 /`>
+    ///
+    pub fn find_cross_t(&self, epsilon: f32) -> Option<f32> {
+        let p0 = self.points[0];
+        let p1 = self.points[1];
+        let p2 = self.points[2];
+        let p3 = self.points[3];
+
+        let a = (p3.x - 3.0 * p2.x + 3.0 * p1.x - p0.x) * (p3.y - p0.y)
+            - (p3.y - 3.0 * p2.y + 3.0 * p1.y - p0.y) * (p3.x - p0.x);
+        let b = (3.0 * p2.x - 6.0 * p1.x + 3.0 * p0.x) * (p3.y - p0.y)
+            - (3.0 * p2.y - 6.0 * p1.y + 3.0 * p0.y) * (p3.x - p0.x);
+        let c =
+            (3.0 * p1.x - 3.0 * p0.x) * (p3.y - p0.y) - (3.0 * p1.y - 3.0 * p0.y) * (p3.x - p0.x);
+        let d = p0.x * (p3.y - p0.y) - p0.y * (p3.x - p0.x)
+            + p0.x * (p0.y - p3.y)
+            + p0.y * (p3.x - p0.x);
+
+        let h = -b / (3.0 * a);
+        let p = (3.0 * a * c - b * b) / (3.0 * a * a);
+        let q = (2.0 * b * b * b - 9.0 * a * b * c + 27.0 * a * a * d) / (27.0 * a * a * a);
+
+        if p > 0.0 {
+            return None;
+        }
+        let r = (-1.0 * (p / 3.0).powi(3)).sqrt();
+        let theta = (-1.0 * q / (2.0 * r)).acos() / 3.0;
+
+        let t1 = 2.0 * r.cbrt() * theta.cos() + h;
+        let t2 = 2.0 * r.cbrt() * (theta + 120.0 * std::f32::consts::PI / 180.0).cos() + h;
+        let t3 = 2.0 * r.cbrt() * (theta + 240.0 * std::f32::consts::PI / 180.0).cos() + h;
+
+        if t1 > epsilon && t1 < 1.0 - epsilon {
+            return Some(t1);
+        }
+        if t2 > epsilon && t2 < 1.0 - epsilon {
+            return Some(t2);
+        }
+        if t3 > epsilon && t3 < 1.0 - epsilon {
+            return Some(t3);
+        }
+        None
+    }
+
+    /// Calculate the point (x,y) at t based on the cubic Bézier curve equation.
+    /// t is in [0.0,1.0]
+    /// [Bézier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Cubic_B.C3.A9zier_curves)
+    ///
+    pub fn sample(&self, t: f32) -> Pos2 {
+        crate::epaint_assert!(
+            t >= 0.0 && t <= 1.0,
+            "the sample value should be in [0.0,1.0]"
+        );
+
+        let h = 1.0 - t;
+        let a = t * t * t;
+        let b = 3.0 * t * t * h;
+        let c = 3.0 * t * h * h;
+        let d = h * h * h;
+        let result = self.points[3].to_vec2() * a
+            + self.points[2].to_vec2() * b
+            + self.points[1].to_vec2() * c
+            + self.points[0].to_vec2() * d;
+        result.to_pos2()
+    }
+
+    /// find a set of points that approximate the cubic Bézier curve.
+    /// the number of points is determined by the tolerance.
+    /// the points may not be evenly distributed in the range [0.0,1.0] (t value)
+    pub fn flatten(&self, tolerance: Option<f32>) -> Vec<Pos2> {
+        let tolerance = tolerance.unwrap_or((self.points[0].x - self.points[3].x).abs() * 0.001);
+        let mut result = vec![self.points[0]];
+        self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+            result.push(p);
+        });
+        result
+    }
+
+    /// find a set of points that approximate the cubic Bézier curve.
+    /// the number of points is determined by the tolerance.
+    /// the points may not be evenly distributed in the range [0.0,1.0] (t value)
+    /// this api will check whether the curve will cross the base line or not when closed = true.
+    /// The result will be a vec of vec of Pos2. it will store two closed aren in different vec.
+    /// The epsilon is used to compare a float value.
+    pub fn flatten_closed(&self, tolerance: Option<f32>, epsilon: Option<f32>) -> Vec<Vec<Pos2>> {
+        let tolerance = tolerance.unwrap_or((self.points[0].x - self.points[3].x).abs() * 0.001);
+        let epsilon = epsilon.unwrap_or(1.0e-5);
+        let mut result = Vec::new();
+        let mut first_half = Vec::new();
+        let mut second_half = Vec::new();
+        let mut flipped = false;
+        first_half.push(self.points[0]);
+
+        let cross = self.find_cross_t(epsilon);
+        match cross {
+            Some(cross) => {
+                if self.closed {
+                    self.for_each_flattened_with_t(tolerance, &mut |p, t| {
+                        if t < cross {
+                            first_half.push(p);
+                        } else {
+                            if !flipped {
+                                // when just crossed the base line, flip the order of the points
+                                // add the cross point to the first half as the last point
+                                // and add the cross point to the second half as the first point
+                                flipped = true;
+                                let cross_point = self.sample(cross);
+                                first_half.push(cross_point);
+                                second_half.push(cross_point);
+                            }
+                            second_half.push(p);
+                        }
+                    });
+                } else {
+                    self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+                        first_half.push(p);
+                    });
+                }
+            }
+            None => {
+                self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+                    first_half.push(p);
+                });
+            }
+        }
+
+        result.push(first_half);
+        if !second_half.is_empty() {
+            result.push(second_half);
+        }
+        result
+    }
+    // from lyon_geom::cubic_bezier.rs
+    /// Iterates through the curve invoking a callback at each point.
+    pub fn for_each_flattened_with_t<F: FnMut(Pos2, f32)>(&self, tolerance: f32, callback: &mut F) {
+        flatten_cubic_bezier_with_t(self, tolerance, callback);
+    }
+}
+
+impl From<CubicBezierShape> for Shape {
+    #[inline(always)]
+    fn from(shape: CubicBezierShape) -> Self {
+        Self::CubicBezier(shape)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A quadratic [Bézier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+///
+/// See also [`CubicBezierShape`].
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct QuadraticBezierShape {
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle point is the control points.
+    pub points: [Pos2; 3],
+    pub closed: bool,
+
+    pub fill: Color32,
+    pub stroke: Stroke,
+}
+
+impl QuadraticBezierShape {
+    /// Create a new quadratic Bézier shape based on the 3 points and stroke.
+    ///
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle point is the control points.
+    /// The points should be in the order [start, control, end]
+    pub fn from_points_stroke(
+        points: [Pos2; 3],
+        closed: bool,
+        fill: Color32,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        QuadraticBezierShape {
+            points,
+            closed,
+            fill,
+            stroke: stroke.into(),
+        }
+    }
+
+    /// Transform the curve with the given transform.
+    pub fn transform(&self, transform: &RectTransform) -> Self {
+        let mut points = [Pos2::default(); 3];
+        for (i, origin_point) in self.points.iter().enumerate() {
+            points[i] = transform * *origin_point;
+        }
+        QuadraticBezierShape {
+            points,
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    /// Convert the quadratic Bézier curve to one [`PathShape`].
+    /// The `tolerance` will be used to control the max distance between the curve and the base line.
+    pub fn to_path_shape(&self, tolerance: Option<f32>) -> PathShape {
+        let points = self.flatten(tolerance);
+        PathShape {
+            points,
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    /// The visual bounding rectangle (includes stroke width)
+    pub fn visual_bounding_rect(&self) -> Rect {
+        if self.fill == Color32::TRANSPARENT && self.stroke.is_empty() {
+            Rect::NOTHING
+        } else {
+            self.logical_bounding_rect().expand(self.stroke.width / 2.0)
+        }
+    }
+
+    /// Logical bounding rectangle (ignoring stroke width)
+    pub fn logical_bounding_rect(&self) -> Rect {
+        let (mut min_x, mut max_x) = if self.points[0].x < self.points[2].x {
+            (self.points[0].x, self.points[2].x)
+        } else {
+            (self.points[2].x, self.points[0].x)
+        };
+        let (mut min_y, mut max_y) = if self.points[0].y < self.points[2].y {
+            (self.points[0].y, self.points[2].y)
+        } else {
+            (self.points[2].y, self.points[0].y)
+        };
+
+        quadratic_for_each_local_extremum(
+            self.points[0].x,
+            self.points[1].x,
+            self.points[2].x,
+            &mut |t| {
+                let x = self.sample(t).x;
+                if x < min_x {
+                    min_x = x;
+                }
+                if x > max_x {
+                    max_x = x;
+                }
+            },
+        );
+
+        quadratic_for_each_local_extremum(
+            self.points[0].y,
+            self.points[1].y,
+            self.points[2].y,
+            &mut |t| {
+                let y = self.sample(t).y;
+                if y < min_y {
+                    min_y = y;
+                }
+                if y > max_y {
+                    max_y = y;
+                }
+            },
+        );
+
+        Rect {
+            min: Pos2 { x: min_x, y: min_y },
+            max: Pos2 { x: max_x, y: max_y },
+        }
+    }
+
+    /// Calculate the point (x,y) at t based on the quadratic Bézier curve equation.
+    /// t is in [0.0,1.0]
+    /// [Bézier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Quadratic_B.C3.A9zier_curves)
+    ///
+    pub fn sample(&self, t: f32) -> Pos2 {
+        crate::epaint_assert!(
+            t >= 0.0 && t <= 1.0,
+            "the sample value should be in [0.0,1.0]"
+        );
+
+        let h = 1.0 - t;
+        let a = t * t;
+        let b = 2.0 * t * h;
+        let c = h * h;
+        let result = self.points[2].to_vec2() * a
+            + self.points[1].to_vec2() * b
+            + self.points[0].to_vec2() * c;
+        result.to_pos2()
+    }
+
+    /// find a set of points that approximate the quadratic Bézier curve.
+    /// the number of points is determined by the tolerance.
+    /// the points may not be evenly distributed in the range [0.0,1.0] (t value)
+    pub fn flatten(&self, tolerance: Option<f32>) -> Vec<Pos2> {
+        let tolerance = tolerance.unwrap_or((self.points[0].x - self.points[2].x).abs() * 0.001);
+        let mut result = vec![self.points[0]];
+        self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+            result.push(p);
+        });
+        result
+    }
+
+    // copied from https://docs.rs/lyon_geom/latest/lyon_geom/
+    /// Compute a flattened approximation of the curve, invoking a callback at
+    /// each step.
+    ///
+    /// The callback takes the point and corresponding curve parameter at each step.
+    ///
+    /// This implements the algorithm described by Raph Levien at
+    /// <https://raphlinus.github.io/graphics/curves/2019/12/23/flatten-quadbez.html>
+    pub fn for_each_flattened_with_t<F>(&self, tolerance: f32, callback: &mut F)
+    where
+        F: FnMut(Pos2, f32),
+    {
+        let params = FlatteningParameters::from_curve(self, tolerance);
+        if params.is_point {
+            return;
+        }
+
+        let count = params.count as u32;
+        for index in 1..count {
+            let t = params.t_at_iteration(index as f32);
+
+            callback(self.sample(t), t);
+        }
+
+        callback(self.sample(1.0), 1.0);
+    }
+}
+
+impl From<QuadraticBezierShape> for Shape {
+    #[inline(always)]
+    fn from(shape: QuadraticBezierShape) -> Self {
+        Self::QuadraticBezier(shape)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+// lyon_geom::flatten_cubic.rs
+// copied from https://docs.rs/lyon_geom/latest/lyon_geom/
+fn flatten_cubic_bezier_with_t<F: FnMut(Pos2, f32)>(
+    curve: &CubicBezierShape,
+    tolerance: f32,
+    callback: &mut F,
+) {
+    // debug_assert!(tolerance >= S::EPSILON * S::EPSILON);
+    let quadratics_tolerance = tolerance * 0.2;
+    let flattening_tolerance = tolerance * 0.8;
+
+    let num_quadratics = curve.num_quadratics(quadratics_tolerance);
+    let step = 1.0 / num_quadratics as f32;
+    let n = num_quadratics;
+    let mut t0 = 0.0;
+    for _ in 0..(n - 1) {
+        let t1 = t0 + step;
+
+        let quadratic = single_curve_approximation(&curve.split_range(t0..t1));
+        quadratic.for_each_flattened_with_t(flattening_tolerance, &mut |point, t_sub| {
+            let t = t0 + step * t_sub;
+            callback(point, t);
+        });
+
+        t0 = t1;
+    }
+
+    // Do the last step manually to make sure we finish at t = 1.0 exactly.
+    let quadratic = single_curve_approximation(&curve.split_range(t0..1.0));
+    quadratic.for_each_flattened_with_t(flattening_tolerance, &mut |point, t_sub| {
+        let t = t0 + step * t_sub;
+        callback(point, t);
+    });
+}
+
+// from lyon_geom::quadratic_bezier.rs
+// copied from https://docs.rs/lyon_geom/latest/lyon_geom/
+struct FlatteningParameters {
+    count: f32,
+    integral_from: f32,
+    integral_step: f32,
+    inv_integral_from: f32,
+    div_inv_integral_diff: f32,
+    is_point: bool,
+}
+
+impl FlatteningParameters {
+    // https://raphlinus.github.io/graphics/curves/2019/12/23/flatten-quadbez.html
+    pub fn from_curve(curve: &QuadraticBezierShape, tolerance: f32) -> Self {
+        // Map the quadratic bézier segment to y = x^2 parabola.
+        let from = curve.points[0];
+        let ctrl = curve.points[1];
+        let to = curve.points[2];
+
+        let ddx = 2.0 * ctrl.x - from.x - to.x;
+        let ddy = 2.0 * ctrl.y - from.y - to.y;
+        let cross = (to.x - from.x) * ddy - (to.y - from.y) * ddx;
+        let inv_cross = 1.0 / cross;
+        let parabola_from = ((ctrl.x - from.x) * ddx + (ctrl.y - from.y) * ddy) * inv_cross;
+        let parabola_to = ((to.x - ctrl.x) * ddx + (to.y - ctrl.y) * ddy) * inv_cross;
+        // Note, scale can be NaN, for example with straight lines. When it happens the NaN will
+        // propagate to other parameters. We catch it all by setting the iteration count to zero
+        // and leave the rest as garbage.
+        let scale = cross.abs() / (ddx.hypot(ddy) * (parabola_to - parabola_from).abs());
+
+        let integral_from = approx_parabola_integral(parabola_from);
+        let integral_to = approx_parabola_integral(parabola_to);
+        let integral_diff = integral_to - integral_from;
+
+        let inv_integral_from = approx_parabola_inv_integral(integral_from);
+        let inv_integral_to = approx_parabola_inv_integral(integral_to);
+        let div_inv_integral_diff = 1.0 / (inv_integral_to - inv_integral_from);
+
+        // the original author thinks it can be stored as integer if it's not generic.
+        // but if so, we have to handle the edge case of the integral being infinite.
+        let mut count = (0.5 * integral_diff.abs() * (scale / tolerance).sqrt()).ceil();
+        let mut is_point = false;
+        // If count is NaN the curve can be approximated by a single straight line or a point.
+        if !count.is_finite() {
+            count = 0.0;
+            is_point = (to.x - from.x).hypot(to.y - from.y) < tolerance * tolerance;
+        }
+
+        let integral_step = integral_diff / count;
+
+        FlatteningParameters {
+            count,
+            integral_from,
+            integral_step,
+            inv_integral_from,
+            div_inv_integral_diff,
+            is_point,
+        }
+    }
+
+    fn t_at_iteration(&self, iteration: f32) -> f32 {
+        let u = approx_parabola_inv_integral(self.integral_from + self.integral_step * iteration);
+        (u - self.inv_integral_from) * self.div_inv_integral_diff
+    }
+}
+
+/// Compute an approximation to integral (1 + 4x^2) ^ -0.25 dx used in the flattening code.
+fn approx_parabola_integral(x: f32) -> f32 {
+    let d: f32 = 0.67;
+    let quarter = 0.25;
+    x / (1.0 - d + (d.powi(4) + quarter * x * x).sqrt().sqrt())
+}
+
+/// Approximate the inverse of the function above.
+fn approx_parabola_inv_integral(x: f32) -> f32 {
+    let b = 0.39;
+    let quarter = 0.25;
+    x * (1.0 - b + (b * b + quarter * x * x).sqrt())
+}
+
+fn single_curve_approximation(curve: &CubicBezierShape) -> QuadraticBezierShape {
+    let c1_x = (curve.points[1].x * 3.0 - curve.points[0].x) * 0.5;
+    let c1_y = (curve.points[1].y * 3.0 - curve.points[0].y) * 0.5;
+    let c2_x = (curve.points[2].x * 3.0 - curve.points[3].x) * 0.5;
+    let c2_y = (curve.points[2].y * 3.0 - curve.points[3].y) * 0.5;
+    let c = Pos2 {
+        x: (c1_x + c2_x) * 0.5,
+        y: (c1_y + c2_y) * 0.5,
+    };
+    QuadraticBezierShape {
+        points: [curve.points[0], c, curve.points[3]],
+        closed: curve.closed,
+        fill: curve.fill,
+        stroke: curve.stroke,
+    }
+}
+
+fn quadratic_for_each_local_extremum<F: FnMut(f32)>(p0: f32, p1: f32, p2: f32, cb: &mut F) {
+    // A quadratic Bézier curve can be derived by a linear function:
+    // p(t) = p0 + t(p1 - p0) + t^2(p2 - 2p1 + p0)
+    // The derivative is:
+    // p'(t) = (p1 - p0) + 2(p2 - 2p1 + p0)t or:
+    // f(x) = a* x + b
+    let a = p2 - 2.0 * p1 + p0;
+    // let b = p1 - p0;
+    // no need to check for zero, since we're only interested in local extrema
+    if a == 0.0 {
+        return;
+    }
+
+    let t = (p0 - p1) / a;
+    if t > 0.0 && t < 1.0 {
+        cb(t);
+    }
+}
+
+fn cubic_for_each_local_extremum<F: FnMut(f32)>(p0: f32, p1: f32, p2: f32, p3: f32, cb: &mut F) {
+    // See www.faculty.idc.ac.il/arik/quality/appendixa.html for an explanation
+    // A cubic Bézier curve can be derivated by the following equation:
+    // B'(t) = 3(1-t)^2(p1-p0) + 6(1-t)t(p2-p1) + 3t^2(p3-p2) or
+    // f(x) = a * x² + b * x + c
+    let a = 3.0 * (p3 + 3.0 * (p1 - p2) - p0);
+    let b = 6.0 * (p2 - 2.0 * p1 + p0);
+    let c = 3.0 * (p1 - p0);
+
+    let in_range = |t: f32| t <= 1.0 && t >= 0.0;
+
+    // linear situation
+    if a == 0.0 {
+        if b != 0.0 {
+            let t = -c / b;
+            if in_range(t) {
+                cb(t);
+            }
+        }
+        return;
+    }
+
+    let discr = b * b - 4.0 * a * c;
+    // no Real solution
+    if discr < 0.0 {
+        return;
+    }
+
+    // one Real solution
+    if discr == 0.0 {
+        let t = -b / (2.0 * a);
+        if in_range(t) {
+            cb(t);
+        }
+        return;
+    }
+
+    // two Real solutions
+    let discr = discr.sqrt();
+    let t1 = (-b - discr) / (2.0 * a);
+    let t2 = (-b + discr) / (2.0 * a);
+    if in_range(t1) {
+        cb(t1);
+    }
+    if in_range(t2) {
+        cb(t2);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quadratic_bounding_box() {
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2 { x: 110.0, y: 170.0 },
+                Pos2 { x: 10.0, y: 10.0 },
+                Pos2 { x: 180.0, y: 30.0 },
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+        let bbox = curve.logical_bounding_rect();
+        assert!((bbox.min.x - 72.96).abs() < 0.01);
+        assert!((bbox.min.y - 27.78).abs() < 0.01);
+
+        assert!((bbox.max.x - 180.0).abs() < 0.01);
+        assert!((bbox.max.y - 170.0).abs() < 0.01);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 26);
+
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2 { x: 110.0, y: 170.0 },
+                Pos2 { x: 180.0, y: 30.0 },
+                Pos2 { x: 10.0, y: 10.0 },
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+        let bbox = curve.logical_bounding_rect();
+        assert!((bbox.min.x - 10.0).abs() < 0.01);
+        assert!((bbox.min.y - 10.0).abs() < 0.01);
+
+        assert!((bbox.max.x - 130.42).abs() < 0.01);
+        assert!((bbox.max.y - 170.0).abs() < 0.01);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 25);
+    }
+
+    #[test]
+    fn test_quadratic_different_tolerance() {
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2 { x: 110.0, y: 170.0 },
+                Pos2 { x: 180.0, y: 30.0 },
+                Pos2 { x: 10.0, y: 10.0 },
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(1.0, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 9);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 25);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 77);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.001, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 240);
+    }
+
+    #[test]
+    fn test_cubic_bounding_box() {
+        let curve = CubicBezierShape {
+            points: [
+                pos2(10.0, 10.0),
+                pos2(110.0, 170.0),
+                pos2(180.0, 30.0),
+                pos2(270.0, 210.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let bbox = curve.logical_bounding_rect();
+        assert_eq!(bbox.min.x, 10.0);
+        assert_eq!(bbox.min.y, 10.0);
+        assert_eq!(bbox.max.x, 270.0);
+        assert_eq!(bbox.max.y, 210.0);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(10.0, 10.0),
+                pos2(110.0, 170.0),
+                pos2(270.0, 210.0),
+                pos2(180.0, 30.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let bbox = curve.logical_bounding_rect();
+        assert_eq!(bbox.min.x, 10.0);
+        assert_eq!(bbox.min.y, 10.0);
+        assert!((bbox.max.x - 206.50).abs() < 0.01);
+        assert!((bbox.max.y - 148.48).abs() < 0.01);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(110.0, 170.0),
+                pos2(10.0, 10.0),
+                pos2(270.0, 210.0),
+                pos2(180.0, 30.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let bbox = curve.logical_bounding_rect();
+        assert!((bbox.min.x - 86.71).abs() < 0.01);
+        assert!((bbox.min.y - 30.0).abs() < 0.01);
+
+        assert!((bbox.max.x - 199.27).abs() < 0.01);
+        assert!((bbox.max.y - 170.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_cubic_different_tolerance_flattening() {
+        let curve = CubicBezierShape {
+            points: [
+                pos2(0.0, 0.0),
+                pos2(100.0, 0.0),
+                pos2(100.0, 100.0),
+                pos2(100.0, 200.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(1.0, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 10);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.5, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 13);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 28);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 83);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.001, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 248);
+    }
+
+    #[test]
+    fn test_cubic_different_shape_flattening() {
+        let curve = CubicBezierShape {
+            points: [
+                pos2(90.0, 110.0),
+                pos2(30.0, 170.0),
+                pos2(210.0, 170.0),
+                pos2(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 117);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(90.0, 110.0),
+                pos2(90.0, 170.0),
+                pos2(170.0, 170.0),
+                pos2(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 91);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(90.0, 110.0),
+                pos2(110.0, 170.0),
+                pos2(150.0, 170.0),
+                pos2(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 75);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(90.0, 110.0),
+                pos2(110.0, 170.0),
+                pos2(230.0, 110.0),
+                pos2(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 100);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(90.0, 110.0),
+                pos2(110.0, 170.0),
+                pos2(210.0, 70.0),
+                pos2(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 71);
+
+        let curve = CubicBezierShape {
+            points: [
+                pos2(90.0, 110.0),
+                pos2(110.0, 170.0),
+                pos2(150.0, 50.0),
+                pos2(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 88);
+    }
+
+    #[test]
+    fn test_quadratic_flattening() {
+        let curve = QuadraticBezierShape {
+            points: [pos2(0.0, 0.0), pos2(80.0, 200.0), pos2(100.0, 30.0)],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(1.0, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 9);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.5, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 11);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 24);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 72);
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.001, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 223);
+    }
+}
diff --git a/egui/crates/epaint/src/image.rs b/egui/crates/epaint/src/image.rs
new file mode 100644
index 0000000..35b0885
--- /dev/null
+++ b/egui/crates/epaint/src/image.rs
@@ -0,0 +1,376 @@
+use crate::{textures::TextureOptions, Color32};
+
+/// An image stored in RAM.
+///
+/// To load an image file, see [`ColorImage::from_rgba_unmultiplied`].
+///
+/// In order to paint the image on screen, you first need to convert it to
+///
+/// See also: [`ColorImage`], [`FontImage`].
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum ImageData {
+    /// RGBA image.
+    Color(ColorImage),
+
+    /// Used for the font texture.
+    Font(FontImage),
+}
+
+impl ImageData {
+    pub fn size(&self) -> [usize; 2] {
+        match self {
+            Self::Color(image) => image.size,
+            Self::Font(image) => image.size,
+        }
+    }
+
+    pub fn width(&self) -> usize {
+        self.size()[0]
+    }
+
+    pub fn height(&self) -> usize {
+        self.size()[1]
+    }
+
+    pub fn bytes_per_pixel(&self) -> usize {
+        match self {
+            Self::Color(_) | Self::Font(_) => 4,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A 2D RGBA color image in RAM.
+#[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ColorImage {
+    /// width, height.
+    pub size: [usize; 2],
+
+    /// The pixels, row by row, from top to bottom.
+    pub pixels: Vec<Color32>,
+}
+
+impl ColorImage {
+    /// Create an image filled with the given color.
+    pub fn new(size: [usize; 2], color: Color32) -> Self {
+        Self {
+            size,
+            pixels: vec![color; size[0] * size[1]],
+        }
+    }
+
+    /// Create a [`ColorImage`] from flat un-multiplied RGBA data.
+    ///
+    /// This is usually what you want to use after having loaded an image file.
+    ///
+    /// Panics if `size[0] * size[1] * 4 != rgba.len()`.
+    ///
+    /// ## Example using the [`image`](crates.io/crates/image) crate:
+    /// ``` ignore
+    /// fn load_image_from_path(path: &std::path::Path) -> Result<egui::ColorImage, image::ImageError> {
+    ///     let image = image::io::Reader::open(path)?.decode()?;
+    ///     let size = [image.width() as _, image.height() as _];
+    ///     let image_buffer = image.to_rgba8();
+    ///     let pixels = image_buffer.as_flat_samples();
+    ///     Ok(egui::ColorImage::from_rgba_unmultiplied(
+    ///         size,
+    ///         pixels.as_slice(),
+    ///     ))
+    /// }
+    ///
+    /// fn load_image_from_memory(image_data: &[u8]) -> Result<ColorImage, image::ImageError> {
+    ///     let image = image::load_from_memory(image_data)?;
+    ///     let size = [image.width() as _, image.height() as _];
+    ///     let image_buffer = image.to_rgba8();
+    ///     let pixels = image_buffer.as_flat_samples();
+    ///     Ok(ColorImage::from_rgba_unmultiplied(
+    ///         size,
+    ///         pixels.as_slice(),
+    ///     ))
+    /// }
+    /// ```
+    pub fn from_rgba_unmultiplied(size: [usize; 2], rgba: &[u8]) -> Self {
+        assert_eq!(size[0] * size[1] * 4, rgba.len());
+        let pixels = rgba
+            .chunks_exact(4)
+            .map(|p| Color32::from_rgba_unmultiplied(p[0], p[1], p[2], p[3]))
+            .collect();
+        Self { size, pixels }
+    }
+
+    pub fn from_rgba_premultiplied(size: [usize; 2], rgba: &[u8]) -> Self {
+        assert_eq!(size[0] * size[1] * 4, rgba.len());
+        let pixels = rgba
+            .chunks_exact(4)
+            .map(|p| Color32::from_rgba_premultiplied(p[0], p[1], p[2], p[3]))
+            .collect();
+        Self { size, pixels }
+    }
+
+    /// A view of the underlying data as `&[u8]`
+    #[cfg(feature = "bytemuck")]
+    pub fn as_raw(&self) -> &[u8] {
+        bytemuck::cast_slice(&self.pixels)
+    }
+
+    /// A view of the underlying data as `&mut [u8]`
+    #[cfg(feature = "bytemuck")]
+    pub fn as_raw_mut(&mut self) -> &mut [u8] {
+        bytemuck::cast_slice_mut(&mut self.pixels)
+    }
+
+    /// Create a new Image from a patch of the current image. This method is especially convenient for screenshotting a part of the app
+    /// since `region` can be interpreted as screen coordinates of the entire screenshot if `pixels_per_point` is provided for the native application.
+    /// The floats of [`emath::Rect`] are cast to usize, rounding them down in order to interpret them as indices to the image data.
+    ///
+    /// Panics if `region.min.x > region.max.x || region.min.y > region.max.y`, or if a region larger than the image is passed.
+    pub fn region(&self, region: &emath::Rect, pixels_per_point: Option<f32>) -> Self {
+        let pixels_per_point = pixels_per_point.unwrap_or(1.0);
+        let min_x = (region.min.x * pixels_per_point) as usize;
+        let max_x = (region.max.x * pixels_per_point) as usize;
+        let min_y = (region.min.y * pixels_per_point) as usize;
+        let max_y = (region.max.y * pixels_per_point) as usize;
+        assert!(min_x <= max_x);
+        assert!(min_y <= max_y);
+        let width = max_x - min_x;
+        let height = max_y - min_y;
+        let mut output = Vec::with_capacity(width * height);
+        let row_stride = self.size[0];
+
+        for row in min_y..max_y {
+            output.extend_from_slice(
+                &self.pixels[row * row_stride + min_x..row * row_stride + max_x],
+            );
+        }
+        Self {
+            size: [width, height],
+            pixels: output,
+        }
+    }
+
+    /// Create a [`ColorImage`] from flat RGB data.
+    ///
+    /// This is what you want to use after having loaded an image file (and if
+    /// you are ignoring the alpha channel - considering it to always be 0xff)
+    ///
+    /// Panics if `size[0] * size[1] * 3 != rgb.len()`.
+    pub fn from_rgb(size: [usize; 2], rgb: &[u8]) -> Self {
+        assert_eq!(size[0] * size[1] * 3, rgb.len());
+        let pixels = rgb
+            .chunks_exact(3)
+            .map(|p| Color32::from_rgb(p[0], p[1], p[2]))
+            .collect();
+        Self { size, pixels }
+    }
+
+    /// An example color image, useful for tests.
+    pub fn example() -> Self {
+        let width = 128;
+        let height = 64;
+        let mut img = Self::new([width, height], Color32::TRANSPARENT);
+        for y in 0..height {
+            for x in 0..width {
+                let h = x as f32 / width as f32;
+                let s = 1.0;
+                let v = 1.0;
+                let a = y as f32 / height as f32;
+                img[(x, y)] = crate::Hsva { h, s, v, a }.into();
+            }
+        }
+        img
+    }
+
+    #[inline]
+    pub fn width(&self) -> usize {
+        self.size[0]
+    }
+
+    #[inline]
+    pub fn height(&self) -> usize {
+        self.size[1]
+    }
+}
+
+impl std::ops::Index<(usize, usize)> for ColorImage {
+    type Output = Color32;
+
+    #[inline]
+    fn index(&self, (x, y): (usize, usize)) -> &Color32 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &self.pixels[y * w + x]
+    }
+}
+
+impl std::ops::IndexMut<(usize, usize)> for ColorImage {
+    #[inline]
+    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Color32 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &mut self.pixels[y * w + x]
+    }
+}
+
+impl From<ColorImage> for ImageData {
+    #[inline(always)]
+    fn from(image: ColorImage) -> Self {
+        Self::Color(image)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A single-channel image designed for the font texture.
+///
+/// Each value represents "coverage", i.e. how much a texel is covered by a character.
+///
+/// This is roughly interpreted as the opacity of a white image.
+#[derive(Clone, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct FontImage {
+    /// width, height
+    pub size: [usize; 2],
+
+    /// The coverage value.
+    ///
+    /// Often you want to use [`Self::srgba_pixels`] instead.
+    pub pixels: Vec<f32>,
+}
+
+impl FontImage {
+    pub fn new(size: [usize; 2]) -> Self {
+        Self {
+            size,
+            pixels: vec![0.0; size[0] * size[1]],
+        }
+    }
+
+    #[inline]
+    pub fn width(&self) -> usize {
+        self.size[0]
+    }
+
+    #[inline]
+    pub fn height(&self) -> usize {
+        self.size[1]
+    }
+
+    /// Returns the textures as `sRGBA` premultiplied pixels, row by row, top to bottom.
+    ///
+    /// `gamma` should normally be set to `None`.
+    ///
+    /// If you are having problems with text looking skinny and pixelated, try using a low gamma, e.g. `0.4`.
+    pub fn srgba_pixels(
+        &'_ self,
+        gamma: Option<f32>,
+    ) -> impl ExactSizeIterator<Item = Color32> + '_ {
+        let gamma = gamma.unwrap_or(0.55); // TODO(emilk): this default coverage gamma is a magic constant, chosen by eye. I don't even know why we need it.
+        self.pixels.iter().map(move |coverage| {
+            let alpha = coverage.powf(gamma);
+            // We want to multiply with `vec4(alpha)` in the fragment shader:
+            let a = fast_round(alpha * 255.0);
+            Color32::from_rgba_premultiplied(a, a, a, a)
+        })
+    }
+
+    /// Clone a sub-region as a new image.
+    pub fn region(&self, [x, y]: [usize; 2], [w, h]: [usize; 2]) -> FontImage {
+        assert!(x + w <= self.width());
+        assert!(y + h <= self.height());
+
+        let mut pixels = Vec::with_capacity(w * h);
+        for y in y..y + h {
+            let offset = y * self.width() + x;
+            pixels.extend(&self.pixels[offset..(offset + w)]);
+        }
+        assert_eq!(pixels.len(), w * h);
+        FontImage {
+            size: [w, h],
+            pixels,
+        }
+    }
+}
+
+impl std::ops::Index<(usize, usize)> for FontImage {
+    type Output = f32;
+
+    #[inline]
+    fn index(&self, (x, y): (usize, usize)) -> &f32 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &self.pixels[y * w + x]
+    }
+}
+
+impl std::ops::IndexMut<(usize, usize)> for FontImage {
+    #[inline]
+    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut f32 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &mut self.pixels[y * w + x]
+    }
+}
+
+impl From<FontImage> for ImageData {
+    #[inline(always)]
+    fn from(image: FontImage) -> Self {
+        Self::Font(image)
+    }
+}
+
+fn fast_round(r: f32) -> u8 {
+    (r + 0.5).floor() as _ // rust does a saturating cast since 1.45
+}
+
+// ----------------------------------------------------------------------------
+
+/// A change to an image.
+///
+/// Either a whole new image, or an update to a rectangular region of it.
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[must_use = "The painter must take care of this"]
+pub struct ImageDelta {
+    /// What to set the texture to.
+    ///
+    /// If [`Self::pos`] is `None`, this describes the whole texture.
+    ///
+    /// If [`Self::pos`] is `Some`, this describes a patch of the whole image starting at [`Self::pos`].
+    pub image: ImageData,
+
+    pub options: TextureOptions,
+
+    /// If `None`, set the whole texture to [`Self::image`].
+    ///
+    /// If `Some(pos)`, update a sub-region of an already allocated texture with the patch in [`Self::image`].
+    pub pos: Option<[usize; 2]>,
+}
+
+impl ImageDelta {
+    /// Update the whole texture.
+    pub fn full(image: impl Into<ImageData>, options: TextureOptions) -> Self {
+        Self {
+            image: image.into(),
+            options,
+            pos: None,
+        }
+    }
+
+    /// Update a sub-region of an existing texture.
+    pub fn partial(pos: [usize; 2], image: impl Into<ImageData>, options: TextureOptions) -> Self {
+        Self {
+            image: image.into(),
+            options,
+            pos: Some(pos),
+        }
+    }
+
+    /// Is this affecting the whole texture?
+    /// If `false`, this is a partial (sub-region) update.
+    pub fn is_whole(&self) -> bool {
+        self.pos.is_none()
+    }
+}
diff --git a/egui/crates/epaint/src/lib.rs b/egui/crates/epaint/src/lib.rs
new file mode 100644
index 0000000..924547d
--- /dev/null
+++ b/egui/crates/epaint/src/lib.rs
@@ -0,0 +1,161 @@
+//! A simple 2D graphics library for turning simple 2D shapes and text into textured triangles.
+//!
+//! Made for [`egui`](https://github.com/emilk/egui/).
+//!
+//! Create some [`Shape`]:s and pass them to [`tessellate_shapes`] to generate [`Mesh`]:es
+//! that you can then paint using some graphics API of your choice (e.g. OpenGL).
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
+
+#![allow(clippy::float_cmp)]
+#![allow(clippy::manual_range_contains)]
+#![forbid(unsafe_code)]
+
+mod bezier;
+pub mod image;
+mod mesh;
+pub mod mutex;
+mod shadow;
+mod shape;
+pub mod shape_transform;
+pub mod stats;
+mod stroke;
+pub mod tessellator;
+pub mod text;
+mod texture_atlas;
+mod texture_handle;
+pub mod textures;
+pub mod util;
+
+pub use {
+    bezier::{CubicBezierShape, QuadraticBezierShape},
+    image::{ColorImage, FontImage, ImageData, ImageDelta},
+    mesh::{Mesh, Mesh16, Vertex},
+    shadow::Shadow,
+    shape::{
+        CircleShape, PaintCallback, PaintCallbackInfo, PathShape, RectShape, Rounding, Shape,
+        TextShape,
+    },
+    stats::PaintStats,
+    stroke::Stroke,
+    tessellator::{tessellate_shapes, TessellationOptions, Tessellator},
+    text::{FontFamily, FontId, Fonts, Galley},
+    texture_atlas::TextureAtlas,
+    texture_handle::TextureHandle,
+    textures::TextureManager,
+};
+
+pub use ecolor::{Color32, Hsva, HsvaGamma, Rgba};
+pub use emath::{pos2, vec2, Pos2, Rect, Vec2};
+
+pub use ahash;
+pub use ecolor;
+pub use emath;
+
+#[cfg(feature = "color-hex")]
+pub use ecolor::hex_color;
+
+/// The UV coordinate of a white region of the texture mesh.
+/// The default egui texture has the top-left corner pixel fully white.
+/// You need need use a clamping texture sampler for this to work
+/// (so it doesn't do bilinear blending with bottom right corner).
+pub const WHITE_UV: emath::Pos2 = emath::pos2(0.0, 0.0);
+
+/// What texture to use in a [`Mesh`] mesh.
+///
+/// If you don't want to use a texture, use `TextureId::Epaint(0)` and the [`WHITE_UV`] for uv-coord.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum TextureId {
+    /// Textures allocated using [`TextureManager`].
+    ///
+    /// The first texture (`TextureId::Epaint(0)`) is used for the font data.
+    Managed(u64),
+
+    /// Your own texture, defined in any which way you want.
+    /// The backend renderer will presumably use this to look up what texture to use.
+    User(u64),
+}
+
+impl Default for TextureId {
+    /// The epaint font texture.
+    fn default() -> Self {
+        Self::Managed(0)
+    }
+}
+
+/// A [`Shape`] within a clip rectangle.
+///
+/// Everything is using logical points.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ClippedShape(
+    /// Clip / scissor rectangle.
+    /// Only show the part of the [`Shape`] that falls within this.
+    pub emath::Rect,
+    /// The shape
+    pub Shape,
+);
+
+/// A [`Mesh`] or [`PaintCallback`] within a clip rectangle.
+///
+/// Everything is using logical points.
+#[derive(Clone, Debug)]
+pub struct ClippedPrimitive {
+    /// Clip / scissor rectangle.
+    /// Only show the part of the [`Mesh`] that falls within this.
+    pub clip_rect: emath::Rect,
+
+    /// What to paint - either a [`Mesh`] or a [`PaintCallback`].
+    pub primitive: Primitive,
+}
+
+/// A rendering primitive - either a [`Mesh`] or a [`PaintCallback`].
+#[derive(Clone, Debug)]
+pub enum Primitive {
+    Mesh(Mesh),
+    Callback(PaintCallback),
+}
+
+// ----------------------------------------------------------------------------
+
+/// An assert that is only active when `epaint` is compiled with the `extra_asserts` feature
+/// or with the `extra_debug_asserts` feature in debug builds.
+#[macro_export]
+macro_rules! epaint_assert {
+    ($($arg: tt)*) => {
+        if cfg!(any(
+            feature = "extra_asserts",
+            all(feature = "extra_debug_asserts", debug_assertions),
+        )) {
+            assert!($($arg)*);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[inline(always)]
+pub(crate) fn f32_hash<H: std::hash::Hasher>(state: &mut H, f: f32) {
+    if f == 0.0 {
+        state.write_u8(0);
+    } else if f.is_nan() {
+        state.write_u8(1);
+    } else {
+        use std::hash::Hash;
+        f.to_bits().hash(state);
+    }
+}
+
+#[inline(always)]
+pub(crate) fn f64_hash<H: std::hash::Hasher>(state: &mut H, f: f64) {
+    if f == 0.0 {
+        state.write_u8(0);
+    } else if f.is_nan() {
+        state.write_u8(1);
+    } else {
+        use std::hash::Hash;
+        f.to_bits().hash(state);
+    }
+}
diff --git a/egui/crates/epaint/src/mesh.rs b/egui/crates/epaint/src/mesh.rs
new file mode 100644
index 0000000..0902526
--- /dev/null
+++ b/egui/crates/epaint/src/mesh.rs
@@ -0,0 +1,316 @@
+use crate::*;
+use emath::*;
+
+/// The 2D vertex type.
+///
+/// Should be friendly to send to GPU as is.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[cfg(not(feature = "unity"))]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Vertex {
+    /// Logical pixel coordinates (points).
+    /// (0,0) is the top left corner of the screen.
+    pub pos: Pos2, // 64 bit
+
+    /// Normalized texture coordinates.
+    /// (0, 0) is the top left corner of the texture.
+    /// (1, 1) is the bottom right corner of the texture.
+    pub uv: Pos2, // 64 bit
+
+    /// sRGBA with premultiplied alpha
+    pub color: Color32, // 32 bit
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[cfg(feature = "unity")]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
+pub struct Vertex {
+    /// Logical pixel coordinates (points).
+    /// (0,0) is the top left corner of the screen.
+    pub pos: Pos2, // 64 bit
+
+    /// sRGBA with premultiplied alpha
+    pub color: Color32, // 32 bit
+
+    /// Normalized texture coordinates.
+    /// (0, 0) is the top left corner of the texture.
+    /// (1, 1) is the bottom right corner of the texture.
+    pub uv: Pos2, // 64 bit
+}
+
+/// Textured triangles in two dimensions.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Mesh {
+    /// Draw as triangles (i.e. the length is always multiple of three).
+    ///
+    /// If you only support 16-bit indices you can use [`Mesh::split_to_u16`].
+    ///
+    /// egui is NOT consistent with what winding order it uses, so turn off backface culling.
+    pub indices: Vec<u32>,
+
+    /// The vertex data indexed by `indices`.
+    pub vertices: Vec<Vertex>,
+
+    /// The texture to use when drawing these triangles.
+    pub texture_id: TextureId,
+    // TODO(emilk): bounding rectangle
+}
+
+impl Mesh {
+    pub fn with_texture(texture_id: TextureId) -> Self {
+        Self {
+            texture_id,
+            ..Default::default()
+        }
+    }
+
+    /// Restore to default state, but without freeing memory.
+    pub fn clear(&mut self) {
+        self.indices.clear();
+        self.vertices.clear();
+        self.vertices = Default::default();
+    }
+
+    pub fn bytes_used(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + self.vertices.len() * std::mem::size_of::<Vertex>()
+            + self.indices.len() * std::mem::size_of::<u32>()
+    }
+
+    /// Are all indices within the bounds of the contained vertices?
+    pub fn is_valid(&self) -> bool {
+        if let Ok(n) = u32::try_from(self.vertices.len()) {
+            self.indices.iter().all(|&i| i < n)
+        } else {
+            false
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.indices.is_empty() && self.vertices.is_empty()
+    }
+
+    /// Calculate a bounding rectangle.
+    pub fn calc_bounds(&self) -> Rect {
+        let mut bounds = Rect::NOTHING;
+        for v in &self.vertices {
+            bounds.extend_with(v.pos);
+        }
+        bounds
+    }
+
+    /// Append all the indices and vertices of `other` to `self`.
+    pub fn append(&mut self, other: Mesh) {
+        crate::epaint_assert!(other.is_valid());
+
+        if self.is_empty() {
+            *self = other;
+        } else {
+            self.append_ref(&other);
+        }
+    }
+
+    /// Append all the indices and vertices of `other` to `self` without
+    /// taking ownership.
+    pub fn append_ref(&mut self, other: &Mesh) {
+        crate::epaint_assert!(other.is_valid());
+
+        if !self.is_empty() {
+            assert_eq!(
+                self.texture_id, other.texture_id,
+                "Can't merge Mesh using different textures"
+            );
+        } else {
+            self.texture_id = other.texture_id;
+        }
+
+        let index_offset = self.vertices.len() as u32;
+        self.indices
+            .extend(other.indices.iter().map(|index| index + index_offset));
+        self.vertices.extend(other.vertices.iter());
+    }
+
+    #[inline(always)]
+    pub fn colored_vertex(&mut self, pos: Pos2, color: Color32) {
+        crate::epaint_assert!(self.texture_id == TextureId::default());
+        self.vertices.push(Vertex {
+            pos,
+            uv: WHITE_UV,
+            color,
+        });
+    }
+
+    /// Add a triangle.
+    #[inline(always)]
+    pub fn add_triangle(&mut self, a: u32, b: u32, c: u32) {
+        self.indices.push(a);
+        self.indices.push(b);
+        self.indices.push(c);
+    }
+
+    /// Make room for this many additional triangles (will reserve 3x as many indices).
+    /// See also `reserve_vertices`.
+    #[inline(always)]
+    pub fn reserve_triangles(&mut self, additional_triangles: usize) {
+        self.indices.reserve(3 * additional_triangles);
+    }
+
+    /// Make room for this many additional vertices.
+    /// See also `reserve_triangles`.
+    #[inline(always)]
+    pub fn reserve_vertices(&mut self, additional: usize) {
+        self.vertices.reserve(additional);
+    }
+
+    /// Rectangle with a texture and color.
+    pub fn add_rect_with_uv(&mut self, rect: Rect, uv: Rect, color: Color32) {
+        #![allow(clippy::identity_op)]
+
+        let idx = self.vertices.len() as u32;
+        self.add_triangle(idx + 0, idx + 1, idx + 2);
+        self.add_triangle(idx + 2, idx + 1, idx + 3);
+
+        self.vertices.push(Vertex {
+            pos: rect.left_top(),
+            uv: uv.left_top(),
+            color,
+        });
+        self.vertices.push(Vertex {
+            pos: rect.right_top(),
+            uv: uv.right_top(),
+            color,
+        });
+        self.vertices.push(Vertex {
+            pos: rect.left_bottom(),
+            uv: uv.left_bottom(),
+            color,
+        });
+        self.vertices.push(Vertex {
+            pos: rect.right_bottom(),
+            uv: uv.right_bottom(),
+            color,
+        });
+    }
+
+    /// Uniformly colored rectangle.
+    #[inline(always)]
+    pub fn add_colored_rect(&mut self, rect: Rect, color: Color32) {
+        crate::epaint_assert!(self.texture_id == TextureId::default());
+        self.add_rect_with_uv(rect, [WHITE_UV, WHITE_UV].into(), color);
+    }
+
+    /// This is for platforms that only support 16-bit index buffers.
+    ///
+    /// Splits this mesh into many smaller meshes (if needed)
+    /// where the smaller meshes have 16-bit indices.
+    pub fn split_to_u16(self) -> Vec<Mesh16> {
+        crate::epaint_assert!(self.is_valid());
+
+        const MAX_SIZE: u32 = std::u16::MAX as u32;
+
+        if self.vertices.len() <= MAX_SIZE as usize {
+            // Common-case optimization:
+            return vec![Mesh16 {
+                indices: self.indices.iter().map(|&i| i as u16).collect(),
+                vertices: self.vertices,
+                texture_id: self.texture_id,
+            }];
+        }
+
+        let mut output = vec![];
+        let mut index_cursor = 0;
+
+        while index_cursor < self.indices.len() {
+            let span_start = index_cursor;
+            let mut min_vindex = self.indices[index_cursor];
+            let mut max_vindex = self.indices[index_cursor];
+
+            while index_cursor < self.indices.len() {
+                let (mut new_min, mut new_max) = (min_vindex, max_vindex);
+                for i in 0..3 {
+                    let idx = self.indices[index_cursor + i];
+                    new_min = new_min.min(idx);
+                    new_max = new_max.max(idx);
+                }
+
+                let new_span_size = new_max - new_min + 1; // plus one, because it is an inclusive range
+                if new_span_size <= MAX_SIZE {
+                    // Triangle fits
+                    min_vindex = new_min;
+                    max_vindex = new_max;
+                    index_cursor += 3;
+                } else {
+                    break;
+                }
+            }
+
+            assert!(
+                index_cursor > span_start,
+                "One triangle spanned more than {} vertices",
+                MAX_SIZE
+            );
+
+            let mesh = Mesh16 {
+                indices: self.indices[span_start..index_cursor]
+                    .iter()
+                    .map(|vi| u16::try_from(vi - min_vindex).unwrap())
+                    .collect(),
+                vertices: self.vertices[(min_vindex as usize)..=(max_vindex as usize)].to_vec(),
+                texture_id: self.texture_id,
+            };
+            crate::epaint_assert!(mesh.is_valid());
+            output.push(mesh);
+        }
+        output
+    }
+
+    /// Translate location by this much, in-place
+    pub fn translate(&mut self, delta: Vec2) {
+        for v in &mut self.vertices {
+            v.pos += delta;
+        }
+    }
+
+    /// Rotate by some angle about an origin, in-place.
+    ///
+    /// Origin is a position in screen space.
+    pub fn rotate(&mut self, rot: Rot2, origin: Pos2) {
+        for v in &mut self.vertices {
+            v.pos = origin + rot * (v.pos - origin);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A version of [`Mesh`] that uses 16-bit indices.
+///
+/// This is produced by [`Mesh::split_to_u16`] and is meant to be used for legacy render backends.
+pub struct Mesh16 {
+    /// Draw as triangles (i.e. the length is always multiple of three).
+    ///
+    /// egui is NOT consistent with what winding order it uses, so turn off backface culling.
+    pub indices: Vec<u16>,
+
+    /// The vertex data indexed by `indices`.
+    pub vertices: Vec<Vertex>,
+
+    /// The texture to use when drawing these triangles.
+    pub texture_id: TextureId,
+}
+
+impl Mesh16 {
+    /// Are all indices within the bounds of the contained vertices?
+    pub fn is_valid(&self) -> bool {
+        if let Ok(n) = u16::try_from(self.vertices.len()) {
+            self.indices.iter().all(|&i| i < n)
+        } else {
+            false
+        }
+    }
+}
diff --git a/egui/crates/epaint/src/mutex.rs b/egui/crates/epaint/src/mutex.rs
new file mode 100644
index 0000000..f3a18bf
--- /dev/null
+++ b/egui/crates/epaint/src/mutex.rs
@@ -0,0 +1,579 @@
+//! Helper module that wraps some Mutex types with different implementations.
+
+// ----------------------------------------------------------------------------
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(not(debug_assertions))]
+mod mutex_impl {
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct Mutex<T>(parking_lot::Mutex<T>);
+
+    /// The lock you get from [`Mutex`].
+    pub use parking_lot::MutexGuard;
+
+    impl<T> Mutex<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(parking_lot::Mutex::new(val))
+        }
+
+        #[inline(always)]
+        pub fn lock(&self) -> MutexGuard<'_, T> {
+            self.0.lock()
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(debug_assertions)]
+mod mutex_impl {
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct Mutex<T>(parking_lot::Mutex<T>);
+
+    /// The lock you get from [`Mutex`].
+    pub struct MutexGuard<'a, T>(parking_lot::MutexGuard<'a, T>, *const ());
+
+    #[derive(Default)]
+    struct HeldLocks(Vec<*const ()>);
+
+    impl HeldLocks {
+        #[inline(always)]
+        fn insert(&mut self, lock: *const ()) {
+            // Very few locks will ever be held at the same time, so a linear search is fast
+            assert!(
+                !self.0.contains(&lock),
+                "Recursively locking a Mutex in the same thread is not supported"
+            );
+            self.0.push(lock);
+        }
+
+        #[inline(always)]
+        fn remove(&mut self, lock: *const ()) {
+            self.0.retain(|&ptr| ptr != lock);
+        }
+    }
+
+    thread_local! {
+        static HELD_LOCKS_TLS: std::cell::RefCell<HeldLocks> = Default::default();
+    }
+
+    impl<T> Mutex<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(parking_lot::Mutex::new(val))
+        }
+
+        pub fn lock(&self) -> MutexGuard<'_, T> {
+            // Detect if we are recursively taking out a lock on this mutex.
+
+            // use a pointer to the inner data as an id for this lock
+            let ptr = (&self.0 as *const parking_lot::Mutex<_>).cast::<()>();
+
+            // Store it in thread local storage while we have a lock guard taken out
+            HELD_LOCKS_TLS.with(|held_locks| {
+                held_locks.borrow_mut().insert(ptr);
+            });
+
+            MutexGuard(self.0.lock(), ptr)
+        }
+    }
+
+    impl<T> Drop for MutexGuard<'_, T> {
+        fn drop(&mut self) {
+            let ptr = self.1;
+            HELD_LOCKS_TLS.with(|held_locks| {
+                held_locks.borrow_mut().remove(ptr);
+            });
+        }
+    }
+
+    impl<T> std::ops::Deref for MutexGuard<'_, T> {
+        type Target = T;
+
+        #[inline(always)]
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl<T> std::ops::DerefMut for MutexGuard<'_, T> {
+        #[inline(always)]
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(not(feature = "deadlock_detection"))]
+mod rw_lock_impl {
+    /// The lock you get from [`RwLock::read`].
+    pub use parking_lot::MappedRwLockReadGuard as RwLockReadGuard;
+
+    /// The lock you get from [`RwLock::write`].
+    pub use parking_lot::MappedRwLockWriteGuard as RwLockWriteGuard;
+
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct RwLock<T>(parking_lot::RwLock<T>);
+
+    impl<T> RwLock<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(parking_lot::RwLock::new(val))
+        }
+
+        #[inline(always)]
+        pub fn read(&self) -> RwLockReadGuard<'_, T> {
+            parking_lot::RwLockReadGuard::map(self.0.read(), |v| v)
+        }
+
+        #[inline(always)]
+        pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+            parking_lot::RwLockWriteGuard::map(self.0.write(), |v| v)
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(feature = "deadlock_detection")]
+mod rw_lock_impl {
+    use std::{
+        ops::{Deref, DerefMut},
+        sync::Arc,
+        thread::ThreadId,
+    };
+
+    use ahash::HashMap;
+    use parking_lot::{MappedRwLockReadGuard, MappedRwLockWriteGuard};
+
+    /// The lock you get from [`RwLock::read`].
+    pub struct RwLockReadGuard<'a, T> {
+        // The option is used only because we need to `take()` the guard out of self
+        // when doing remappings (`map()`), i.e. it's used as a safe `ManuallyDrop`.
+        guard: Option<MappedRwLockReadGuard<'a, T>>,
+        holders: Arc<parking_lot::Mutex<HashMap<ThreadId, backtrace::Backtrace>>>,
+    }
+
+    impl<'a, T> RwLockReadGuard<'a, T> {
+        #[inline]
+        pub fn map<U, F>(mut s: Self, f: F) -> RwLockReadGuard<'a, U>
+        where
+            F: FnOnce(&T) -> &U,
+        {
+            RwLockReadGuard {
+                guard: s
+                    .guard
+                    .take()
+                    .map(|g| parking_lot::MappedRwLockReadGuard::map(g, f)),
+                holders: Arc::clone(&s.holders),
+            }
+        }
+    }
+
+    impl<'a, T> Deref for RwLockReadGuard<'a, T> {
+        type Target = T;
+
+        fn deref(&self) -> &Self::Target {
+            self.guard.as_ref().unwrap()
+        }
+    }
+
+    impl<'a, T> Drop for RwLockReadGuard<'a, T> {
+        fn drop(&mut self) {
+            let tid = std::thread::current().id();
+            self.holders.lock().remove(&tid);
+        }
+    }
+
+    /// The lock you get from [`RwLock::write`].
+    pub struct RwLockWriteGuard<'a, T> {
+        // The option is used only because we need to `take()` the guard out of self
+        // when doing remappings (`map()`), i.e. it's used as a safe `ManuallyDrop`.
+        guard: Option<MappedRwLockWriteGuard<'a, T>>,
+        holders: Arc<parking_lot::Mutex<HashMap<ThreadId, backtrace::Backtrace>>>,
+    }
+
+    impl<'a, T> RwLockWriteGuard<'a, T> {
+        #[inline]
+        pub fn map<U, F>(mut s: Self, f: F) -> RwLockWriteGuard<'a, U>
+        where
+            F: FnOnce(&mut T) -> &mut U,
+        {
+            RwLockWriteGuard {
+                guard: s
+                    .guard
+                    .take()
+                    .map(|g| parking_lot::MappedRwLockWriteGuard::map(g, f)),
+                holders: Arc::clone(&s.holders),
+            }
+        }
+    }
+
+    impl<'a, T> Deref for RwLockWriteGuard<'a, T> {
+        type Target = T;
+
+        fn deref(&self) -> &Self::Target {
+            self.guard.as_ref().unwrap()
+        }
+    }
+
+    impl<'a, T> DerefMut for RwLockWriteGuard<'a, T> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.guard.as_mut().unwrap()
+        }
+    }
+
+    impl<'a, T> Drop for RwLockWriteGuard<'a, T> {
+        fn drop(&mut self) {
+            let tid = std::thread::current().id();
+            self.holders.lock().remove(&tid);
+        }
+    }
+
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct RwLock<T> {
+        lock: parking_lot::RwLock<T>,
+        // Technically we'd need a list of backtraces per thread-id since parking_lot's
+        // read-locks are reentrant.
+        // In practice it's not that useful to have the whole list though, so we only
+        // keep track of the first backtrace for now.
+        holders: Arc<parking_lot::Mutex<HashMap<ThreadId, backtrace::Backtrace>>>,
+    }
+
+    impl<T> RwLock<T> {
+        pub fn new(val: T) -> Self {
+            Self {
+                lock: parking_lot::RwLock::new(val),
+                holders: Default::default(),
+            }
+        }
+
+        pub fn read(&self) -> RwLockReadGuard<'_, T> {
+            let tid = std::thread::current().id();
+
+            // If it is write-locked, and we locked it (reentrancy deadlock)
+            let would_deadlock =
+                self.lock.is_locked_exclusive() && self.holders.lock().contains_key(&tid);
+            assert!(
+                !would_deadlock,
+                "{} DEAD-LOCK DETECTED ({:?})!\n\
+                    Trying to grab read-lock at:\n{}\n\
+                    which is already exclusively held by current thread at:\n{}\n\n",
+                std::any::type_name::<Self>(),
+                tid,
+                format_backtrace(&mut make_backtrace()),
+                format_backtrace(self.holders.lock().get_mut(&tid).unwrap())
+            );
+
+            self.holders
+                .lock()
+                .entry(tid)
+                .or_insert_with(make_backtrace);
+
+            RwLockReadGuard {
+                guard: parking_lot::RwLockReadGuard::map(self.lock.read(), |v| v).into(),
+                holders: Arc::clone(&self.holders),
+            }
+        }
+
+        pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+            let tid = std::thread::current().id();
+
+            // If it is locked in any way, and we locked it (reentrancy deadlock)
+            let would_deadlock = self.lock.is_locked() && self.holders.lock().contains_key(&tid);
+            assert!(
+                !would_deadlock,
+                "{} DEAD-LOCK DETECTED ({:?})!\n\
+                    Trying to grab write-lock at:\n{}\n\
+                    which is already held by current thread at:\n{}\n\n",
+                std::any::type_name::<Self>(),
+                tid,
+                format_backtrace(&mut make_backtrace()),
+                format_backtrace(self.holders.lock().get_mut(&tid).unwrap())
+            );
+
+            self.holders
+                .lock()
+                .entry(tid)
+                .or_insert_with(make_backtrace);
+
+            RwLockWriteGuard {
+                guard: parking_lot::RwLockWriteGuard::map(self.lock.write(), |v| v).into(),
+                holders: Arc::clone(&self.holders),
+            }
+        }
+    }
+
+    fn make_backtrace() -> backtrace::Backtrace {
+        backtrace::Backtrace::new_unresolved()
+    }
+
+    fn format_backtrace(backtrace: &mut backtrace::Backtrace) -> String {
+        backtrace.resolve();
+
+        let stacktrace = format!("{:?}", backtrace);
+
+        // Remove irrelevant parts of the stacktrace:
+        let end_offset = stacktrace
+            .find("std::sys_common::backtrace::__rust_begin_short_backtrace")
+            .unwrap_or(stacktrace.len());
+        let stacktrace = &stacktrace[..end_offset];
+
+        let first_interesting_function = "epaint::mutex::rw_lock_impl::make_backtrace\n";
+        if let Some(start_offset) = stacktrace.find(first_interesting_function) {
+            stacktrace[start_offset + first_interesting_function.len()..].to_owned()
+        } else {
+            stacktrace.to_owned()
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(target_arch = "wasm32")]
+mod mutex_impl {
+    // `atomic_refcell` will panic if multiple threads try to access the same value
+
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct Mutex<T>(atomic_refcell::AtomicRefCell<T>);
+
+    /// The lock you get from [`Mutex`].
+    pub use atomic_refcell::AtomicRefMut as MutexGuard;
+
+    impl<T> Mutex<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(atomic_refcell::AtomicRefCell::new(val))
+        }
+
+        /// Panics if already locked.
+        #[inline(always)]
+        pub fn lock(&self) -> MutexGuard<'_, T> {
+            self.0.borrow_mut()
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+mod rw_lock_impl {
+    // `atomic_refcell` will panic if multiple threads try to access the same value
+
+    /// The lock you get from [`RwLock::read`].
+    pub use atomic_refcell::AtomicRef as RwLockReadGuard;
+
+    /// The lock you get from [`RwLock::write`].
+    pub use atomic_refcell::AtomicRefMut as RwLockWriteGuard;
+
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct RwLock<T>(atomic_refcell::AtomicRefCell<T>);
+
+    impl<T> RwLock<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(atomic_refcell::AtomicRefCell::new(val))
+        }
+
+        #[inline(always)]
+        pub fn read(&self) -> RwLockReadGuard<'_, T> {
+            self.0.borrow()
+        }
+
+        /// Panics if already locked.
+        #[inline(always)]
+        pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+            self.0.borrow_mut()
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub use mutex_impl::{Mutex, MutexGuard};
+pub use rw_lock_impl::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+impl<T> Clone for Mutex<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.lock().clone())
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use crate::mutex::Mutex;
+    use std::time::Duration;
+
+    #[test]
+    fn lock_two_different_mutexes_single_thread() {
+        let one = Mutex::new(());
+        let two = Mutex::new(());
+        let _a = one.lock();
+        let _b = two.lock();
+    }
+
+    #[test]
+    #[should_panic]
+    fn lock_reentry_single_thread() {
+        let one = Mutex::new(());
+        let _a = one.lock();
+        let _a2 = one.lock(); // panics
+    }
+
+    #[test]
+    fn lock_multiple_threads() {
+        use std::sync::Arc;
+        let one = Arc::new(Mutex::new(()));
+        let our_lock = one.lock();
+        let other_thread = {
+            let one = Arc::clone(&one);
+            std::thread::spawn(move || {
+                let _ = one.lock();
+            })
+        };
+        std::thread::sleep(Duration::from_millis(200));
+        drop(our_lock);
+        other_thread.join().unwrap();
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(feature = "deadlock_detection")]
+#[cfg(test)]
+mod tests_rwlock {
+    use crate::mutex::RwLock;
+    use std::time::Duration;
+
+    #[test]
+    fn lock_two_different_rwlocks_single_thread() {
+        let one = RwLock::new(());
+        let two = RwLock::new(());
+        let _a = one.write();
+        let _b = two.write();
+    }
+
+    #[test]
+    fn rwlock_multiple_threads() {
+        use std::sync::Arc;
+        let one = Arc::new(RwLock::new(()));
+        let our_lock = one.write();
+        let other_thread1 = {
+            let one = Arc::clone(&one);
+            std::thread::spawn(move || {
+                let _ = one.write();
+            })
+        };
+        let other_thread2 = {
+            let one = Arc::clone(&one);
+            std::thread::spawn(move || {
+                let _ = one.read();
+            })
+        };
+        std::thread::sleep(Duration::from_millis(200));
+        drop(our_lock);
+        other_thread1.join().unwrap();
+        other_thread2.join().unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn rwlock_write_write_reentrancy() {
+        let one = RwLock::new(());
+        let _a1 = one.write();
+        let _a2 = one.write(); // panics
+    }
+
+    #[test]
+    #[should_panic]
+    fn rwlock_write_read_reentrancy() {
+        let one = RwLock::new(());
+        let _a1 = one.write();
+        let _a2 = one.read(); // panics
+    }
+
+    #[test]
+    #[should_panic]
+    fn rwlock_read_write_reentrancy() {
+        let one = RwLock::new(());
+        let _a1 = one.read();
+        let _a2 = one.write(); // panics
+    }
+
+    #[test]
+    fn rwlock_read_read_reentrancy() {
+        let one = RwLock::new(());
+        let _a1 = one.read();
+        // This is legal: this test suite specifically targets native, which relies
+        // on parking_lot's rw-locks, which are reentrant.
+        let _a2 = one.read();
+    }
+
+    #[test]
+    fn rwlock_short_read_foreign_read_write_reentrancy() {
+        use std::sync::Arc;
+
+        let lock = Arc::new(RwLock::new(()));
+
+        // Thread #0 grabs a read lock
+        let t0r0 = lock.read();
+
+        // Thread #1 grabs the same read lock
+        let other_thread = {
+            let lock = Arc::clone(&lock);
+            std::thread::spawn(move || {
+                let _t1r0 = lock.read();
+            })
+        };
+        other_thread.join().unwrap();
+
+        // Thread #0 releases its read lock
+        drop(t0r0);
+
+        // Thread #0 now grabs a write lock, which is legal
+        let _t0w0 = lock.write();
+    }
+
+    #[test]
+    #[should_panic]
+    fn rwlock_read_foreign_read_write_reentrancy() {
+        use std::sync::Arc;
+
+        let lock = Arc::new(RwLock::new(()));
+
+        // Thread #0 grabs a read lock
+        let _t0r0 = lock.read();
+
+        // Thread #1 grabs the same read lock
+        let other_thread = {
+            let lock = Arc::clone(&lock);
+            std::thread::spawn(move || {
+                let _t1r0 = lock.read();
+            })
+        };
+        other_thread.join().unwrap();
+
+        // Thread #0 now grabs a write lock, which should panic (read-write)
+        let _t0w0 = lock.write(); // panics
+    }
+}
diff --git a/egui/crates/epaint/src/shadow.rs b/egui/crates/epaint/src/shadow.rs
new file mode 100644
index 0000000..ad13037
--- /dev/null
+++ b/egui/crates/epaint/src/shadow.rs
@@ -0,0 +1,87 @@
+use super::*;
+
+/// The color and fuzziness of a fuzzy shape.
+/// Can be used for a rectangular shadow with a soft penumbra.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Shadow {
+    /// The shadow extends this much outside the rect.
+    /// The size of the fuzzy penumbra.
+    pub extrusion: f32,
+
+    /// Color of the opaque center of the shadow.
+    pub color: Color32,
+}
+
+impl Shadow {
+    pub const NONE: Self = Self {
+        extrusion: 0.0,
+        color: Color32::TRANSPARENT,
+    };
+
+    /// Tooltips, menus, …, for dark mode.
+    pub fn small_dark() -> Self {
+        Self {
+            extrusion: 16.0,
+            color: Color32::from_black_alpha(96),
+        }
+    }
+
+    /// Tooltips, menus, …, for light mode.
+    pub fn small_light() -> Self {
+        Self {
+            extrusion: 16.0,
+            color: Color32::from_black_alpha(20),
+        }
+    }
+
+    /// Used for egui windows in dark mode.
+    pub fn big_dark() -> Self {
+        Self {
+            extrusion: 32.0,
+            color: Color32::from_black_alpha(96),
+        }
+    }
+
+    /// Used for egui windows in light mode.
+    pub fn big_light() -> Self {
+        Self {
+            extrusion: 32.0,
+            color: Color32::from_black_alpha(16),
+        }
+    }
+
+    pub fn tessellate(&self, rect: Rect, rounding: impl Into<Rounding>) -> Mesh {
+        // tessellator.clip_rect = clip_rect; // TODO(emilk): culling
+
+        let Self { extrusion, color } = *self;
+
+        let rounding: Rounding = rounding.into();
+        let half_ext = 0.5 * extrusion;
+
+        let ext_rounding = Rounding {
+            nw: rounding.nw + half_ext,
+            ne: rounding.ne + half_ext,
+            sw: rounding.sw + half_ext,
+            se: rounding.se + half_ext,
+        };
+
+        use crate::tessellator::*;
+        let rect = RectShape::filled(rect.expand(half_ext), ext_rounding, color);
+        let pixels_per_point = 1.0; // doesn't matter here
+        let font_tex_size = [1; 2]; // unused size we are not tessellating text.
+        let mut tessellator = Tessellator::new(
+            pixels_per_point,
+            TessellationOptions {
+                feathering: true,
+                feathering_size_in_pixels: extrusion * pixels_per_point,
+                ..Default::default()
+            },
+            font_tex_size,
+            vec![],
+        );
+        let mut mesh = Mesh::default();
+        tessellator.tessellate_rect(&rect, &mut mesh);
+        mesh
+    }
+}
diff --git a/egui/crates/epaint/src/shape.rs b/egui/crates/epaint/src/shape.rs
new file mode 100644
index 0000000..0462156
--- /dev/null
+++ b/egui/crates/epaint/src/shape.rs
@@ -0,0 +1,846 @@
+//! The different shapes that can be painted.
+
+use std::ops::RangeInclusive;
+use std::{any::Any, sync::Arc};
+
+use crate::{
+    text::{FontId, Fonts, Galley},
+    Color32, Mesh, Stroke, TextureId,
+};
+use emath::*;
+
+pub use crate::{CubicBezierShape, QuadraticBezierShape};
+
+/// A paint primitive such as a circle or a piece of text.
+/// Coordinates are all screen space points (not physical pixels).
+///
+/// You should generally recreate your [`Shape`]s each frame,
+/// but storing them should also be fine with one exception:
+/// [`Shape::Text`] depends on the current `pixels_per_point` (dpi scale)
+/// and so must be recreated every time `pixels_per_point` changes.
+#[must_use = "Add a Shape to a Painter"]
+#[derive(Clone, Debug, PartialEq)]
+pub enum Shape {
+    /// Paint nothing. This can be useful as a placeholder.
+    Noop,
+
+    /// Recursively nest more shapes - sometimes a convenience to be able to do.
+    /// For performance reasons it is better to avoid it.
+    Vec(Vec<Shape>),
+
+    /// Circle with optional outline and fill.
+    Circle(CircleShape),
+
+    /// A line between two points.
+    LineSegment { points: [Pos2; 2], stroke: Stroke },
+
+    /// A series of lines between points.
+    /// The path can have a stroke and/or fill (if closed).
+    Path(PathShape),
+
+    /// Rectangle with optional outline and fill.
+    Rect(RectShape),
+
+    /// Text.
+    ///
+    /// This needs to be recreated if `pixels_per_point` (dpi scale) changes.
+    Text(TextShape),
+
+    /// A general triangle mesh.
+    ///
+    /// Can be used to display images.
+    Mesh(Mesh),
+
+    /// A quadratic [Bézier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+    QuadraticBezier(QuadraticBezierShape),
+
+    /// A cubic [Bézier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+    CubicBezier(CubicBezierShape),
+
+    /// Backend-specific painting.
+    Callback(PaintCallback),
+}
+
+#[test]
+fn shape_impl_send_sync() {
+    fn assert_send_sync<T: Send + Sync>() {}
+    assert_send_sync::<Shape>();
+}
+
+impl From<Vec<Shape>> for Shape {
+    #[inline(always)]
+    fn from(shapes: Vec<Shape>) -> Self {
+        Self::Vec(shapes)
+    }
+}
+
+impl From<Mesh> for Shape {
+    #[inline(always)]
+    fn from(mesh: Mesh) -> Self {
+        Self::Mesh(mesh)
+    }
+}
+
+/// ## Constructors
+impl Shape {
+    /// A line between two points.
+    /// More efficient than calling [`Self::line`].
+    #[inline]
+    pub fn line_segment(points: [Pos2; 2], stroke: impl Into<Stroke>) -> Self {
+        Self::LineSegment {
+            points,
+            stroke: stroke.into(),
+        }
+    }
+
+    /// A horizontal line.
+    pub fn hline(x: RangeInclusive<f32>, y: f32, stroke: impl Into<Stroke>) -> Self {
+        Shape::LineSegment {
+            points: [pos2(*x.start(), y), pos2(*x.end(), y)],
+            stroke: stroke.into(),
+        }
+    }
+
+    /// A vertical line.
+    pub fn vline(x: f32, y: RangeInclusive<f32>, stroke: impl Into<Stroke>) -> Self {
+        Shape::LineSegment {
+            points: [pos2(x, *y.start()), pos2(x, *y.end())],
+            stroke: stroke.into(),
+        }
+    }
+
+    /// A line through many points.
+    ///
+    /// Use [`Self::line_segment`] instead if your line only connects two points.
+    #[inline]
+    pub fn line(points: Vec<Pos2>, stroke: impl Into<Stroke>) -> Self {
+        Self::Path(PathShape::line(points, stroke))
+    }
+
+    /// A line that closes back to the start point again.
+    #[inline]
+    pub fn closed_line(points: Vec<Pos2>, stroke: impl Into<Stroke>) -> Self {
+        Self::Path(PathShape::closed_line(points, stroke))
+    }
+
+    /// Turn a line into equally spaced dots.
+    pub fn dotted_line(
+        path: &[Pos2],
+        color: impl Into<Color32>,
+        spacing: f32,
+        radius: f32,
+    ) -> Vec<Self> {
+        let mut shapes = Vec::new();
+        points_from_line(path, spacing, radius, color.into(), &mut shapes);
+        shapes
+    }
+
+    /// Turn a line into dashes.
+    pub fn dashed_line(
+        path: &[Pos2],
+        stroke: impl Into<Stroke>,
+        dash_length: f32,
+        gap_length: f32,
+    ) -> Vec<Self> {
+        let mut shapes = Vec::new();
+        dashes_from_line(path, stroke.into(), dash_length, gap_length, &mut shapes);
+        shapes
+    }
+
+    /// Turn a line into dashes. If you need to create many dashed lines use this instead of
+    /// [`Self::dashed_line`]
+    pub fn dashed_line_many(
+        points: &[Pos2],
+        stroke: impl Into<Stroke>,
+        dash_length: f32,
+        gap_length: f32,
+        shapes: &mut Vec<Shape>,
+    ) {
+        dashes_from_line(points, stroke.into(), dash_length, gap_length, shapes);
+    }
+
+    /// A convex polygon with a fill and optional stroke.
+    ///
+    /// The most performant winding order is clockwise.
+    #[inline]
+    pub fn convex_polygon(
+        points: Vec<Pos2>,
+        fill: impl Into<Color32>,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        Self::Path(PathShape::convex_polygon(points, fill, stroke))
+    }
+
+    #[inline]
+    pub fn circle_filled(center: Pos2, radius: f32, fill_color: impl Into<Color32>) -> Self {
+        Self::Circle(CircleShape::filled(center, radius, fill_color))
+    }
+
+    #[inline]
+    pub fn circle_stroke(center: Pos2, radius: f32, stroke: impl Into<Stroke>) -> Self {
+        Self::Circle(CircleShape::stroke(center, radius, stroke))
+    }
+
+    #[inline]
+    pub fn rect_filled(
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+    ) -> Self {
+        Self::Rect(RectShape::filled(rect, rounding, fill_color))
+    }
+
+    #[inline]
+    pub fn rect_stroke(
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        Self::Rect(RectShape::stroke(rect, rounding, stroke))
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn text(
+        fonts: &Fonts,
+        pos: Pos2,
+        anchor: Align2,
+        text: impl ToString,
+        font_id: FontId,
+        color: Color32,
+    ) -> Self {
+        let galley = fonts.layout_no_wrap(text.to_string(), font_id, color);
+        let rect = anchor.anchor_rect(Rect::from_min_size(pos, galley.size()));
+        Self::galley(rect.min, galley)
+    }
+
+    #[inline]
+    pub fn galley(pos: Pos2, galley: Arc<Galley>) -> Self {
+        TextShape::new(pos, galley).into()
+    }
+
+    #[inline]
+    /// The text color in the [`Galley`] will be replaced with the given color.
+    pub fn galley_with_color(pos: Pos2, galley: Arc<Galley>, text_color: Color32) -> Self {
+        TextShape {
+            override_text_color: Some(text_color),
+            ..TextShape::new(pos, galley)
+        }
+        .into()
+    }
+
+    pub fn mesh(mesh: Mesh) -> Self {
+        crate::epaint_assert!(mesh.is_valid());
+        Self::Mesh(mesh)
+    }
+
+    /// An image at the given position.
+    ///
+    /// `uv` should normally be `Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0))`
+    /// unless you want to crop or flip the image.
+    ///
+    /// `tint` is a color multiplier. Use [`Color32::WHITE`] if you don't want to tint the image.
+    pub fn image(texture_id: TextureId, rect: Rect, uv: Rect, tint: Color32) -> Self {
+        let mut mesh = Mesh::with_texture(texture_id);
+        mesh.add_rect_with_uv(rect, uv, tint);
+        Shape::mesh(mesh)
+    }
+
+    /// The visual bounding rectangle (includes stroke widths)
+    pub fn visual_bounding_rect(&self) -> Rect {
+        match self {
+            Self::Noop => Rect::NOTHING,
+            Self::Vec(shapes) => {
+                let mut rect = Rect::NOTHING;
+                for shape in shapes {
+                    rect = rect.union(shape.visual_bounding_rect());
+                }
+                rect
+            }
+            Self::Circle(circle_shape) => circle_shape.visual_bounding_rect(),
+            Self::LineSegment { points, stroke } => {
+                if stroke.is_empty() {
+                    Rect::NOTHING
+                } else {
+                    Rect::from_two_pos(points[0], points[1]).expand(stroke.width / 2.0)
+                }
+            }
+            Self::Path(path_shape) => path_shape.visual_bounding_rect(),
+            Self::Rect(rect_shape) => rect_shape.visual_bounding_rect(),
+            Self::Text(text_shape) => text_shape.visual_bounding_rect(),
+            Self::Mesh(mesh) => mesh.calc_bounds(),
+            Self::QuadraticBezier(bezier) => bezier.visual_bounding_rect(),
+            Self::CubicBezier(bezier) => bezier.visual_bounding_rect(),
+            Self::Callback(custom) => custom.rect,
+        }
+    }
+}
+
+/// ## Inspection and transforms
+impl Shape {
+    #[inline(always)]
+    pub fn texture_id(&self) -> super::TextureId {
+        if let Shape::Mesh(mesh) = self {
+            mesh.texture_id
+        } else {
+            super::TextureId::default()
+        }
+    }
+
+    /// Move the shape by this many points, in-place.
+    pub fn translate(&mut self, delta: Vec2) {
+        match self {
+            Shape::Noop => {}
+            Shape::Vec(shapes) => {
+                for shape in shapes {
+                    shape.translate(delta);
+                }
+            }
+            Shape::Circle(circle_shape) => {
+                circle_shape.center += delta;
+            }
+            Shape::LineSegment { points, .. } => {
+                for p in points {
+                    *p += delta;
+                }
+            }
+            Shape::Path(path_shape) => {
+                for p in &mut path_shape.points {
+                    *p += delta;
+                }
+            }
+            Shape::Rect(rect_shape) => {
+                rect_shape.rect = rect_shape.rect.translate(delta);
+            }
+            Shape::Text(text_shape) => {
+                text_shape.pos += delta;
+            }
+            Shape::Mesh(mesh) => {
+                mesh.translate(delta);
+            }
+            Shape::QuadraticBezier(bezier_shape) => {
+                bezier_shape.points[0] += delta;
+                bezier_shape.points[1] += delta;
+                bezier_shape.points[2] += delta;
+            }
+            Shape::CubicBezier(cubic_curve) => {
+                for p in &mut cubic_curve.points {
+                    *p += delta;
+                }
+            }
+            Shape::Callback(shape) => {
+                shape.rect = shape.rect.translate(delta);
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// How to paint a circle.
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct CircleShape {
+    pub center: Pos2,
+    pub radius: f32,
+    pub fill: Color32,
+    pub stroke: Stroke,
+}
+
+impl CircleShape {
+    #[inline]
+    pub fn filled(center: Pos2, radius: f32, fill_color: impl Into<Color32>) -> Self {
+        Self {
+            center,
+            radius,
+            fill: fill_color.into(),
+            stroke: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn stroke(center: Pos2, radius: f32, stroke: impl Into<Stroke>) -> Self {
+        Self {
+            center,
+            radius,
+            fill: Default::default(),
+            stroke: stroke.into(),
+        }
+    }
+
+    /// The visual bounding rectangle (includes stroke width)
+    pub fn visual_bounding_rect(&self) -> Rect {
+        if self.fill == Color32::TRANSPARENT && self.stroke.is_empty() {
+            Rect::NOTHING
+        } else {
+            Rect::from_center_size(
+                self.center,
+                Vec2::splat(self.radius * 2.0 + self.stroke.width),
+            )
+        }
+    }
+}
+
+impl From<CircleShape> for Shape {
+    #[inline(always)]
+    fn from(shape: CircleShape) -> Self {
+        Self::Circle(shape)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A path which can be stroked and/or filled (if closed).
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PathShape {
+    /// Filled paths should prefer clockwise order.
+    pub points: Vec<Pos2>,
+
+    /// If true, connect the first and last of the points together.
+    /// This is required if `fill != TRANSPARENT`.
+    pub closed: bool,
+
+    /// Fill is only supported for convex polygons.
+    pub fill: Color32,
+
+    /// Color and thickness of the line.
+    pub stroke: Stroke,
+}
+
+impl PathShape {
+    /// A line through many points.
+    ///
+    /// Use [`Shape::line_segment`] instead if your line only connects two points.
+    #[inline]
+    pub fn line(points: Vec<Pos2>, stroke: impl Into<Stroke>) -> Self {
+        PathShape {
+            points,
+            closed: false,
+            fill: Default::default(),
+            stroke: stroke.into(),
+        }
+    }
+
+    /// A line that closes back to the start point again.
+    #[inline]
+    pub fn closed_line(points: Vec<Pos2>, stroke: impl Into<Stroke>) -> Self {
+        PathShape {
+            points,
+            closed: true,
+            fill: Default::default(),
+            stroke: stroke.into(),
+        }
+    }
+
+    /// A convex polygon with a fill and optional stroke.
+    ///
+    /// The most performant winding order is clockwise.
+    #[inline]
+    pub fn convex_polygon(
+        points: Vec<Pos2>,
+        fill: impl Into<Color32>,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        PathShape {
+            points,
+            closed: true,
+            fill: fill.into(),
+            stroke: stroke.into(),
+        }
+    }
+
+    /// The visual bounding rectangle (includes stroke width)
+    #[inline]
+    pub fn visual_bounding_rect(&self) -> Rect {
+        if self.fill == Color32::TRANSPARENT && self.stroke.is_empty() {
+            Rect::NOTHING
+        } else {
+            Rect::from_points(&self.points).expand(self.stroke.width / 2.0)
+        }
+    }
+}
+
+impl From<PathShape> for Shape {
+    #[inline(always)]
+    fn from(shape: PathShape) -> Self {
+        Self::Path(shape)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// How to paint a rectangle.
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct RectShape {
+    pub rect: Rect,
+
+    /// How rounded the corners are. Use `Rounding::none()` for no rounding.
+    pub rounding: Rounding,
+
+    /// How to fill the rectangle.
+    pub fill: Color32,
+
+    /// The thickness and color of the outline.
+    pub stroke: Stroke,
+}
+
+impl RectShape {
+    #[inline]
+    pub fn filled(
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+    ) -> Self {
+        Self {
+            rect,
+            rounding: rounding.into(),
+            fill: fill_color.into(),
+            stroke: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn stroke(rect: Rect, rounding: impl Into<Rounding>, stroke: impl Into<Stroke>) -> Self {
+        Self {
+            rect,
+            rounding: rounding.into(),
+            fill: Default::default(),
+            stroke: stroke.into(),
+        }
+    }
+
+    /// The visual bounding rectangle (includes stroke width)
+    #[inline]
+    pub fn visual_bounding_rect(&self) -> Rect {
+        if self.fill == Color32::TRANSPARENT && self.stroke.is_empty() {
+            Rect::NOTHING
+        } else {
+            self.rect.expand(self.stroke.width / 2.0)
+        }
+    }
+}
+
+impl From<RectShape> for Shape {
+    #[inline(always)]
+    fn from(shape: RectShape) -> Self {
+        Self::Rect(shape)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+/// How rounded the corners of things should be
+pub struct Rounding {
+    /// Radius of the rounding of the North-West (left top) corner.
+    pub nw: f32,
+
+    /// Radius of the rounding of the North-East (right top) corner.
+    pub ne: f32,
+
+    /// Radius of the rounding of the South-West (left bottom) corner.
+    pub sw: f32,
+
+    /// Radius of the rounding of the South-East (right bottom) corner.
+    pub se: f32,
+}
+
+impl Default for Rounding {
+    #[inline]
+    fn default() -> Self {
+        Self::none()
+    }
+}
+
+impl From<f32> for Rounding {
+    #[inline]
+    fn from(radius: f32) -> Self {
+        Self {
+            nw: radius,
+            ne: radius,
+            sw: radius,
+            se: radius,
+        }
+    }
+}
+
+impl Rounding {
+    #[inline]
+    pub fn same(radius: f32) -> Self {
+        Self {
+            nw: radius,
+            ne: radius,
+            sw: radius,
+            se: radius,
+        }
+    }
+
+    #[inline]
+    pub fn none() -> Self {
+        Self {
+            nw: 0.0,
+            ne: 0.0,
+            sw: 0.0,
+            se: 0.0,
+        }
+    }
+
+    /// Do all corners have the same rounding?
+    #[inline]
+    pub fn is_same(&self) -> bool {
+        self.nw == self.ne && self.nw == self.sw && self.nw == self.se
+    }
+
+    /// Make sure each corner has a rounding of at least this.
+    #[inline]
+    pub fn at_least(&self, min: f32) -> Self {
+        Self {
+            nw: self.nw.max(min),
+            ne: self.ne.max(min),
+            sw: self.sw.max(min),
+            se: self.se.max(min),
+        }
+    }
+
+    /// Make sure each corner has a rounding of at most this.
+    #[inline]
+    pub fn at_most(&self, max: f32) -> Self {
+        Self {
+            nw: self.nw.min(max),
+            ne: self.ne.min(max),
+            sw: self.sw.min(max),
+            se: self.se.min(max),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// How to paint some text on screen.
+///
+/// This needs to be recreated if `pixels_per_point` (dpi scale) changes.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TextShape {
+    /// Top left corner of the first character.
+    pub pos: Pos2,
+
+    /// The laid out text, from [`Fonts::layout_job`].
+    pub galley: Arc<Galley>,
+
+    /// Add this underline to the whole text.
+    /// You can also set an underline when creating the galley.
+    pub underline: Stroke,
+
+    /// If set, the text color in the galley will be ignored and replaced
+    /// with the given color.
+    /// This will NOT replace background color nor strikethrough/underline color.
+    pub override_text_color: Option<Color32>,
+
+    /// Rotate text by this many radians clockwise.
+    /// The pivot is `pos` (the upper left corner of the text).
+    pub angle: f32,
+}
+
+impl TextShape {
+    #[inline]
+    pub fn new(pos: Pos2, galley: Arc<Galley>) -> Self {
+        Self {
+            pos,
+            galley,
+            underline: Stroke::NONE,
+            override_text_color: None,
+            angle: 0.0,
+        }
+    }
+
+    /// The visual bounding rectangle
+    #[inline]
+    pub fn visual_bounding_rect(&self) -> Rect {
+        self.galley.mesh_bounds.translate(self.pos.to_vec2())
+    }
+}
+
+impl From<TextShape> for Shape {
+    #[inline(always)]
+    fn from(shape: TextShape) -> Self {
+        Self::Text(shape)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Creates equally spaced filled circles from a line.
+fn points_from_line(
+    path: &[Pos2],
+    spacing: f32,
+    radius: f32,
+    color: Color32,
+    shapes: &mut Vec<Shape>,
+) {
+    let mut position_on_segment = 0.0;
+    path.windows(2).for_each(|window| {
+        let (start, end) = (window[0], window[1]);
+        let vector = end - start;
+        let segment_length = vector.length();
+        while position_on_segment < segment_length {
+            let new_point = start + vector * (position_on_segment / segment_length);
+            shapes.push(Shape::circle_filled(new_point, radius, color));
+            position_on_segment += spacing;
+        }
+        position_on_segment -= segment_length;
+    });
+}
+
+/// Creates dashes from a line.
+fn dashes_from_line(
+    path: &[Pos2],
+    stroke: Stroke,
+    dash_length: f32,
+    gap_length: f32,
+    shapes: &mut Vec<Shape>,
+) {
+    let mut position_on_segment = 0.0;
+    let mut drawing_dash = false;
+    path.windows(2).for_each(|window| {
+        let (start, end) = (window[0], window[1]);
+        let vector = end - start;
+        let segment_length = vector.length();
+
+        let mut start_point = start;
+        while position_on_segment < segment_length {
+            let new_point = start + vector * (position_on_segment / segment_length);
+            if drawing_dash {
+                // This is the end point.
+                shapes.push(Shape::line_segment([start_point, new_point], stroke));
+                position_on_segment += gap_length;
+            } else {
+                // Start a new dash.
+                start_point = new_point;
+                position_on_segment += dash_length;
+            }
+            drawing_dash = !drawing_dash;
+        }
+
+        // If the segment ends and the dash is not finished, add the segment's end point.
+        if drawing_dash {
+            shapes.push(Shape::line_segment([start_point, end], stroke));
+        }
+
+        position_on_segment -= segment_length;
+    });
+}
+
+// ----------------------------------------------------------------------------
+
+/// Information passed along with [`PaintCallback`] ([`Shape::Callback`]).
+pub struct PaintCallbackInfo {
+    /// Viewport in points.
+    ///
+    /// This specifies where on the screen to paint, and the borders of this
+    /// Rect is the [-1, +1] of the Normalized Device Coordinates.
+    ///
+    /// Note than only a portion of this may be visible due to [`Self::clip_rect`].
+    pub viewport: Rect,
+
+    /// Clip rectangle in points.
+    pub clip_rect: Rect,
+
+    /// Pixels per point.
+    pub pixels_per_point: f32,
+
+    /// Full size of the screen, in pixels.
+    pub screen_size_px: [u32; 2],
+}
+
+pub struct ViewportInPixels {
+    /// Physical pixel offset for left side of the viewport.
+    pub left_px: f32,
+
+    /// Physical pixel offset for top side of the viewport.
+    pub top_px: f32,
+
+    /// Physical pixel offset for bottom side of the viewport.
+    ///
+    /// This is what `glViewport`, `glScissor` etc expects for the y axis.
+    pub from_bottom_px: f32,
+
+    /// Viewport width in physical pixels.
+    pub width_px: f32,
+
+    /// Viewport height in physical pixels.
+    pub height_px: f32,
+}
+
+impl PaintCallbackInfo {
+    fn points_to_pixels(&self, rect: &Rect) -> ViewportInPixels {
+        ViewportInPixels {
+            left_px: rect.min.x * self.pixels_per_point,
+            top_px: rect.min.y * self.pixels_per_point,
+            from_bottom_px: self.screen_size_px[1] as f32 - rect.max.y * self.pixels_per_point,
+            width_px: rect.width() * self.pixels_per_point,
+            height_px: rect.height() * self.pixels_per_point,
+        }
+    }
+
+    /// The viewport rectangle. This is what you would use in e.g. `glViewport`.
+    pub fn viewport_in_pixels(&self) -> ViewportInPixels {
+        self.points_to_pixels(&self.viewport)
+    }
+
+    /// The "scissor" or "clip" rectangle. This is what you would use in e.g. `glScissor`.
+    pub fn clip_rect_in_pixels(&self) -> ViewportInPixels {
+        self.points_to_pixels(&self.clip_rect)
+    }
+}
+
+/// If you want to paint some 3D shapes inside an egui region, you can use this.
+///
+/// This is advanced usage, and is backend specific.
+#[derive(Clone)]
+pub struct PaintCallback {
+    /// Where to paint.
+    pub rect: Rect,
+
+    /// Paint something custom (e.g. 3D stuff).
+    ///
+    /// The concrete value of `callback` depends on the rendering backend used. For instance, the
+    /// `glow` backend requires that callback be an `egui_glow::CallbackFn` while the `wgpu`
+    /// backend requires a `egui_wgpu::CallbackFn`.
+    ///
+    /// If the type cannot be downcast to the type expected by the current backend the callback
+    /// will not be drawn.
+    ///
+    /// The rendering backend is responsible for first setting the active viewport to
+    /// [`Self::rect`].
+    ///
+    /// The rendering backend is also responsible for restoring any state, such as the bound shader
+    /// program, vertex array, etc.
+    pub callback: Arc<dyn Any + Sync + Send>,
+}
+
+impl std::fmt::Debug for PaintCallback {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CustomShape")
+            .field("rect", &self.rect)
+            .finish_non_exhaustive()
+    }
+}
+
+impl std::cmp::PartialEq for PaintCallback {
+    fn eq(&self, other: &Self) -> bool {
+        // As I understand it, the problem this clippy is trying to protect against
+        // can only happen if we do dynamic casts back and forth on the pointers, and we don't do that.
+        #[allow(clippy::vtable_address_comparisons)]
+        {
+            self.rect.eq(&other.rect) && Arc::ptr_eq(&self.callback, &other.callback)
+        }
+    }
+}
+
+impl From<PaintCallback> for Shape {
+    #[inline(always)]
+    fn from(shape: PaintCallback) -> Self {
+        Self::Callback(shape)
+    }
+}
diff --git a/egui/crates/epaint/src/shape_transform.rs b/egui/crates/epaint/src/shape_transform.rs
new file mode 100644
index 0000000..1b0e9c7
--- /dev/null
+++ b/egui/crates/epaint/src/shape_transform.rs
@@ -0,0 +1,58 @@
+use crate::*;
+
+pub fn adjust_colors(shape: &mut Shape, adjust_color: &impl Fn(&mut Color32)) {
+    #![allow(clippy::match_same_arms)]
+    match shape {
+        Shape::Noop => {}
+        Shape::Vec(shapes) => {
+            for shape in shapes {
+                adjust_colors(shape, adjust_color);
+            }
+        }
+        Shape::Circle(circle_shape) => {
+            adjust_color(&mut circle_shape.fill);
+            adjust_color(&mut circle_shape.stroke.color);
+        }
+        Shape::LineSegment { stroke, .. } => {
+            adjust_color(&mut stroke.color);
+        }
+        Shape::Path(path_shape) => {
+            adjust_color(&mut path_shape.fill);
+            adjust_color(&mut path_shape.stroke.color);
+        }
+        Shape::Rect(rect_shape) => {
+            adjust_color(&mut rect_shape.fill);
+            adjust_color(&mut rect_shape.stroke.color);
+        }
+        Shape::Text(text_shape) => {
+            if let Some(override_text_color) = &mut text_shape.override_text_color {
+                adjust_color(override_text_color);
+            }
+
+            if !text_shape.galley.is_empty() {
+                let galley = std::sync::Arc::make_mut(&mut text_shape.galley);
+                for row in &mut galley.rows {
+                    for vertex in &mut row.visuals.mesh.vertices {
+                        adjust_color(&mut vertex.color);
+                    }
+                }
+            }
+        }
+        Shape::Mesh(mesh) => {
+            for v in &mut mesh.vertices {
+                adjust_color(&mut v.color);
+            }
+        }
+        Shape::QuadraticBezier(quadratic) => {
+            adjust_color(&mut quadratic.fill);
+            adjust_color(&mut quadratic.stroke.color);
+        }
+        Shape::CubicBezier(bezier) => {
+            adjust_color(&mut bezier.fill);
+            adjust_color(&mut bezier.stroke.color);
+        }
+        Shape::Callback(_) => {
+            // Can't tint user callback code
+        }
+    }
+}
diff --git a/egui/crates/epaint/src/stats.rs b/egui/crates/epaint/src/stats.rs
new file mode 100644
index 0000000..5abbe45
--- /dev/null
+++ b/egui/crates/epaint/src/stats.rs
@@ -0,0 +1,245 @@
+//! Collect statistics about what is being painted.
+
+use crate::*;
+
+/// Size of the elements in a vector/array.
+#[derive(Clone, Copy, PartialEq)]
+enum ElementSize {
+    Unknown,
+    Homogeneous(usize),
+    Heterogenous,
+}
+
+impl Default for ElementSize {
+    fn default() -> Self {
+        Self::Unknown
+    }
+}
+
+/// Aggregate information about a bunch of allocations.
+#[derive(Clone, Copy, Default, PartialEq)]
+pub struct AllocInfo {
+    element_size: ElementSize,
+    num_allocs: usize,
+    num_elements: usize,
+    num_bytes: usize,
+}
+
+impl<T> From<&[T]> for AllocInfo {
+    fn from(slice: &[T]) -> Self {
+        Self::from_slice(slice)
+    }
+}
+
+impl std::ops::Add for AllocInfo {
+    type Output = AllocInfo;
+
+    fn add(self, rhs: AllocInfo) -> AllocInfo {
+        use ElementSize::{Heterogenous, Homogeneous, Unknown};
+        let element_size = match (self.element_size, rhs.element_size) {
+            (Heterogenous, _) | (_, Heterogenous) => Heterogenous,
+            (Unknown, other) | (other, Unknown) => other,
+            (Homogeneous(lhs), Homogeneous(rhs)) if lhs == rhs => Homogeneous(lhs),
+            _ => Heterogenous,
+        };
+
+        AllocInfo {
+            element_size,
+            num_allocs: self.num_allocs + rhs.num_allocs,
+            num_elements: self.num_elements + rhs.num_elements,
+            num_bytes: self.num_bytes + rhs.num_bytes,
+        }
+    }
+}
+
+impl std::ops::AddAssign for AllocInfo {
+    fn add_assign(&mut self, rhs: AllocInfo) {
+        *self = *self + rhs;
+    }
+}
+
+impl std::iter::Sum for AllocInfo {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        let mut sum = Self::default();
+        for value in iter {
+            sum += value;
+        }
+        sum
+    }
+}
+
+impl AllocInfo {
+    // pub fn from_shape(shape: &Shape) -> Self {
+    //     match shape {
+    //         Shape::Noop
+    //         Shape::Vec(shapes) => Self::from_shapes(shapes)
+    //         | Shape::Circle { .. }
+    //         | Shape::LineSegment { .. }
+    //         | Shape::Rect { .. } => Self::default(),
+    //         Shape::Path { points, .. } => Self::from_slice(points),
+    //         Shape::Text { galley, .. } => Self::from_galley(galley),
+    //         Shape::Mesh(mesh) => Self::from_mesh(mesh),
+    //     }
+    // }
+
+    pub fn from_galley(galley: &Galley) -> Self {
+        Self::from_slice(galley.text().as_bytes())
+            + Self::from_slice(&galley.rows)
+            + galley.rows.iter().map(Self::from_galley_row).sum()
+    }
+
+    fn from_galley_row(row: &crate::text::Row) -> Self {
+        Self::from_mesh(&row.visuals.mesh) + Self::from_slice(&row.glyphs)
+    }
+
+    pub fn from_mesh(mesh: &Mesh) -> Self {
+        Self::from_slice(&mesh.indices) + Self::from_slice(&mesh.vertices)
+    }
+
+    pub fn from_slice<T>(slice: &[T]) -> Self {
+        use std::mem::size_of;
+        let element_size = size_of::<T>();
+        Self {
+            element_size: ElementSize::Homogeneous(element_size),
+            num_allocs: 1,
+            num_elements: slice.len(),
+            num_bytes: slice.len() * element_size,
+        }
+    }
+
+    pub fn num_elements(&self) -> usize {
+        assert!(self.element_size != ElementSize::Heterogenous);
+        self.num_elements
+    }
+
+    pub fn num_allocs(&self) -> usize {
+        self.num_allocs
+    }
+
+    pub fn num_bytes(&self) -> usize {
+        self.num_bytes
+    }
+
+    pub fn megabytes(&self) -> String {
+        megabytes(self.num_bytes())
+    }
+
+    pub fn format(&self, what: &str) -> String {
+        if self.num_allocs() == 0 {
+            format!("{:6} {:16}", 0, what)
+        } else if self.num_allocs() == 1 {
+            format!(
+                "{:6} {:16}  {}       1 allocation",
+                self.num_elements,
+                what,
+                self.megabytes()
+            )
+        } else if self.element_size != ElementSize::Heterogenous {
+            format!(
+                "{:6} {:16}  {}     {:3} allocations",
+                self.num_elements(),
+                what,
+                self.megabytes(),
+                self.num_allocs()
+            )
+        } else {
+            format!(
+                "{:6} {:16}  {}     {:3} allocations",
+                "",
+                what,
+                self.megabytes(),
+                self.num_allocs()
+            )
+        }
+    }
+}
+
+/// Collected allocation statistics for shapes and meshes.
+#[derive(Clone, Copy, Default)]
+pub struct PaintStats {
+    pub shapes: AllocInfo,
+    pub shape_text: AllocInfo,
+    pub shape_path: AllocInfo,
+    pub shape_mesh: AllocInfo,
+    pub shape_vec: AllocInfo,
+    pub num_callbacks: usize,
+
+    pub text_shape_vertices: AllocInfo,
+    pub text_shape_indices: AllocInfo,
+
+    /// Number of separate clip rectangles
+    pub clipped_primitives: AllocInfo,
+    pub vertices: AllocInfo,
+    pub indices: AllocInfo,
+}
+
+impl PaintStats {
+    pub fn from_shapes(shapes: &[ClippedShape]) -> Self {
+        let mut stats = Self::default();
+        stats.shape_path.element_size = ElementSize::Heterogenous; // nicer display later
+        stats.shape_vec.element_size = ElementSize::Heterogenous; // nicer display later
+
+        stats.shapes = AllocInfo::from_slice(shapes);
+        for ClippedShape(_, shape) in shapes {
+            stats.add(shape);
+        }
+        stats
+    }
+
+    fn add(&mut self, shape: &Shape) {
+        match shape {
+            Shape::Vec(shapes) => {
+                // self += PaintStats::from_shapes(&shapes); // TODO
+                self.shapes += AllocInfo::from_slice(shapes);
+                self.shape_vec += AllocInfo::from_slice(shapes);
+                for shape in shapes {
+                    self.add(shape);
+                }
+            }
+            Shape::Noop
+            | Shape::Circle { .. }
+            | Shape::LineSegment { .. }
+            | Shape::Rect { .. }
+            | Shape::CubicBezier(_)
+            | Shape::QuadraticBezier(_) => {}
+            Shape::Path(path_shape) => {
+                self.shape_path += AllocInfo::from_slice(&path_shape.points);
+            }
+            Shape::Text(text_shape) => {
+                self.shape_text += AllocInfo::from_galley(&text_shape.galley);
+
+                for row in &text_shape.galley.rows {
+                    self.text_shape_indices += AllocInfo::from_slice(&row.visuals.mesh.indices);
+                    self.text_shape_vertices += AllocInfo::from_slice(&row.visuals.mesh.vertices);
+                }
+            }
+            Shape::Mesh(mesh) => {
+                self.shape_mesh += AllocInfo::from_mesh(mesh);
+            }
+            Shape::Callback(_) => {
+                self.num_callbacks += 1;
+            }
+        }
+    }
+
+    pub fn with_clipped_primitives(
+        mut self,
+        clipped_primitives: &[crate::ClippedPrimitive],
+    ) -> Self {
+        self.clipped_primitives += AllocInfo::from_slice(clipped_primitives);
+        for clipped_primitive in clipped_primitives {
+            if let Primitive::Mesh(mesh) = &clipped_primitive.primitive {
+                self.vertices += AllocInfo::from_slice(&mesh.vertices);
+                self.indices += AllocInfo::from_slice(&mesh.indices);
+            }
+        }
+        self
+    }
+}
+
+fn megabytes(size: usize) -> String {
+    format!("{:.2} MB", size as f64 / 1e6)
+}
diff --git a/egui/crates/epaint/src/stroke.rs b/egui/crates/epaint/src/stroke.rs
new file mode 100644
index 0000000..acfa4ef
--- /dev/null
+++ b/egui/crates/epaint/src/stroke.rs
@@ -0,0 +1,60 @@
+#![allow(clippy::derive_hash_xor_eq)] // We need to impl Hash for f32, but we don't implement Eq, which is fine
+
+use super::*;
+
+/// Describes the width and color of a line.
+///
+/// The default stroke is the same as [`Stroke::none`].
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Stroke {
+    pub width: f32,
+    pub color: Color32,
+}
+
+impl Stroke {
+    /// Same as [`Stroke::default`].
+    pub const NONE: Stroke = Stroke {
+        width: 0.0,
+        color: Color32::TRANSPARENT,
+    };
+
+    #[deprecated = "Use Stroke::NONE instead"]
+    #[inline(always)]
+    pub fn none() -> Self {
+        Self::new(0.0, Color32::TRANSPARENT)
+    }
+
+    #[inline]
+    pub fn new(width: impl Into<f32>, color: impl Into<Color32>) -> Self {
+        Self {
+            width: width.into(),
+            color: color.into(),
+        }
+    }
+
+    /// True if width is zero or color is transparent
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.width <= 0.0 || self.color == Color32::TRANSPARENT
+    }
+}
+
+impl<Color> From<(f32, Color)> for Stroke
+where
+    Color: Into<Color32>,
+{
+    #[inline(always)]
+    fn from((width, color): (f32, Color)) -> Stroke {
+        Stroke::new(width, color)
+    }
+}
+
+impl std::hash::Hash for Stroke {
+    #[inline(always)]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let Self { width, color } = *self;
+        crate::f32_hash(state, width);
+        color.hash(state);
+    }
+}
diff --git a/egui/crates/epaint/src/tessellator.rs b/egui/crates/epaint/src/tessellator.rs
new file mode 100644
index 0000000..75b5dc9
--- /dev/null
+++ b/egui/crates/epaint/src/tessellator.rs
@@ -0,0 +1,1657 @@
+//! Converts graphics primitives into textured triangles.
+//!
+//! This module converts lines, circles, text and more represented by [`Shape`]
+//! into textured triangles represented by [`Mesh`].
+
+#![allow(clippy::identity_op)]
+
+use crate::texture_atlas::PreparedDisc;
+use crate::*;
+use emath::*;
+
+// ----------------------------------------------------------------------------
+
+#[allow(clippy::approx_constant)]
+mod precomputed_vertices {
+    /*
+    fn main() {
+        let n = 64;
+        println!("pub const CIRCLE_{}: [Vec2; {}] = [", n, n+1);
+        for i in 0..=n {
+            let a = std::f64::consts::TAU * i as f64 / n as f64;
+            println!("    vec2({:.06}, {:.06}),", a.cos(), a.sin());
+        }
+        println!("];")
+    }
+    */
+
+    use emath::{vec2, Vec2};
+
+    pub const CIRCLE_8: [Vec2; 9] = [
+        vec2(1.000000, 0.000000),
+        vec2(0.707107, 0.707107),
+        vec2(0.000000, 1.000000),
+        vec2(-0.707107, 0.707107),
+        vec2(-1.000000, 0.000000),
+        vec2(-0.707107, -0.707107),
+        vec2(0.000000, -1.000000),
+        vec2(0.707107, -0.707107),
+        vec2(1.000000, 0.000000),
+    ];
+
+    pub const CIRCLE_16: [Vec2; 17] = [
+        vec2(1.000000, 0.000000),
+        vec2(0.923880, 0.382683),
+        vec2(0.707107, 0.707107),
+        vec2(0.382683, 0.923880),
+        vec2(0.000000, 1.000000),
+        vec2(-0.382684, 0.923880),
+        vec2(-0.707107, 0.707107),
+        vec2(-0.923880, 0.382683),
+        vec2(-1.000000, 0.000000),
+        vec2(-0.923880, -0.382683),
+        vec2(-0.707107, -0.707107),
+        vec2(-0.382684, -0.923880),
+        vec2(0.000000, -1.000000),
+        vec2(0.382684, -0.923879),
+        vec2(0.707107, -0.707107),
+        vec2(0.923880, -0.382683),
+        vec2(1.000000, 0.000000),
+    ];
+
+    pub const CIRCLE_32: [Vec2; 33] = [
+        vec2(1.000000, 0.000000),
+        vec2(0.980785, 0.195090),
+        vec2(0.923880, 0.382683),
+        vec2(0.831470, 0.555570),
+        vec2(0.707107, 0.707107),
+        vec2(0.555570, 0.831470),
+        vec2(0.382683, 0.923880),
+        vec2(0.195090, 0.980785),
+        vec2(0.000000, 1.000000),
+        vec2(-0.195090, 0.980785),
+        vec2(-0.382683, 0.923880),
+        vec2(-0.555570, 0.831470),
+        vec2(-0.707107, 0.707107),
+        vec2(-0.831470, 0.555570),
+        vec2(-0.923880, 0.382683),
+        vec2(-0.980785, 0.195090),
+        vec2(-1.000000, 0.000000),
+        vec2(-0.980785, -0.195090),
+        vec2(-0.923880, -0.382683),
+        vec2(-0.831470, -0.555570),
+        vec2(-0.707107, -0.707107),
+        vec2(-0.555570, -0.831470),
+        vec2(-0.382683, -0.923880),
+        vec2(-0.195090, -0.980785),
+        vec2(-0.000000, -1.000000),
+        vec2(0.195090, -0.980785),
+        vec2(0.382683, -0.923880),
+        vec2(0.555570, -0.831470),
+        vec2(0.707107, -0.707107),
+        vec2(0.831470, -0.555570),
+        vec2(0.923880, -0.382683),
+        vec2(0.980785, -0.195090),
+        vec2(1.000000, -0.000000),
+    ];
+
+    pub const CIRCLE_64: [Vec2; 65] = [
+        vec2(1.000000, 0.000000),
+        vec2(0.995185, 0.098017),
+        vec2(0.980785, 0.195090),
+        vec2(0.956940, 0.290285),
+        vec2(0.923880, 0.382683),
+        vec2(0.881921, 0.471397),
+        vec2(0.831470, 0.555570),
+        vec2(0.773010, 0.634393),
+        vec2(0.707107, 0.707107),
+        vec2(0.634393, 0.773010),
+        vec2(0.555570, 0.831470),
+        vec2(0.471397, 0.881921),
+        vec2(0.382683, 0.923880),
+        vec2(0.290285, 0.956940),
+        vec2(0.195090, 0.980785),
+        vec2(0.098017, 0.995185),
+        vec2(0.000000, 1.000000),
+        vec2(-0.098017, 0.995185),
+        vec2(-0.195090, 0.980785),
+        vec2(-0.290285, 0.956940),
+        vec2(-0.382683, 0.923880),
+        vec2(-0.471397, 0.881921),
+        vec2(-0.555570, 0.831470),
+        vec2(-0.634393, 0.773010),
+        vec2(-0.707107, 0.707107),
+        vec2(-0.773010, 0.634393),
+        vec2(-0.831470, 0.555570),
+        vec2(-0.881921, 0.471397),
+        vec2(-0.923880, 0.382683),
+        vec2(-0.956940, 0.290285),
+        vec2(-0.980785, 0.195090),
+        vec2(-0.995185, 0.098017),
+        vec2(-1.000000, 0.000000),
+        vec2(-0.995185, -0.098017),
+        vec2(-0.980785, -0.195090),
+        vec2(-0.956940, -0.290285),
+        vec2(-0.923880, -0.382683),
+        vec2(-0.881921, -0.471397),
+        vec2(-0.831470, -0.555570),
+        vec2(-0.773010, -0.634393),
+        vec2(-0.707107, -0.707107),
+        vec2(-0.634393, -0.773010),
+        vec2(-0.555570, -0.831470),
+        vec2(-0.471397, -0.881921),
+        vec2(-0.382683, -0.923880),
+        vec2(-0.290285, -0.956940),
+        vec2(-0.195090, -0.980785),
+        vec2(-0.098017, -0.995185),
+        vec2(-0.000000, -1.000000),
+        vec2(0.098017, -0.995185),
+        vec2(0.195090, -0.980785),
+        vec2(0.290285, -0.956940),
+        vec2(0.382683, -0.923880),
+        vec2(0.471397, -0.881921),
+        vec2(0.555570, -0.831470),
+        vec2(0.634393, -0.773010),
+        vec2(0.707107, -0.707107),
+        vec2(0.773010, -0.634393),
+        vec2(0.831470, -0.555570),
+        vec2(0.881921, -0.471397),
+        vec2(0.923880, -0.382683),
+        vec2(0.956940, -0.290285),
+        vec2(0.980785, -0.195090),
+        vec2(0.995185, -0.098017),
+        vec2(1.000000, -0.000000),
+    ];
+
+    pub const CIRCLE_128: [Vec2; 129] = [
+        vec2(1.000000, 0.000000),
+        vec2(0.998795, 0.049068),
+        vec2(0.995185, 0.098017),
+        vec2(0.989177, 0.146730),
+        vec2(0.980785, 0.195090),
+        vec2(0.970031, 0.242980),
+        vec2(0.956940, 0.290285),
+        vec2(0.941544, 0.336890),
+        vec2(0.923880, 0.382683),
+        vec2(0.903989, 0.427555),
+        vec2(0.881921, 0.471397),
+        vec2(0.857729, 0.514103),
+        vec2(0.831470, 0.555570),
+        vec2(0.803208, 0.595699),
+        vec2(0.773010, 0.634393),
+        vec2(0.740951, 0.671559),
+        vec2(0.707107, 0.707107),
+        vec2(0.671559, 0.740951),
+        vec2(0.634393, 0.773010),
+        vec2(0.595699, 0.803208),
+        vec2(0.555570, 0.831470),
+        vec2(0.514103, 0.857729),
+        vec2(0.471397, 0.881921),
+        vec2(0.427555, 0.903989),
+        vec2(0.382683, 0.923880),
+        vec2(0.336890, 0.941544),
+        vec2(0.290285, 0.956940),
+        vec2(0.242980, 0.970031),
+        vec2(0.195090, 0.980785),
+        vec2(0.146730, 0.989177),
+        vec2(0.098017, 0.995185),
+        vec2(0.049068, 0.998795),
+        vec2(0.000000, 1.000000),
+        vec2(-0.049068, 0.998795),
+        vec2(-0.098017, 0.995185),
+        vec2(-0.146730, 0.989177),
+        vec2(-0.195090, 0.980785),
+        vec2(-0.242980, 0.970031),
+        vec2(-0.290285, 0.956940),
+        vec2(-0.336890, 0.941544),
+        vec2(-0.382683, 0.923880),
+        vec2(-0.427555, 0.903989),
+        vec2(-0.471397, 0.881921),
+        vec2(-0.514103, 0.857729),
+        vec2(-0.555570, 0.831470),
+        vec2(-0.595699, 0.803208),
+        vec2(-0.634393, 0.773010),
+        vec2(-0.671559, 0.740951),
+        vec2(-0.707107, 0.707107),
+        vec2(-0.740951, 0.671559),
+        vec2(-0.773010, 0.634393),
+        vec2(-0.803208, 0.595699),
+        vec2(-0.831470, 0.555570),
+        vec2(-0.857729, 0.514103),
+        vec2(-0.881921, 0.471397),
+        vec2(-0.903989, 0.427555),
+        vec2(-0.923880, 0.382683),
+        vec2(-0.941544, 0.336890),
+        vec2(-0.956940, 0.290285),
+        vec2(-0.970031, 0.242980),
+        vec2(-0.980785, 0.195090),
+        vec2(-0.989177, 0.146730),
+        vec2(-0.995185, 0.098017),
+        vec2(-0.998795, 0.049068),
+        vec2(-1.000000, 0.000000),
+        vec2(-0.998795, -0.049068),
+        vec2(-0.995185, -0.098017),
+        vec2(-0.989177, -0.146730),
+        vec2(-0.980785, -0.195090),
+        vec2(-0.970031, -0.242980),
+        vec2(-0.956940, -0.290285),
+        vec2(-0.941544, -0.336890),
+        vec2(-0.923880, -0.382683),
+        vec2(-0.903989, -0.427555),
+        vec2(-0.881921, -0.471397),
+        vec2(-0.857729, -0.514103),
+        vec2(-0.831470, -0.555570),
+        vec2(-0.803208, -0.595699),
+        vec2(-0.773010, -0.634393),
+        vec2(-0.740951, -0.671559),
+        vec2(-0.707107, -0.707107),
+        vec2(-0.671559, -0.740951),
+        vec2(-0.634393, -0.773010),
+        vec2(-0.595699, -0.803208),
+        vec2(-0.555570, -0.831470),
+        vec2(-0.514103, -0.857729),
+        vec2(-0.471397, -0.881921),
+        vec2(-0.427555, -0.903989),
+        vec2(-0.382683, -0.923880),
+        vec2(-0.336890, -0.941544),
+        vec2(-0.290285, -0.956940),
+        vec2(-0.242980, -0.970031),
+        vec2(-0.195090, -0.980785),
+        vec2(-0.146730, -0.989177),
+        vec2(-0.098017, -0.995185),
+        vec2(-0.049068, -0.998795),
+        vec2(-0.000000, -1.000000),
+        vec2(0.049068, -0.998795),
+        vec2(0.098017, -0.995185),
+        vec2(0.146730, -0.989177),
+        vec2(0.195090, -0.980785),
+        vec2(0.242980, -0.970031),
+        vec2(0.290285, -0.956940),
+        vec2(0.336890, -0.941544),
+        vec2(0.382683, -0.923880),
+        vec2(0.427555, -0.903989),
+        vec2(0.471397, -0.881921),
+        vec2(0.514103, -0.857729),
+        vec2(0.555570, -0.831470),
+        vec2(0.595699, -0.803208),
+        vec2(0.634393, -0.773010),
+        vec2(0.671559, -0.740951),
+        vec2(0.707107, -0.707107),
+        vec2(0.740951, -0.671559),
+        vec2(0.773010, -0.634393),
+        vec2(0.803208, -0.595699),
+        vec2(0.831470, -0.555570),
+        vec2(0.857729, -0.514103),
+        vec2(0.881921, -0.471397),
+        vec2(0.903989, -0.427555),
+        vec2(0.923880, -0.382683),
+        vec2(0.941544, -0.336890),
+        vec2(0.956940, -0.290285),
+        vec2(0.970031, -0.242980),
+        vec2(0.980785, -0.195090),
+        vec2(0.989177, -0.146730),
+        vec2(0.995185, -0.098017),
+        vec2(0.998795, -0.049068),
+        vec2(1.000000, -0.000000),
+    ];
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, Default)]
+struct PathPoint {
+    pos: Pos2,
+
+    /// For filled paths the normal is used for anti-aliasing (both strokes and filled areas).
+    ///
+    /// For strokes the normal is also used for giving thickness to the path
+    /// (i.e. in what direction to expand).
+    ///
+    /// The normal could be estimated by differences between successive points,
+    /// but that would be less accurate (and in some cases slower).
+    ///
+    /// Normals are normally unit-length.
+    normal: Vec2,
+}
+
+/// A connected line (without thickness or gaps) which can be tessellated
+/// to either to a stroke (with thickness) or a filled convex area.
+/// Used as a scratch-pad during tessellation.
+#[derive(Clone, Debug, Default)]
+pub struct Path(Vec<PathPoint>);
+
+impl Path {
+    #[inline(always)]
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    #[inline(always)]
+    pub fn reserve(&mut self, additional: usize) {
+        self.0.reserve(additional);
+    }
+
+    #[inline(always)]
+    pub fn add_point(&mut self, pos: Pos2, normal: Vec2) {
+        self.0.push(PathPoint { pos, normal });
+    }
+
+    pub fn add_circle(&mut self, center: Pos2, radius: f32) {
+        use precomputed_vertices::*;
+
+        // These cutoffs are based on a high-dpi display. TODO(emilk): use pixels_per_point here?
+        // same cutoffs as in add_circle_quadrant
+
+        if radius <= 2.0 {
+            self.0.extend(CIRCLE_8.iter().map(|&n| PathPoint {
+                pos: center + radius * n,
+                normal: n,
+            }));
+        } else if radius <= 5.0 {
+            self.0.extend(CIRCLE_16.iter().map(|&n| PathPoint {
+                pos: center + radius * n,
+                normal: n,
+            }));
+        } else if radius < 18.0 {
+            self.0.extend(CIRCLE_32.iter().map(|&n| PathPoint {
+                pos: center + radius * n,
+                normal: n,
+            }));
+        } else if radius < 50.0 {
+            self.0.extend(CIRCLE_64.iter().map(|&n| PathPoint {
+                pos: center + radius * n,
+                normal: n,
+            }));
+        } else {
+            self.0.extend(CIRCLE_128.iter().map(|&n| PathPoint {
+                pos: center + radius * n,
+                normal: n,
+            }));
+        }
+    }
+
+    pub fn add_line_segment(&mut self, points: [Pos2; 2]) {
+        self.reserve(2);
+        let normal = (points[1] - points[0]).normalized().rot90();
+        self.add_point(points[0], normal);
+        self.add_point(points[1], normal);
+    }
+
+    pub fn add_open_points(&mut self, points: &[Pos2]) {
+        let n = points.len();
+        assert!(n >= 2);
+
+        if n == 2 {
+            // Common case optimization:
+            self.add_line_segment([points[0], points[1]]);
+        } else {
+            self.reserve(n);
+            self.add_point(points[0], (points[1] - points[0]).normalized().rot90());
+            let mut n0 = (points[1] - points[0]).normalized().rot90();
+            for i in 1..n - 1 {
+                let mut n1 = (points[i + 1] - points[i]).normalized().rot90();
+
+                // Handle duplicated points (but not triplicated…):
+                if n0 == Vec2::ZERO {
+                    n0 = n1;
+                } else if n1 == Vec2::ZERO {
+                    n1 = n0;
+                }
+
+                let normal = (n0 + n1) / 2.0;
+                let length_sq = normal.length_sq();
+                let right_angle_length_sq = 0.5;
+                let sharper_than_a_right_angle = length_sq < right_angle_length_sq;
+                if sharper_than_a_right_angle {
+                    // cut off the sharp corner
+                    let center_normal = normal.normalized();
+                    let n0c = (n0 + center_normal) / 2.0;
+                    let n1c = (n1 + center_normal) / 2.0;
+                    self.add_point(points[i], n0c / n0c.length_sq());
+                    self.add_point(points[i], n1c / n1c.length_sq());
+                } else {
+                    // miter join
+                    self.add_point(points[i], normal / length_sq);
+                }
+
+                n0 = n1;
+            }
+            self.add_point(
+                points[n - 1],
+                (points[n - 1] - points[n - 2]).normalized().rot90(),
+            );
+        }
+    }
+
+    pub fn add_line_loop(&mut self, points: &[Pos2]) {
+        let n = points.len();
+        assert!(n >= 2);
+        self.reserve(n);
+
+        let mut n0 = (points[0] - points[n - 1]).normalized().rot90();
+
+        for i in 0..n {
+            let next_i = if i + 1 == n { 0 } else { i + 1 };
+            let mut n1 = (points[next_i] - points[i]).normalized().rot90();
+
+            // Handle duplicated points (but not triplicated…):
+            if n0 == Vec2::ZERO {
+                n0 = n1;
+            } else if n1 == Vec2::ZERO {
+                n1 = n0;
+            }
+
+            let normal = (n0 + n1) / 2.0;
+            let length_sq = normal.length_sq();
+
+            // We can't just cut off corners for filled shapes like this,
+            // because the feather will both expand and contract the corner along the provided normals
+            // to make sure it doesn't grow, and the shrinking will make the inner points cross each other.
+            //
+            // A better approach is to shrink the vertices in by half the feather-width here
+            // and then only expand during feathering.
+            //
+            // See https://github.com/emilk/egui/issues/1226
+            const CUT_OFF_SHARP_CORNERS: bool = false;
+
+            let right_angle_length_sq = 0.5;
+            let sharper_than_a_right_angle = length_sq < right_angle_length_sq;
+            if CUT_OFF_SHARP_CORNERS && sharper_than_a_right_angle {
+                // cut off the sharp corner
+                let center_normal = normal.normalized();
+                let n0c = (n0 + center_normal) / 2.0;
+                let n1c = (n1 + center_normal) / 2.0;
+                self.add_point(points[i], n0c / n0c.length_sq());
+                self.add_point(points[i], n1c / n1c.length_sq());
+            } else {
+                // miter join
+                self.add_point(points[i], normal / length_sq);
+            }
+
+            n0 = n1;
+        }
+    }
+
+    /// Open-ended.
+    pub fn stroke_open(&self, feathering: f32, stroke: Stroke, out: &mut Mesh) {
+        stroke_path(feathering, &self.0, PathType::Open, stroke, out);
+    }
+
+    /// A closed path (returning to the first point).
+    pub fn stroke_closed(&self, feathering: f32, stroke: Stroke, out: &mut Mesh) {
+        stroke_path(feathering, &self.0, PathType::Closed, stroke, out);
+    }
+
+    pub fn stroke(&self, feathering: f32, path_type: PathType, stroke: Stroke, out: &mut Mesh) {
+        stroke_path(feathering, &self.0, path_type, stroke, out);
+    }
+
+    /// The path is taken to be closed (i.e. returning to the start again).
+    ///
+    /// Calling this may reverse the vertices in the path if they are wrong winding order.
+    ///
+    /// The preferred winding order is clockwise.
+    pub fn fill(&mut self, feathering: f32, color: Color32, out: &mut Mesh) {
+        fill_closed_path(feathering, &mut self.0, color, out);
+    }
+}
+
+pub mod path {
+    //! Helpers for constructing paths
+    use crate::shape::Rounding;
+    use emath::*;
+
+    /// overwrites existing points
+    pub fn rounded_rectangle(path: &mut Vec<Pos2>, rect: Rect, rounding: Rounding) {
+        path.clear();
+
+        let min = rect.min;
+        let max = rect.max;
+
+        let r = clamp_radius(rounding, rect);
+
+        if r == Rounding::none() {
+            let min = rect.min;
+            let max = rect.max;
+            path.reserve(4);
+            path.push(pos2(min.x, min.y)); // left top
+            path.push(pos2(max.x, min.y)); // right top
+            path.push(pos2(max.x, max.y)); // right bottom
+            path.push(pos2(min.x, max.y)); // left bottom
+        } else {
+            add_circle_quadrant(path, pos2(max.x - r.se, max.y - r.se), r.se, 0.0);
+            add_circle_quadrant(path, pos2(min.x + r.sw, max.y - r.sw), r.sw, 1.0);
+            add_circle_quadrant(path, pos2(min.x + r.nw, min.y + r.nw), r.nw, 2.0);
+            add_circle_quadrant(path, pos2(max.x - r.ne, min.y + r.ne), r.ne, 3.0);
+        }
+    }
+
+    /// Add one quadrant of a circle
+    ///
+    /// * quadrant 0: right bottom
+    /// * quadrant 1: left bottom
+    /// * quadrant 2: left top
+    /// * quadrant 3: right top
+    //
+    // Derivation:
+    //
+    // * angle 0 * TAU / 4 = right
+    //   - quadrant 0: right bottom
+    // * angle 1 * TAU / 4 = bottom
+    //   - quadrant 1: left bottom
+    // * angle 2 * TAU / 4 = left
+    //   - quadrant 2: left top
+    // * angle 3 * TAU / 4 = top
+    //   - quadrant 3: right top
+    // * angle 4 * TAU / 4 = right
+    pub fn add_circle_quadrant(path: &mut Vec<Pos2>, center: Pos2, radius: f32, quadrant: f32) {
+        use super::precomputed_vertices::*;
+
+        // These cutoffs are based on a high-dpi display. TODO(emilk): use pixels_per_point here?
+        // same cutoffs as in add_circle
+
+        if radius <= 0.0 {
+            path.push(center);
+        } else if radius <= 2.0 {
+            let offset = quadrant as usize * 2;
+            let quadrant_vertices = &CIRCLE_8[offset..=offset + 2];
+            path.extend(quadrant_vertices.iter().map(|&n| center + radius * n));
+        } else if radius <= 5.0 {
+            let offset = quadrant as usize * 4;
+            let quadrant_vertices = &CIRCLE_16[offset..=offset + 4];
+            path.extend(quadrant_vertices.iter().map(|&n| center + radius * n));
+        } else if radius < 18.0 {
+            let offset = quadrant as usize * 8;
+            let quadrant_vertices = &CIRCLE_32[offset..=offset + 8];
+            path.extend(quadrant_vertices.iter().map(|&n| center + radius * n));
+        } else if radius < 50.0 {
+            let offset = quadrant as usize * 16;
+            let quadrant_vertices = &CIRCLE_64[offset..=offset + 16];
+            path.extend(quadrant_vertices.iter().map(|&n| center + radius * n));
+        } else {
+            let offset = quadrant as usize * 32;
+            let quadrant_vertices = &CIRCLE_128[offset..=offset + 32];
+            path.extend(quadrant_vertices.iter().map(|&n| center + radius * n));
+        }
+    }
+
+    // Ensures the radius of each corner is within a valid range
+    fn clamp_radius(rounding: Rounding, rect: Rect) -> Rounding {
+        let half_width = rect.width() * 0.5;
+        let half_height = rect.height() * 0.5;
+        let max_cr = half_width.min(half_height);
+        rounding.at_most(max_cr).at_least(0.0)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum PathType {
+    Open,
+    Closed,
+}
+
+/// Tessellation quality options
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct TessellationOptions {
+    /// Use "feathering" to smooth out the edges of shapes as a form of anti-aliasing.
+    ///
+    /// Feathering works by making each edge into a thin gradient into transparency.
+    /// The size of this edge is controlled by [`Self::feathering_size_in_pixels`].
+    ///
+    /// This makes shapes appear smoother, but requires more triangles and is therefore slower.
+    ///
+    /// This setting does not affect text.
+    ///
+    /// Default: `true`.
+    pub feathering: bool,
+
+    /// The size of the the feathering, in physical pixels.
+    ///
+    /// The default, and suggested, value for this is `1.0`.
+    /// If you use a larger value, edges will appear blurry.
+    pub feathering_size_in_pixels: f32,
+
+    /// If `true` (default) cull certain primitives before tessellating them.
+    /// This likely makes
+    pub coarse_tessellation_culling: bool,
+
+    /// If `true`, small filled circled will be optimized by using pre-rasterized circled
+    /// from the font atlas.
+    pub prerasterized_discs: bool,
+
+    /// If `true` (default) align text to mesh grid.
+    /// This makes the text sharper on most platforms.
+    pub round_text_to_pixels: bool,
+
+    /// Output the clip rectangles to be painted.
+    pub debug_paint_clip_rects: bool,
+
+    /// Output the text-containing rectangles.
+    pub debug_paint_text_rects: bool,
+
+    /// If true, no clipping will be done.
+    pub debug_ignore_clip_rects: bool,
+
+    /// The maximum distance between the original curve and the flattened curve.
+    pub bezier_tolerance: f32,
+
+    /// The default value will be 1.0e-5, it will be used during float compare.
+    pub epsilon: f32,
+}
+
+impl Default for TessellationOptions {
+    fn default() -> Self {
+        Self {
+            feathering: true,
+            feathering_size_in_pixels: 1.0,
+            coarse_tessellation_culling: true,
+            prerasterized_discs: true,
+            round_text_to_pixels: true,
+            debug_paint_text_rects: false,
+            debug_paint_clip_rects: false,
+            debug_ignore_clip_rects: false,
+            bezier_tolerance: 0.1,
+            epsilon: 1.0e-5,
+        }
+    }
+}
+
+fn cw_signed_area(path: &[PathPoint]) -> f64 {
+    if let Some(last) = path.last() {
+        let mut previous = last.pos;
+        let mut area = 0.0;
+        for p in path {
+            area += (previous.x * p.pos.y - p.pos.x * previous.y) as f64;
+            previous = p.pos;
+        }
+        area
+    } else {
+        0.0
+    }
+}
+
+/// Tessellate the given convex area into a polygon.
+///
+/// Calling this may reverse the vertices in the path if they are wrong winding order.
+///
+/// The preferred winding order is clockwise.
+fn fill_closed_path(feathering: f32, path: &mut [PathPoint], color: Color32, out: &mut Mesh) {
+    if color == Color32::TRANSPARENT {
+        return;
+    }
+
+    let n = path.len() as u32;
+    if feathering > 0.0 {
+        if cw_signed_area(path) < 0.0 {
+            // Wrong winding order - fix:
+            path.reverse();
+            for point in path.iter_mut() {
+                point.normal = -point.normal;
+            }
+        }
+
+        out.reserve_triangles(3 * n as usize);
+        out.reserve_vertices(2 * n as usize);
+        let color_outer = Color32::TRANSPARENT;
+        let idx_inner = out.vertices.len() as u32;
+        let idx_outer = idx_inner + 1;
+
+        // The fill:
+        for i in 2..n {
+            out.add_triangle(idx_inner + 2 * (i - 1), idx_inner, idx_inner + 2 * i);
+        }
+
+        // The feathering:
+        let mut i0 = n - 1;
+        for i1 in 0..n {
+            let p1 = &path[i1 as usize];
+            let dm = 0.5 * feathering * p1.normal;
+            out.colored_vertex(p1.pos - dm, color);
+            out.colored_vertex(p1.pos + dm, color_outer);
+            out.add_triangle(idx_inner + i1 * 2, idx_inner + i0 * 2, idx_outer + 2 * i0);
+            out.add_triangle(idx_outer + i0 * 2, idx_outer + i1 * 2, idx_inner + 2 * i1);
+            i0 = i1;
+        }
+    } else {
+        out.reserve_triangles(n as usize);
+        let idx = out.vertices.len() as u32;
+        out.vertices.extend(path.iter().map(|p| Vertex {
+            pos: p.pos,
+            uv: WHITE_UV,
+            color,
+        }));
+        for i in 2..n {
+            out.add_triangle(idx, idx + i - 1, idx + i);
+        }
+    }
+}
+
+/// Tessellate the given path as a stroke with thickness.
+fn stroke_path(
+    feathering: f32,
+    path: &[PathPoint],
+    path_type: PathType,
+    stroke: Stroke,
+    out: &mut Mesh,
+) {
+    let n = path.len() as u32;
+
+    if stroke.width <= 0.0 || stroke.color == Color32::TRANSPARENT || n < 2 {
+        return;
+    }
+
+    let idx = out.vertices.len() as u32;
+
+    if feathering > 0.0 {
+        let color_inner = stroke.color;
+        let color_outer = Color32::TRANSPARENT;
+
+        let thin_line = stroke.width <= feathering;
+        if thin_line {
+            /*
+            We paint the line using three edges: outer, inner, outer.
+
+            .       o   i   o      outer, inner, outer
+            .       |---|          feathering (pixel width)
+            */
+
+            // Fade out as it gets thinner:
+            let color_inner = mul_color(color_inner, stroke.width / feathering);
+            if color_inner == Color32::TRANSPARENT {
+                return;
+            }
+
+            out.reserve_triangles(4 * n as usize);
+            out.reserve_vertices(3 * n as usize);
+
+            let mut i0 = n - 1;
+            for i1 in 0..n {
+                let connect_with_previous = path_type == PathType::Closed || i1 > 0;
+                let p1 = &path[i1 as usize];
+                let p = p1.pos;
+                let n = p1.normal;
+                out.colored_vertex(p + n * feathering, color_outer);
+                out.colored_vertex(p, color_inner);
+                out.colored_vertex(p - n * feathering, color_outer);
+
+                if connect_with_previous {
+                    out.add_triangle(idx + 3 * i0 + 0, idx + 3 * i0 + 1, idx + 3 * i1 + 0);
+                    out.add_triangle(idx + 3 * i0 + 1, idx + 3 * i1 + 0, idx + 3 * i1 + 1);
+
+                    out.add_triangle(idx + 3 * i0 + 1, idx + 3 * i0 + 2, idx + 3 * i1 + 1);
+                    out.add_triangle(idx + 3 * i0 + 2, idx + 3 * i1 + 1, idx + 3 * i1 + 2);
+                }
+                i0 = i1;
+            }
+        } else {
+            // thick anti-aliased line
+
+            /*
+            We paint the line using four edges: outer, inner, inner, outer
+
+            .       o   i     p    i   o   outer, inner, point, inner, outer
+            .       |---|                  feathering (pixel width)
+            .         |--------------|     width
+            .       |---------|            outer_rad
+            .           |-----|            inner_rad
+            */
+
+            let inner_rad = 0.5 * (stroke.width - feathering);
+            let outer_rad = 0.5 * (stroke.width + feathering);
+
+            match path_type {
+                PathType::Closed => {
+                    out.reserve_triangles(6 * n as usize);
+                    out.reserve_vertices(4 * n as usize);
+
+                    let mut i0 = n - 1;
+                    for i1 in 0..n {
+                        let p1 = &path[i1 as usize];
+                        let p = p1.pos;
+                        let n = p1.normal;
+                        out.colored_vertex(p + n * outer_rad, color_outer);
+                        out.colored_vertex(p + n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * outer_rad, color_outer);
+
+                        out.add_triangle(idx + 4 * i0 + 0, idx + 4 * i0 + 1, idx + 4 * i1 + 0);
+                        out.add_triangle(idx + 4 * i0 + 1, idx + 4 * i1 + 0, idx + 4 * i1 + 1);
+
+                        out.add_triangle(idx + 4 * i0 + 1, idx + 4 * i0 + 2, idx + 4 * i1 + 1);
+                        out.add_triangle(idx + 4 * i0 + 2, idx + 4 * i1 + 1, idx + 4 * i1 + 2);
+
+                        out.add_triangle(idx + 4 * i0 + 2, idx + 4 * i0 + 3, idx + 4 * i1 + 2);
+                        out.add_triangle(idx + 4 * i0 + 3, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
+
+                        i0 = i1;
+                    }
+                }
+                PathType::Open => {
+                    // Anti-alias the ends by extruding the outer edge and adding
+                    // two more triangles to each end:
+
+                    //   | aa |       | aa |
+                    //    _________________   ___
+                    //   | \    added    / |  feathering
+                    //   |   \ ___p___ /   |  ___
+                    //   |    |       |    |
+                    //   |    |  opa  |    |
+                    //   |    |  que  |    |
+                    //   |    |       |    |
+
+                    // (in the future it would be great with an option to add a circular end instead)
+
+                    out.reserve_triangles(6 * n as usize + 4);
+                    out.reserve_vertices(4 * n as usize);
+
+                    {
+                        let end = &path[0];
+                        let p = end.pos;
+                        let n = end.normal;
+                        let back_extrude = n.rot90() * feathering;
+                        out.colored_vertex(p + n * outer_rad + back_extrude, color_outer);
+                        out.colored_vertex(p + n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * outer_rad + back_extrude, color_outer);
+
+                        out.add_triangle(idx + 0, idx + 1, idx + 2);
+                        out.add_triangle(idx + 0, idx + 2, idx + 3);
+                    }
+
+                    let mut i0 = 0;
+                    for i1 in 1..n - 1 {
+                        let point = &path[i1 as usize];
+                        let p = point.pos;
+                        let n = point.normal;
+                        out.colored_vertex(p + n * outer_rad, color_outer);
+                        out.colored_vertex(p + n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * outer_rad, color_outer);
+
+                        out.add_triangle(idx + 4 * i0 + 0, idx + 4 * i0 + 1, idx + 4 * i1 + 0);
+                        out.add_triangle(idx + 4 * i0 + 1, idx + 4 * i1 + 0, idx + 4 * i1 + 1);
+
+                        out.add_triangle(idx + 4 * i0 + 1, idx + 4 * i0 + 2, idx + 4 * i1 + 1);
+                        out.add_triangle(idx + 4 * i0 + 2, idx + 4 * i1 + 1, idx + 4 * i1 + 2);
+
+                        out.add_triangle(idx + 4 * i0 + 2, idx + 4 * i0 + 3, idx + 4 * i1 + 2);
+                        out.add_triangle(idx + 4 * i0 + 3, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
+
+                        i0 = i1;
+                    }
+
+                    {
+                        let i1 = n - 1;
+                        let end = &path[i1 as usize];
+                        let p = end.pos;
+                        let n = end.normal;
+                        let back_extrude = -n.rot90() * feathering;
+                        out.colored_vertex(p + n * outer_rad + back_extrude, color_outer);
+                        out.colored_vertex(p + n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * inner_rad, color_inner);
+                        out.colored_vertex(p - n * outer_rad + back_extrude, color_outer);
+
+                        out.add_triangle(idx + 4 * i0 + 0, idx + 4 * i0 + 1, idx + 4 * i1 + 0);
+                        out.add_triangle(idx + 4 * i0 + 1, idx + 4 * i1 + 0, idx + 4 * i1 + 1);
+
+                        out.add_triangle(idx + 4 * i0 + 1, idx + 4 * i0 + 2, idx + 4 * i1 + 1);
+                        out.add_triangle(idx + 4 * i0 + 2, idx + 4 * i1 + 1, idx + 4 * i1 + 2);
+
+                        out.add_triangle(idx + 4 * i0 + 2, idx + 4 * i0 + 3, idx + 4 * i1 + 2);
+                        out.add_triangle(idx + 4 * i0 + 3, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
+
+                        // The extension:
+                        out.add_triangle(idx + 4 * i1 + 0, idx + 4 * i1 + 1, idx + 4 * i1 + 2);
+                        out.add_triangle(idx + 4 * i1 + 0, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
+                    }
+                }
+            }
+        }
+    } else {
+        // not anti-aliased:
+        out.reserve_triangles(2 * n as usize);
+        out.reserve_vertices(2 * n as usize);
+
+        let last_index = if path_type == PathType::Closed {
+            n
+        } else {
+            n - 1
+        };
+        for i in 0..last_index {
+            out.add_triangle(
+                idx + (2 * i + 0) % (2 * n),
+                idx + (2 * i + 1) % (2 * n),
+                idx + (2 * i + 2) % (2 * n),
+            );
+            out.add_triangle(
+                idx + (2 * i + 2) % (2 * n),
+                idx + (2 * i + 1) % (2 * n),
+                idx + (2 * i + 3) % (2 * n),
+            );
+        }
+
+        let thin_line = stroke.width <= feathering;
+        if thin_line {
+            // Fade out thin lines rather than making them thinner
+            let radius = feathering / 2.0;
+            let color = mul_color(stroke.color, stroke.width / feathering);
+            if color == Color32::TRANSPARENT {
+                return;
+            }
+            for p in path {
+                out.colored_vertex(p.pos + radius * p.normal, color);
+                out.colored_vertex(p.pos - radius * p.normal, color);
+            }
+        } else {
+            let radius = stroke.width / 2.0;
+            for p in path {
+                out.colored_vertex(p.pos + radius * p.normal, stroke.color);
+                out.colored_vertex(p.pos - radius * p.normal, stroke.color);
+            }
+        }
+    }
+}
+
+fn mul_color(color: Color32, factor: f32) -> Color32 {
+    // The fast gamma-space multiply also happens to be perceptually better.
+    // Win-win!
+    color.gamma_multiply(factor)
+}
+
+// ----------------------------------------------------------------------------
+
+/// Converts [`Shape`]s into triangles ([`Mesh`]).
+///
+/// For performance reasons it is smart to reuse the same [`Tessellator`].
+///
+/// Se also [`tessellate_shapes`], a convenient wrapper around [`Tessellator`].
+pub struct Tessellator {
+    pixels_per_point: f32,
+    options: TessellationOptions,
+    font_tex_size: [usize; 2],
+
+    /// See [`TextureAtlas::prepared_discs`].
+    prepared_discs: Vec<PreparedDisc>,
+
+    /// size of feathering in points. normally the size of a physical pixel. 0.0 if disabled
+    feathering: f32,
+
+    /// Only used for culling
+    clip_rect: Rect,
+
+    scratchpad_points: Vec<Pos2>,
+    scratchpad_path: Path,
+}
+
+impl Tessellator {
+    /// Create a new [`Tessellator`].
+    ///
+    /// * `font_tex_size`: size of the font texture. Required to normalize glyph uv rectangles when tessellating text.
+    /// * `prepared_discs`: What [`TextureAtlas::prepared_discs`] returns. Can safely be set to an empty vec.
+    pub fn new(
+        pixels_per_point: f32,
+        options: TessellationOptions,
+        font_tex_size: [usize; 2],
+        prepared_discs: Vec<PreparedDisc>,
+    ) -> Self {
+        let feathering = if options.feathering {
+            let pixel_size = 1.0 / pixels_per_point;
+            options.feathering_size_in_pixels * pixel_size
+        } else {
+            0.0
+        };
+        Self {
+            pixels_per_point,
+            options,
+            font_tex_size,
+            prepared_discs,
+            feathering,
+            clip_rect: Rect::EVERYTHING,
+            scratchpad_points: Default::default(),
+            scratchpad_path: Default::default(),
+        }
+    }
+
+    /// Set the [`Rect`] to use for culling.
+    pub fn set_clip_rect(&mut self, clip_rect: Rect) {
+        self.clip_rect = clip_rect;
+    }
+
+    #[inline(always)]
+    pub fn round_to_pixel(&self, point: f32) -> f32 {
+        if self.options.round_text_to_pixels {
+            (point * self.pixels_per_point).round() / self.pixels_per_point
+        } else {
+            point
+        }
+    }
+
+    /// Tessellate a clipped shape into a list of primitives.
+    pub fn tessellate_clipped_shape(
+        &mut self,
+        clipped_shape: ClippedShape,
+        out_primitives: &mut Vec<ClippedPrimitive>,
+    ) {
+        let ClippedShape(new_clip_rect, new_shape) = clipped_shape;
+
+        if !new_clip_rect.is_positive() {
+            return; // skip empty clip rectangles
+        }
+
+        if let Shape::Vec(shapes) = new_shape {
+            for shape in shapes {
+                self.tessellate_clipped_shape(ClippedShape(new_clip_rect, shape), out_primitives);
+            }
+            return;
+        }
+
+        if let Shape::Callback(callback) = new_shape {
+            out_primitives.push(ClippedPrimitive {
+                clip_rect: new_clip_rect,
+                primitive: Primitive::Callback(callback),
+            });
+            return;
+        }
+
+        let start_new_mesh = match out_primitives.last() {
+            None => true,
+            Some(output_clipped_primitive) => {
+                output_clipped_primitive.clip_rect != new_clip_rect
+                    || match &output_clipped_primitive.primitive {
+                        Primitive::Mesh(output_mesh) => {
+                            output_mesh.texture_id != new_shape.texture_id()
+                        }
+                        Primitive::Callback(_) => true,
+                    }
+            }
+        };
+
+        if start_new_mesh {
+            out_primitives.push(ClippedPrimitive {
+                clip_rect: new_clip_rect,
+                primitive: Primitive::Mesh(Mesh::default()),
+            });
+        }
+
+        let out = out_primitives.last_mut().unwrap();
+
+        if let Primitive::Mesh(out_mesh) = &mut out.primitive {
+            self.clip_rect = new_clip_rect;
+            self.tessellate_shape(new_shape, out_mesh);
+        } else {
+            unreachable!();
+        }
+    }
+
+    /// Tessellate a single [`Shape`] into a [`Mesh`].
+    ///
+    /// This call can panic the given shape is of [`Shape::Vec`] or [`Shape::Callback`].
+    /// For that, use [`Self::tessellate_clipped_shape`] instead.
+    /// * `shape`: the shape to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_shape(&mut self, shape: Shape, out: &mut Mesh) {
+        match shape {
+            Shape::Noop => {}
+            Shape::Vec(vec) => {
+                for shape in vec {
+                    self.tessellate_shape(shape, out);
+                }
+            }
+            Shape::Circle(circle) => {
+                self.tessellate_circle(circle, out);
+            }
+            Shape::Mesh(mesh) => {
+                if !mesh.is_valid() {
+                    crate::epaint_assert!(false, "Invalid Mesh in Shape::Mesh");
+                    return;
+                }
+
+                if self.options.coarse_tessellation_culling
+                    && !self.clip_rect.intersects(mesh.calc_bounds())
+                {
+                    return;
+                }
+                out.append(mesh);
+            }
+            Shape::LineSegment { points, stroke } => self.tessellate_line(points, stroke, out),
+            Shape::Path(path_shape) => {
+                self.tessellate_path(&path_shape, out);
+            }
+            Shape::Rect(rect_shape) => {
+                self.tessellate_rect(&rect_shape, out);
+            }
+            Shape::Text(text_shape) => {
+                if self.options.debug_paint_text_rects {
+                    let rect = text_shape.galley.rect.translate(text_shape.pos.to_vec2());
+                    self.tessellate_rect(
+                        &RectShape::stroke(rect.expand(0.5), 2.0, (0.5, Color32::GREEN)),
+                        out,
+                    );
+                }
+                self.tessellate_text(&text_shape, out);
+            }
+            Shape::QuadraticBezier(quadratic_shape) => {
+                self.tessellate_quadratic_bezier(quadratic_shape, out);
+            }
+            Shape::CubicBezier(cubic_shape) => self.tessellate_cubic_bezier(cubic_shape, out),
+            Shape::Callback(_) => {
+                panic!("Shape::Callback passed to Tessellator");
+            }
+        }
+    }
+
+    /// Tessellate a single [`CircleShape`] into a [`Mesh`].
+    ///
+    /// * `shape`: the circle to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_circle(&mut self, shape: CircleShape, out: &mut Mesh) {
+        let CircleShape {
+            center,
+            radius,
+            mut fill,
+            stroke,
+        } = shape;
+
+        if radius <= 0.0 {
+            return;
+        }
+
+        if self.options.coarse_tessellation_culling
+            && !self
+                .clip_rect
+                .expand(radius + stroke.width)
+                .contains(center)
+        {
+            return;
+        }
+
+        if self.options.prerasterized_discs && fill != Color32::TRANSPARENT {
+            let radius_px = radius * self.pixels_per_point;
+            // strike the right balance between some circles becoming too blurry, and some too sharp.
+            let cutoff_radius = radius_px * 2.0_f32.powf(0.25);
+
+            // Find the right disc radius for a crisp edge:
+            // TODO(emilk): perhaps we can do something faster than this linear search.
+            for disc in &self.prepared_discs {
+                if cutoff_radius <= disc.r {
+                    let side = radius_px * disc.w / (self.pixels_per_point * disc.r);
+                    let rect = Rect::from_center_size(center, Vec2::splat(side));
+                    out.add_rect_with_uv(rect, disc.uv, fill);
+
+                    if stroke.is_empty() {
+                        return; // we are done
+                    } else {
+                        // we still need to do the stroke
+                        fill = Color32::TRANSPARENT; // don't fill again below
+                        break;
+                    }
+                }
+            }
+        }
+
+        self.scratchpad_path.clear();
+        self.scratchpad_path.add_circle(center, radius);
+        self.scratchpad_path.fill(self.feathering, fill, out);
+        self.scratchpad_path
+            .stroke_closed(self.feathering, stroke, out);
+    }
+
+    /// Tessellate a single [`Mesh`] into a [`Mesh`].
+    ///
+    /// * `mesh`: the mesh to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_mesh(&mut self, mesh: &Mesh, out: &mut Mesh) {
+        if !mesh.is_valid() {
+            crate::epaint_assert!(false, "Invalid Mesh in Shape::Mesh");
+            return;
+        }
+
+        if self.options.coarse_tessellation_culling
+            && !self.clip_rect.intersects(mesh.calc_bounds())
+        {
+            return;
+        }
+
+        out.append_ref(mesh);
+    }
+
+    /// Tessellate a line segment between the two points with the given stroke into a [`Mesh`].
+    ///
+    /// * `shape`: the mesh to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_line(&mut self, points: [Pos2; 2], stroke: Stroke, out: &mut Mesh) {
+        if stroke.is_empty() {
+            return;
+        }
+
+        if self.options.coarse_tessellation_culling
+            && !self
+                .clip_rect
+                .intersects(Rect::from_two_pos(points[0], points[1]).expand(stroke.width))
+        {
+            return;
+        }
+
+        self.scratchpad_path.clear();
+        self.scratchpad_path.add_line_segment(points);
+        self.scratchpad_path
+            .stroke_open(self.feathering, stroke, out);
+    }
+
+    /// Tessellate a single [`PathShape`] into a [`Mesh`].
+    ///
+    /// * `path_shape`: the path to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_path(&mut self, path_shape: &PathShape, out: &mut Mesh) {
+        if path_shape.points.len() < 2 {
+            return;
+        }
+
+        if self.options.coarse_tessellation_culling
+            && !path_shape.visual_bounding_rect().intersects(self.clip_rect)
+        {
+            return;
+        }
+
+        let PathShape {
+            points,
+            closed,
+            fill,
+            stroke,
+        } = path_shape;
+
+        self.scratchpad_path.clear();
+        if *closed {
+            self.scratchpad_path.add_line_loop(points);
+        } else {
+            self.scratchpad_path.add_open_points(points);
+        }
+
+        if *fill != Color32::TRANSPARENT {
+            crate::epaint_assert!(
+                closed,
+                "You asked to fill a path that is not closed. That makes no sense."
+            );
+            self.scratchpad_path.fill(self.feathering, *fill, out);
+        }
+        let typ = if *closed {
+            PathType::Closed
+        } else {
+            PathType::Open
+        };
+        self.scratchpad_path
+            .stroke(self.feathering, typ, *stroke, out);
+    }
+
+    /// Tessellate a single [`Rect`] into a [`Mesh`].
+    ///
+    /// * `rect`: the rectangle to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_rect(&mut self, rect: &RectShape, out: &mut Mesh) {
+        let RectShape {
+            mut rect,
+            rounding,
+            fill,
+            stroke,
+        } = *rect;
+
+        if self.options.coarse_tessellation_culling
+            && !rect.expand(stroke.width).intersects(self.clip_rect)
+        {
+            return;
+        }
+        if rect.is_negative() {
+            return;
+        }
+
+        // It is common to (sometimes accidentally) create an infinitely sized rectangle.
+        // Make sure we can handle that:
+        rect.min = rect.min.at_least(pos2(-1e7, -1e7));
+        rect.max = rect.max.at_most(pos2(1e7, 1e7));
+
+        if rect.width() < self.feathering {
+            // Very thin - approximate by a vertical line-segment:
+            let line = [rect.center_top(), rect.center_bottom()];
+            if fill != Color32::TRANSPARENT {
+                self.tessellate_line(line, Stroke::new(rect.width(), fill), out);
+            }
+            if !stroke.is_empty() {
+                self.tessellate_line(line, stroke, out); // back…
+                self.tessellate_line(line, stroke, out); // …and forth
+            }
+        } else if rect.height() < self.feathering {
+            // Very thin - approximate by a horizontal line-segment:
+            let line = [rect.left_center(), rect.right_center()];
+            if fill != Color32::TRANSPARENT {
+                self.tessellate_line(line, Stroke::new(rect.height(), fill), out);
+            }
+            if !stroke.is_empty() {
+                self.tessellate_line(line, stroke, out); // back…
+                self.tessellate_line(line, stroke, out); // …and forth
+            }
+        } else {
+            let path = &mut self.scratchpad_path;
+            path.clear();
+            path::rounded_rectangle(&mut self.scratchpad_points, rect, rounding);
+            path.add_line_loop(&self.scratchpad_points);
+            path.fill(self.feathering, fill, out);
+            path.stroke_closed(self.feathering, stroke, out);
+        }
+    }
+
+    /// Tessellate a single [`TextShape`] into a [`Mesh`].
+    /// * `text_shape`: the text to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_text(&mut self, text_shape: &TextShape, out: &mut Mesh) {
+        let TextShape {
+            pos: galley_pos,
+            galley,
+            underline,
+            override_text_color,
+            angle,
+        } = text_shape;
+
+        if galley.is_empty() {
+            return;
+        }
+
+        if galley.pixels_per_point != self.pixels_per_point {
+            eprintln!("epaint: WARNING: pixels_per_point (dpi scale) have changed between text layout and tessellation. \
+                       You must recreate your text shapes if pixels_per_point changes.");
+        }
+
+        out.vertices.reserve(galley.num_vertices);
+        out.indices.reserve(galley.num_indices);
+
+        // The contents of the galley is already snapped to pixel coordinates,
+        // but we need to make sure the galley ends up on the start of a physical pixel:
+        let galley_pos = pos2(
+            self.round_to_pixel(galley_pos.x),
+            self.round_to_pixel(galley_pos.y),
+        );
+
+        let uv_normalizer = vec2(
+            1.0 / self.font_tex_size[0] as f32,
+            1.0 / self.font_tex_size[1] as f32,
+        );
+
+        let rotator = Rot2::from_angle(*angle);
+
+        for row in &galley.rows {
+            if row.visuals.mesh.is_empty() {
+                continue;
+            }
+
+            let mut row_rect = row.visuals.mesh_bounds;
+            if *angle != 0.0 {
+                row_rect = row_rect.rotate_bb(rotator);
+            }
+            row_rect = row_rect.translate(galley_pos.to_vec2());
+
+            if self.options.coarse_tessellation_culling && !self.clip_rect.intersects(row_rect) {
+                // culling individual lines of text is important, since a single `Shape::Text`
+                // can span hundreds of lines.
+                continue;
+            }
+
+            let index_offset = out.vertices.len() as u32;
+
+            out.indices.extend(
+                row.visuals
+                    .mesh
+                    .indices
+                    .iter()
+                    .map(|index| index + index_offset),
+            );
+
+            out.vertices.extend(
+                row.visuals
+                    .mesh
+                    .vertices
+                    .iter()
+                    .enumerate()
+                    .map(|(i, vertex)| {
+                        let Vertex { pos, uv, mut color } = *vertex;
+
+                        if let Some(override_text_color) = override_text_color {
+                            if row.visuals.glyph_vertex_range.contains(&i) {
+                                color = *override_text_color;
+                            }
+                        }
+
+                        let offset = if *angle == 0.0 {
+                            pos.to_vec2()
+                        } else {
+                            rotator * pos.to_vec2()
+                        };
+
+                        Vertex {
+                            pos: galley_pos + offset,
+                            uv: (uv.to_vec2() * uv_normalizer).to_pos2(),
+                            color,
+                        }
+                    }),
+            );
+
+            if *underline != Stroke::NONE {
+                self.scratchpad_path.clear();
+                self.scratchpad_path
+                    .add_line_segment([row_rect.left_bottom(), row_rect.right_bottom()]);
+                self.scratchpad_path
+                    .stroke_open(self.feathering, *underline, out);
+            }
+        }
+    }
+
+    /// Tessellate a single [`QuadraticBezierShape`] into a [`Mesh`].
+    ///
+    /// * `quadratic_shape`: the shape to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_quadratic_bezier(
+        &mut self,
+        quadratic_shape: QuadraticBezierShape,
+        out: &mut Mesh,
+    ) {
+        let options = &self.options;
+        let clip_rect = self.clip_rect;
+
+        if options.coarse_tessellation_culling
+            && !quadratic_shape.visual_bounding_rect().intersects(clip_rect)
+        {
+            return;
+        }
+
+        let points = quadratic_shape.flatten(Some(options.bezier_tolerance));
+
+        self.tessellate_bezier_complete(
+            &points,
+            quadratic_shape.fill,
+            quadratic_shape.closed,
+            quadratic_shape.stroke,
+            out,
+        );
+    }
+
+    /// Tessellate a single [`CubicBezierShape`] into a [`Mesh`].
+    ///
+    /// * `cubic_shape`: the shape to tessellate.
+    /// * `out`: triangles are appended to this.
+    pub fn tessellate_cubic_bezier(&mut self, cubic_shape: CubicBezierShape, out: &mut Mesh) {
+        let options = &self.options;
+        let clip_rect = self.clip_rect;
+        if options.coarse_tessellation_culling
+            && !cubic_shape.visual_bounding_rect().intersects(clip_rect)
+        {
+            return;
+        }
+
+        let points_vec =
+            cubic_shape.flatten_closed(Some(options.bezier_tolerance), Some(options.epsilon));
+
+        for points in points_vec {
+            self.tessellate_bezier_complete(
+                &points,
+                cubic_shape.fill,
+                cubic_shape.closed,
+                cubic_shape.stroke,
+                out,
+            );
+        }
+    }
+
+    fn tessellate_bezier_complete(
+        &mut self,
+        points: &[Pos2],
+        fill: Color32,
+        closed: bool,
+        stroke: Stroke,
+        out: &mut Mesh,
+    ) {
+        if points.len() < 2 {
+            return;
+        }
+
+        self.scratchpad_path.clear();
+        if closed {
+            self.scratchpad_path.add_line_loop(points);
+        } else {
+            self.scratchpad_path.add_open_points(points);
+        }
+        if fill != Color32::TRANSPARENT {
+            crate::epaint_assert!(
+                closed,
+                "You asked to fill a path that is not closed. That makes no sense."
+            );
+            self.scratchpad_path.fill(self.feathering, fill, out);
+        }
+        let typ = if closed {
+            PathType::Closed
+        } else {
+            PathType::Open
+        };
+        self.scratchpad_path
+            .stroke(self.feathering, typ, stroke, out);
+    }
+}
+
+/// Turns [`Shape`]:s into sets of triangles.
+///
+/// The given shapes will tessellated in the same order as they are given.
+/// They will be batched together by clip rectangle.
+///
+/// * `pixels_per_point`: number of physical pixels to each logical point
+/// * `options`: tessellation quality
+/// * `shapes`: what to tessellate
+/// * `font_tex_size`: size of the font texture. Required to normalize glyph uv rectangles when tessellating text.
+/// * `prepared_discs`: What [`TextureAtlas::prepared_discs`] returns. Can safely be set to an empty vec.
+///
+/// The implementation uses a [`Tessellator`].
+///
+/// ## Returns
+/// A list of clip rectangles with matching [`Mesh`].
+pub fn tessellate_shapes(
+    pixels_per_point: f32,
+    options: TessellationOptions,
+    font_tex_size: [usize; 2],
+    prepared_discs: Vec<PreparedDisc>,
+    shapes: Vec<ClippedShape>,
+) -> Vec<ClippedPrimitive> {
+    let mut tessellator =
+        Tessellator::new(pixels_per_point, options, font_tex_size, prepared_discs);
+
+    let mut clipped_primitives: Vec<ClippedPrimitive> = Vec::default();
+
+    for clipped_shape in shapes {
+        tessellator.tessellate_clipped_shape(clipped_shape, &mut clipped_primitives);
+    }
+
+    if options.debug_paint_clip_rects {
+        clipped_primitives = add_clip_rects(&mut tessellator, clipped_primitives);
+    }
+
+    if options.debug_ignore_clip_rects {
+        for clipped_primitive in &mut clipped_primitives {
+            clipped_primitive.clip_rect = Rect::EVERYTHING;
+        }
+    }
+
+    clipped_primitives.retain(|p| {
+        p.clip_rect.is_positive()
+            && match &p.primitive {
+                Primitive::Mesh(mesh) => !mesh.is_empty(),
+                Primitive::Callback(_) => true,
+            }
+    });
+
+    for clipped_primitive in &clipped_primitives {
+        if let Primitive::Mesh(mesh) = &clipped_primitive.primitive {
+            crate::epaint_assert!(mesh.is_valid(), "Tessellator generated invalid Mesh");
+        }
+    }
+
+    clipped_primitives
+}
+
+fn add_clip_rects(
+    tessellator: &mut Tessellator,
+    clipped_primitives: Vec<ClippedPrimitive>,
+) -> Vec<ClippedPrimitive> {
+    tessellator.clip_rect = Rect::EVERYTHING;
+    let stroke = Stroke::new(2.0, Color32::from_rgb(150, 255, 150));
+
+    clipped_primitives
+        .into_iter()
+        .flat_map(|clipped_primitive| {
+            let mut clip_rect_mesh = Mesh::default();
+            tessellator.tessellate_shape(
+                Shape::rect_stroke(clipped_primitive.clip_rect, 0.0, stroke),
+                &mut clip_rect_mesh,
+            );
+
+            [
+                clipped_primitive,
+                ClippedPrimitive {
+                    clip_rect: Rect::EVERYTHING, // whatever
+                    primitive: Primitive::Mesh(clip_rect_mesh),
+                },
+            ]
+        })
+        .collect()
+}
+
+#[test]
+fn test_tessellator() {
+    use crate::*;
+
+    let mut shapes = Vec::with_capacity(2);
+
+    let rect = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
+    let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
+
+    let mut mesh = Mesh::with_texture(TextureId::Managed(1));
+    mesh.add_rect_with_uv(rect, uv, Color32::WHITE);
+    shapes.push(Shape::mesh(mesh));
+
+    let mut mesh = Mesh::with_texture(TextureId::Managed(2));
+    mesh.add_rect_with_uv(rect, uv, Color32::WHITE);
+    shapes.push(Shape::mesh(mesh));
+
+    let shape = Shape::Vec(shapes);
+    let clipped_shapes = vec![ClippedShape(rect, shape)];
+
+    let font_tex_size = [1024, 1024]; // unused
+    let prepared_discs = vec![]; // unused
+
+    let primitives = tessellate_shapes(
+        1.0,
+        Default::default(),
+        font_tex_size,
+        prepared_discs,
+        clipped_shapes,
+    );
+    assert_eq!(primitives.len(), 2);
+}
diff --git a/egui/crates/epaint/src/text/cursor.rs b/egui/crates/epaint/src/text/cursor.rs
new file mode 100644
index 0000000..2dac510
--- /dev/null
+++ b/egui/crates/epaint/src/text/cursor.rs
@@ -0,0 +1,122 @@
+//! Different types of text cursors, i.e. ways to point into a [`super::Galley`].
+
+/// Character cursor
+#[derive(Clone, Copy, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct CCursor {
+    /// Character offset (NOT byte offset!).
+    pub index: usize,
+
+    /// If this cursors sits right at the border of a wrapped row break (NOT paragraph break)
+    /// do we prefer the next row?
+    /// This is *almost* always what you want, *except* for when
+    /// explicitly clicking the end of a row or pressing the end key.
+    pub prefer_next_row: bool,
+}
+
+impl CCursor {
+    pub fn new(index: usize) -> Self {
+        Self {
+            index,
+            prefer_next_row: false,
+        }
+    }
+}
+
+/// Two `CCursor`s are considered equal if they refer to the same character boundary,
+/// even if one prefers the start of the next row.
+impl PartialEq for CCursor {
+    fn eq(&self, other: &CCursor) -> bool {
+        self.index == other.index
+    }
+}
+
+impl std::ops::Add<usize> for CCursor {
+    type Output = CCursor;
+
+    fn add(self, rhs: usize) -> Self::Output {
+        CCursor {
+            index: self.index.saturating_add(rhs),
+            prefer_next_row: self.prefer_next_row,
+        }
+    }
+}
+
+impl std::ops::Sub<usize> for CCursor {
+    type Output = CCursor;
+
+    fn sub(self, rhs: usize) -> Self::Output {
+        CCursor {
+            index: self.index.saturating_sub(rhs),
+            prefer_next_row: self.prefer_next_row,
+        }
+    }
+}
+
+impl std::ops::AddAssign<usize> for CCursor {
+    fn add_assign(&mut self, rhs: usize) {
+        self.index = self.index.saturating_add(rhs);
+    }
+}
+
+impl std::ops::SubAssign<usize> for CCursor {
+    fn sub_assign(&mut self, rhs: usize) {
+        self.index = self.index.saturating_sub(rhs);
+    }
+}
+
+/// Row Cursor
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct RCursor {
+    /// 0 is first row, and so on.
+    /// Note that a single paragraph can span multiple rows.
+    /// (a paragraph is text separated by `\n`).
+    pub row: usize,
+
+    /// Character based (NOT bytes).
+    /// It is fine if this points to something beyond the end of the current row.
+    /// When moving up/down it may again be within the next row.
+    pub column: usize,
+}
+
+/// Paragraph Cursor
+#[derive(Clone, Copy, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PCursor {
+    /// 0 is first paragraph, and so on.
+    /// Note that a single paragraph can span multiple rows.
+    /// (a paragraph is text separated by `\n`).
+    pub paragraph: usize,
+
+    /// Character based (NOT bytes).
+    /// It is fine if this points to something beyond the end of the current paragraph.
+    /// When moving up/down it may again be within the next paragraph.
+    pub offset: usize,
+
+    /// If this cursors sits right at the border of a wrapped row break (NOT paragraph break)
+    /// do we prefer the next row?
+    /// This is *almost* always what you want, *except* for when
+    /// explicitly clicking the end of a row or pressing the end key.
+    pub prefer_next_row: bool,
+}
+
+/// Two `PCursor`s are considered equal if they refer to the same character boundary,
+/// even if one prefers the start of the next row.
+impl PartialEq for PCursor {
+    fn eq(&self, other: &PCursor) -> bool {
+        self.paragraph == other.paragraph && self.offset == other.offset
+    }
+}
+
+/// All different types of cursors together.
+/// They all point to the same place, but in their own different ways.
+/// pcursor/rcursor can also point to after the end of the paragraph/row.
+/// Does not implement `PartialEq` because you must think which cursor should be equivalent.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Cursor {
+    pub ccursor: CCursor,
+    pub rcursor: RCursor,
+    pub pcursor: PCursor,
+}
diff --git a/egui/crates/epaint/src/text/font.rs b/egui/crates/epaint/src/text/font.rs
new file mode 100644
index 0000000..939cdf9
--- /dev/null
+++ b/egui/crates/epaint/src/text/font.rs
@@ -0,0 +1,512 @@
+use crate::{
+    mutex::{Mutex, RwLock},
+    text::FontTweak,
+    TextureAtlas,
+};
+use emath::{vec2, Vec2};
+use std::collections::BTreeSet;
+use std::sync::Arc;
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct UvRect {
+    /// X/Y offset for nice rendering (unit: points).
+    pub offset: Vec2,
+
+    /// Screen size (in points) of this glyph.
+    /// Note that the height is different from the font height.
+    pub size: Vec2,
+
+    /// Top left corner UV in texture.
+    pub min: [u16; 2],
+
+    /// Bottom right corner (exclusive).
+    pub max: [u16; 2],
+}
+
+impl UvRect {
+    pub fn is_nothing(&self) -> bool {
+        self.min == self.max
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct GlyphInfo {
+    /// Used for pair-kerning.
+    ///
+    /// Doesn't need to be unique.
+    /// Use `ab_glyph::GlyphId(0)` if you just want to have an id, and don't care.
+    pub(crate) id: ab_glyph::GlyphId,
+
+    /// Unit: points.
+    pub advance_width: f32,
+
+    /// `ascent` value from the font metrics.
+    /// this is the distance from the top to the baseline.
+    ///
+    /// Unit: points.
+    pub ascent: f32,
+
+    /// row height computed from the font metrics.
+    ///
+    /// Unit: points.
+    pub row_height: f32,
+
+    /// Texture coordinates.
+    pub uv_rect: UvRect,
+}
+
+impl Default for GlyphInfo {
+    /// Basically a zero-width space.
+    fn default() -> Self {
+        Self {
+            id: ab_glyph::GlyphId(0),
+            advance_width: 0.0,
+            ascent: 0.0,
+            row_height: 0.0,
+            uv_rect: Default::default(),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A specific font with a size.
+/// The interface uses points as the unit for everything.
+pub struct FontImpl {
+    name: String,
+    ab_glyph_font: ab_glyph::FontArc,
+    /// Maximum character height
+    scale_in_pixels: u32,
+    height_in_points: f32,
+    // move each character by this much (hack)
+    y_offset: f32,
+    ascent: f32,
+    pixels_per_point: f32,
+    glyph_info_cache: RwLock<ahash::HashMap<char, GlyphInfo>>, // TODO(emilk): standard Mutex
+    atlas: Arc<Mutex<TextureAtlas>>,
+}
+
+impl FontImpl {
+    pub fn new(
+        atlas: Arc<Mutex<TextureAtlas>>,
+        pixels_per_point: f32,
+        name: String,
+        ab_glyph_font: ab_glyph::FontArc,
+        scale_in_pixels: f32,
+        tweak: FontTweak,
+    ) -> FontImpl {
+        assert!(scale_in_pixels > 0.0);
+        assert!(pixels_per_point > 0.0);
+
+        use ab_glyph::*;
+        let scaled = ab_glyph_font.as_scaled(scale_in_pixels);
+        let ascent = scaled.ascent() / pixels_per_point;
+        let descent = scaled.descent() / pixels_per_point;
+        let line_gap = scaled.line_gap() / pixels_per_point;
+
+        // Tweak the scale as the user desired
+        let scale_in_pixels = scale_in_pixels * tweak.scale;
+
+        let baseline_offset = {
+            let scale_in_points = scale_in_pixels / pixels_per_point;
+            scale_in_points * tweak.baseline_offset_factor
+        };
+
+        let y_offset_points = {
+            let scale_in_points = scale_in_pixels / pixels_per_point;
+            scale_in_points * tweak.y_offset_factor
+        } + tweak.y_offset;
+
+        // center scaled glyphs properly
+        let y_offset_points = y_offset_points + (tweak.scale - 1.0) * 0.5 * (ascent + descent);
+
+        // Round to an even number of physical pixels to get even kerning.
+        // See https://github.com/emilk/egui/issues/382
+        let scale_in_pixels = scale_in_pixels.round() as u32;
+
+        // Round to closest pixel:
+        let y_offset = (y_offset_points * pixels_per_point).round() / pixels_per_point;
+
+        Self {
+            name,
+            ab_glyph_font,
+            scale_in_pixels,
+            height_in_points: ascent - descent + line_gap,
+            y_offset,
+            ascent: ascent + baseline_offset,
+            pixels_per_point,
+            glyph_info_cache: Default::default(),
+            atlas,
+        }
+    }
+
+    /// Code points that will always be replaced by the replacement character.
+    ///
+    /// See also [`invisible_char`].
+    fn ignore_character(&self, chr: char) -> bool {
+        if self.name == "emoji-icon-font" {
+            // HACK: https://github.com/emilk/egui/issues/1284 https://github.com/jslegers/emoji-icon-font/issues/18
+            // Don't show the wrong fullwidth capital letters:
+            if 'Ｓ' <= chr && chr <= 'Ｙ' {
+                return true;
+            }
+        }
+
+        matches!(
+            chr,
+            // Strip out a religious symbol with secondary nefarious interpretation:
+            '\u{534d}' | '\u{5350}' |
+
+            // Ignore ubuntu-specific stuff in `Ubuntu-Light.ttf`:
+            '\u{E0FF}' | '\u{EFFD}' | '\u{F0FF}' | '\u{F200}'
+        )
+    }
+
+    /// An un-ordered iterator over all supported characters.
+    fn characters(&self) -> impl Iterator<Item = char> + '_ {
+        use ab_glyph::Font as _;
+        self.ab_glyph_font
+            .codepoint_ids()
+            .map(|(_, chr)| chr)
+            .filter(|&chr| !self.ignore_character(chr))
+    }
+
+    /// `\n` will result in `None`
+    fn glyph_info(&self, c: char) -> Option<GlyphInfo> {
+        {
+            if let Some(glyph_info) = self.glyph_info_cache.read().get(&c) {
+                return Some(*glyph_info);
+            }
+        }
+
+        if self.ignore_character(c) {
+            return None; // these will result in the replacement character when rendering
+        }
+
+        if c == '\t' {
+            if let Some(space) = self.glyph_info(' ') {
+                let glyph_info = GlyphInfo {
+                    advance_width: crate::text::TAB_SIZE as f32 * space.advance_width,
+                    ..GlyphInfo::default()
+                };
+                self.glyph_info_cache.write().insert(c, glyph_info);
+                return Some(glyph_info);
+            }
+        }
+
+        if c == '\u{2009}' {
+            // Thin space, often used as thousands deliminator: 1 234 567 890
+            // https://www.compart.com/en/unicode/U+2009
+            // https://en.wikipedia.org/wiki/Thin_space
+
+            if let Some(space) = self.glyph_info(' ') {
+                let em = self.height_in_points; // TODO(emilk): is this right?
+                let advance_width = f32::min(em / 6.0, space.advance_width * 0.5);
+                let glyph_info = GlyphInfo {
+                    advance_width,
+                    ..GlyphInfo::default()
+                };
+                self.glyph_info_cache.write().insert(c, glyph_info);
+                return Some(glyph_info);
+            }
+        }
+
+        if invisible_char(c) {
+            let glyph_info = GlyphInfo::default();
+            self.glyph_info_cache.write().insert(c, glyph_info);
+            return Some(glyph_info);
+        }
+
+        // Add new character:
+        use ab_glyph::Font as _;
+        let glyph_id = self.ab_glyph_font.glyph_id(c);
+
+        if glyph_id.0 == 0 {
+            None // unsupported character
+        } else {
+            let glyph_info = self.allocate_glyph(glyph_id);
+            self.glyph_info_cache.write().insert(c, glyph_info);
+            Some(glyph_info)
+        }
+    }
+
+    #[inline]
+    pub fn pair_kerning(
+        &self,
+        last_glyph_id: ab_glyph::GlyphId,
+        glyph_id: ab_glyph::GlyphId,
+    ) -> f32 {
+        use ab_glyph::{Font as _, ScaleFont};
+        self.ab_glyph_font
+            .as_scaled(self.scale_in_pixels as f32)
+            .kern(last_glyph_id, glyph_id)
+            / self.pixels_per_point
+    }
+
+    /// Height of one row of text. In points
+    #[inline(always)]
+    pub fn row_height(&self) -> f32 {
+        self.height_in_points
+    }
+
+    #[inline(always)]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.pixels_per_point
+    }
+
+    fn allocate_glyph(&self, glyph_id: ab_glyph::GlyphId) -> GlyphInfo {
+        assert!(glyph_id.0 != 0);
+        use ab_glyph::{Font as _, ScaleFont};
+
+        let glyph = glyph_id.with_scale_and_position(
+            self.scale_in_pixels as f32,
+            ab_glyph::Point { x: 0.0, y: 0.0 },
+        );
+
+        let uv_rect = self.ab_glyph_font.outline_glyph(glyph).map(|glyph| {
+            let bb = glyph.px_bounds();
+            let glyph_width = bb.width() as usize;
+            let glyph_height = bb.height() as usize;
+            if glyph_width == 0 || glyph_height == 0 {
+                UvRect::default()
+            } else {
+                let atlas = &mut self.atlas.lock();
+                let (glyph_pos, image) = atlas.allocate((glyph_width, glyph_height));
+                glyph.draw(|x, y, v| {
+                    if v > 0.0 {
+                        let px = glyph_pos.0 + x as usize;
+                        let py = glyph_pos.1 + y as usize;
+                        image[(px, py)] = v;
+                    }
+                });
+
+                let offset_in_pixels = vec2(bb.min.x, bb.min.y);
+                let offset = offset_in_pixels / self.pixels_per_point + self.y_offset * Vec2::Y;
+                UvRect {
+                    offset,
+                    size: vec2(glyph_width as f32, glyph_height as f32) / self.pixels_per_point,
+                    min: [glyph_pos.0 as u16, glyph_pos.1 as u16],
+                    max: [
+                        (glyph_pos.0 + glyph_width) as u16,
+                        (glyph_pos.1 + glyph_height) as u16,
+                    ],
+                }
+            }
+        });
+        let uv_rect = uv_rect.unwrap_or_default();
+
+        let advance_width_in_points = self
+            .ab_glyph_font
+            .as_scaled(self.scale_in_pixels as f32)
+            .h_advance(glyph_id)
+            / self.pixels_per_point;
+
+        GlyphInfo {
+            id: glyph_id,
+            advance_width: advance_width_in_points,
+            ascent: self.ascent,
+            row_height: self.row_height(),
+            uv_rect,
+        }
+    }
+}
+
+type FontIndex = usize;
+
+// TODO(emilk): rename?
+/// Wrapper over multiple [`FontImpl`] (e.g. a primary + fallbacks for emojis)
+pub struct Font {
+    fonts: Vec<Arc<FontImpl>>,
+    /// Lazily calculated.
+    characters: Option<BTreeSet<char>>,
+    replacement_glyph: (FontIndex, GlyphInfo),
+    pixels_per_point: f32,
+    row_height: f32,
+    glyph_info_cache: ahash::HashMap<char, (FontIndex, GlyphInfo)>,
+}
+
+impl Font {
+    pub fn new(fonts: Vec<Arc<FontImpl>>) -> Self {
+        if fonts.is_empty() {
+            return Self {
+                fonts,
+                characters: None,
+                replacement_glyph: Default::default(),
+                pixels_per_point: 1.0,
+                row_height: 0.0,
+                glyph_info_cache: Default::default(),
+            };
+        }
+
+        let pixels_per_point = fonts[0].pixels_per_point();
+        let row_height = fonts[0].row_height();
+
+        let mut slf = Self {
+            fonts,
+            characters: None,
+            replacement_glyph: Default::default(),
+            pixels_per_point,
+            row_height,
+            glyph_info_cache: Default::default(),
+        };
+
+        const PRIMARY_REPLACEMENT_CHAR: char = '◻'; // white medium square
+        const FALLBACK_REPLACEMENT_CHAR: char = '?'; // fallback for the fallback
+
+        let replacement_glyph = slf
+            .glyph_info_no_cache_or_fallback(PRIMARY_REPLACEMENT_CHAR)
+            .or_else(|| slf.glyph_info_no_cache_or_fallback(FALLBACK_REPLACEMENT_CHAR))
+            .unwrap_or_else(|| {
+                panic!(
+                    "Failed to find replacement characters {:?} or {:?}",
+                    PRIMARY_REPLACEMENT_CHAR, FALLBACK_REPLACEMENT_CHAR
+                )
+            });
+        slf.replacement_glyph = replacement_glyph;
+
+        slf
+    }
+
+    pub fn preload_characters(&mut self, s: &str) {
+        for c in s.chars() {
+            self.glyph_info(c);
+        }
+    }
+
+    pub fn preload_common_characters(&mut self) {
+        // Preload the printable ASCII characters [32, 126] (which excludes control codes):
+        const FIRST_ASCII: usize = 32; // 32 == space
+        const LAST_ASCII: usize = 126;
+        for c in (FIRST_ASCII..=LAST_ASCII).map(|c| c as u8 as char) {
+            self.glyph_info(c);
+        }
+        self.glyph_info('°');
+        self.glyph_info(crate::text::PASSWORD_REPLACEMENT_CHAR);
+    }
+
+    /// All supported characters.
+    pub fn characters(&mut self) -> &BTreeSet<char> {
+        self.characters.get_or_insert_with(|| {
+            let mut characters = BTreeSet::new();
+            for font in &self.fonts {
+                characters.extend(font.characters());
+            }
+            characters
+        })
+    }
+
+    #[inline(always)]
+    pub fn round_to_pixel(&self, point: f32) -> f32 {
+        (point * self.pixels_per_point).round() / self.pixels_per_point
+    }
+
+    /// Height of one row of text. In points
+    #[inline(always)]
+    pub fn row_height(&self) -> f32 {
+        self.row_height
+    }
+
+    pub fn uv_rect(&self, c: char) -> UvRect {
+        self.glyph_info_cache
+            .get(&c)
+            .map(|gi| gi.1.uv_rect)
+            .unwrap_or_default()
+    }
+
+    /// Width of this character in points.
+    pub fn glyph_width(&mut self, c: char) -> f32 {
+        self.glyph_info(c).1.advance_width
+    }
+
+    /// Can we display this glyph?
+    pub fn has_glyph(&mut self, c: char) -> bool {
+        self.glyph_info(c) != self.replacement_glyph // TODO(emilk): this is a false negative if the user asks about the replacement character itself 🤦‍♂️
+    }
+
+    /// Can we display all the glyphs in this text?
+    pub fn has_glyphs(&mut self, s: &str) -> bool {
+        s.chars().all(|c| self.has_glyph(c))
+    }
+
+    /// `\n` will (intentionally) show up as the replacement character.
+    fn glyph_info(&mut self, c: char) -> (FontIndex, GlyphInfo) {
+        if let Some(font_index_glyph_info) = self.glyph_info_cache.get(&c) {
+            return *font_index_glyph_info;
+        }
+
+        let font_index_glyph_info = self.glyph_info_no_cache_or_fallback(c);
+        let font_index_glyph_info = font_index_glyph_info.unwrap_or(self.replacement_glyph);
+        self.glyph_info_cache.insert(c, font_index_glyph_info);
+        font_index_glyph_info
+    }
+
+    #[inline]
+    pub(crate) fn glyph_info_and_font_impl(&mut self, c: char) -> (Option<&FontImpl>, GlyphInfo) {
+        if self.fonts.is_empty() {
+            return (None, self.replacement_glyph.1);
+        }
+        let (font_index, glyph_info) = self.glyph_info(c);
+        let font_impl = &self.fonts[font_index];
+        (Some(font_impl), glyph_info)
+    }
+
+    fn glyph_info_no_cache_or_fallback(&mut self, c: char) -> Option<(FontIndex, GlyphInfo)> {
+        for (font_index, font_impl) in self.fonts.iter().enumerate() {
+            if let Some(glyph_info) = font_impl.glyph_info(c) {
+                self.glyph_info_cache.insert(c, (font_index, glyph_info));
+                return Some((font_index, glyph_info));
+            }
+        }
+        None
+    }
+}
+
+/// Code points that will always be invisible (zero width).
+///
+/// See also [`FontImpl::ignore_character`].
+#[inline]
+fn invisible_char(c: char) -> bool {
+    if c == '\r' {
+        // A character most vile and pernicious. Don't display it.
+        return true;
+    }
+
+    // See https://github.com/emilk/egui/issues/336
+
+    // From https://www.fileformat.info/info/unicode/category/Cf/list.htm
+
+    // TODO(emilk): heed bidi characters
+
+    matches!(
+        c,
+        '\u{200B}' // ZERO WIDTH SPACE
+            | '\u{200C}' // ZERO WIDTH NON-JOINER
+            | '\u{200D}' // ZERO WIDTH JOINER
+            | '\u{200E}' // LEFT-TO-RIGHT MARK
+            | '\u{200F}' // RIGHT-TO-LEFT MARK
+            | '\u{202A}' // LEFT-TO-RIGHT EMBEDDING
+            | '\u{202B}' // RIGHT-TO-LEFT EMBEDDING
+            | '\u{202C}' // POP DIRECTIONAL FORMATTING
+            | '\u{202D}' // LEFT-TO-RIGHT OVERRIDE
+            | '\u{202E}' // RIGHT-TO-LEFT OVERRIDE
+            | '\u{2060}' // WORD JOINER
+            | '\u{2061}' // FUNCTION APPLICATION
+            | '\u{2062}' // INVISIBLE TIMES
+            | '\u{2063}' // INVISIBLE SEPARATOR
+            | '\u{2064}' // INVISIBLE PLUS
+            | '\u{2066}' // LEFT-TO-RIGHT ISOLATE
+            | '\u{2067}' // RIGHT-TO-LEFT ISOLATE
+            | '\u{2068}' // FIRST STRONG ISOLATE
+            | '\u{2069}' // POP DIRECTIONAL ISOLATE
+            | '\u{206A}' // INHIBIT SYMMETRIC SWAPPING
+            | '\u{206B}' // ACTIVATE SYMMETRIC SWAPPING
+            | '\u{206C}' // INHIBIT ARABIC FORM SHAPING
+            | '\u{206D}' // ACTIVATE ARABIC FORM SHAPING
+            | '\u{206E}' // NATIONAL DIGIT SHAPES
+            | '\u{206F}' // NOMINAL DIGIT SHAPES
+            | '\u{FEFF}' // ZERO WIDTH NO-BREAK SPACE
+    )
+}
diff --git a/egui/crates/epaint/src/text/fonts.rs b/egui/crates/epaint/src/text/fonts.rs
new file mode 100644
index 0000000..68dd581
--- /dev/null
+++ b/egui/crates/epaint/src/text/fonts.rs
@@ -0,0 +1,793 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use crate::{
+    mutex::{Mutex, MutexGuard},
+    text::{
+        font::{Font, FontImpl},
+        Galley, LayoutJob,
+    },
+    TextureAtlas,
+};
+use emath::NumExt as _;
+
+// ----------------------------------------------------------------------------
+
+/// How to select a sized font.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct FontId {
+    /// Height in points.
+    pub size: f32,
+
+    /// What font family to use.
+    pub family: FontFamily,
+    // TODO(emilk): weight (bold), italics, …
+}
+
+impl Default for FontId {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            size: 14.0,
+            family: FontFamily::Proportional,
+        }
+    }
+}
+
+impl FontId {
+    #[inline]
+    pub const fn new(size: f32, family: FontFamily) -> Self {
+        Self { size, family }
+    }
+
+    #[inline]
+    pub const fn proportional(size: f32) -> Self {
+        Self::new(size, FontFamily::Proportional)
+    }
+
+    #[inline]
+    pub const fn monospace(size: f32) -> Self {
+        Self::new(size, FontFamily::Monospace)
+    }
+}
+
+#[allow(clippy::derive_hash_xor_eq)]
+impl std::hash::Hash for FontId {
+    #[inline(always)]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let Self { size, family } = self;
+        crate::f32_hash(state, *size);
+        family.hash(state);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Font of unknown size.
+///
+/// Which style of font: [`Monospace`][`FontFamily::Monospace`], [`Proportional`][`FontFamily::Proportional`],
+/// or by user-chosen name.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum FontFamily {
+    /// A font where some characters are wider than other (e.g. 'w' is wider than 'i').
+    ///
+    /// Proportional fonts are easier to read and should be the preferred choice in most situations.
+    Proportional,
+
+    /// A font where each character is the same width (`w` is the same width as `i`).
+    ///
+    /// Useful for code snippets, or when you need to align numbers or text.
+    Monospace,
+
+    /// One of the names in [`FontDefinitions::families`].
+    ///
+    /// ```
+    /// # use epaint::FontFamily;
+    /// // User-chosen names:
+    /// FontFamily::Name("arial".into());
+    /// FontFamily::Name("serif".into());
+    /// ```
+    Name(Arc<str>),
+}
+
+impl Default for FontFamily {
+    #[inline]
+    fn default() -> Self {
+        FontFamily::Proportional
+    }
+}
+
+impl std::fmt::Display for FontFamily {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Monospace => "Monospace".fmt(f),
+            Self::Proportional => "Proportional".fmt(f),
+            Self::Name(name) => (*name).fmt(f),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A `.ttf` or `.otf` file and a font face index.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct FontData {
+    /// The content of a `.ttf` or `.otf` file.
+    pub font: std::borrow::Cow<'static, [u8]>,
+
+    /// Which font face in the file to use.
+    /// When in doubt, use `0`.
+    pub index: u32,
+
+    /// Extra scale and vertical tweak to apply to all text of this font.
+    pub tweak: FontTweak,
+}
+
+impl FontData {
+    pub fn from_static(font: &'static [u8]) -> Self {
+        Self {
+            font: std::borrow::Cow::Borrowed(font),
+            index: 0,
+            tweak: Default::default(),
+        }
+    }
+
+    pub fn from_owned(font: Vec<u8>) -> Self {
+        Self {
+            font: std::borrow::Cow::Owned(font),
+            index: 0,
+            tweak: Default::default(),
+        }
+    }
+
+    pub fn tweak(self, tweak: FontTweak) -> Self {
+        Self { tweak, ..self }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Extra scale and vertical tweak to apply to all text of a certain font.
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct FontTweak {
+    /// Scale the font's glyphs by this much.
+    /// this is only a visual effect and does not affect the text layout.
+    ///
+    /// Default: `1.0` (no scaling).
+    pub scale: f32,
+
+    /// Shift font's glyphs downwards by this fraction of the font size (in points).
+    /// this is only a visual effect and does not affect the text layout.
+    ///
+    /// A positive value shifts the text downwards.
+    /// A negative value shifts it upwards.
+    ///
+    /// Example value: `-0.2`.
+    pub y_offset_factor: f32,
+
+    /// Shift font's glyphs downwards by this amount of logical points.
+    /// this is only a visual effect and does not affect the text layout.
+    ///
+    /// Example value: `2.0`.
+    pub y_offset: f32,
+
+    /// When using this font's metrics to layout a row,
+    /// shift the entire row downwards by this fraction of the font size (in points).
+    ///
+    /// A positive value shifts the text downwards.
+    /// A negative value shifts it upwards.
+    pub baseline_offset_factor: f32,
+}
+
+impl Default for FontTweak {
+    fn default() -> Self {
+        Self {
+            scale: 1.0,
+            y_offset_factor: 0.0,
+            y_offset: 0.0,
+            baseline_offset_factor: -0.0333, // makes the default fonts look more centered in buttons and such
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn ab_glyph_font_from_font_data(name: &str, data: &FontData) -> ab_glyph::FontArc {
+    match &data.font {
+        std::borrow::Cow::Borrowed(bytes) => {
+            ab_glyph::FontRef::try_from_slice_and_index(bytes, data.index)
+                .map(ab_glyph::FontArc::from)
+        }
+        std::borrow::Cow::Owned(bytes) => {
+            ab_glyph::FontVec::try_from_vec_and_index(bytes.clone(), data.index)
+                .map(ab_glyph::FontArc::from)
+        }
+    }
+    .unwrap_or_else(|err| panic!("Error parsing {:?} TTF/OTF font file: {}", name, err))
+}
+
+/// Describes the font data and the sizes to use.
+///
+/// Often you would start with [`FontDefinitions::default()`] and then add/change the contents.
+///
+/// This is how you install your own custom fonts:
+/// ```
+/// # use {epaint::text::{FontDefinitions, FontFamily, FontData}};
+/// # struct FakeEguiCtx {};
+/// # impl FakeEguiCtx { fn set_fonts(&self, _: FontDefinitions) {} }
+/// # let egui_ctx = FakeEguiCtx {};
+/// let mut fonts = FontDefinitions::default();
+///
+/// // Install my own font (maybe supporting non-latin characters):
+/// fonts.font_data.insert("my_font".to_owned(),
+///    FontData::from_static(include_bytes!("../../fonts/Ubuntu-Light.ttf"))); // .ttf and .otf supported
+///
+/// // Put my font first (highest priority):
+/// fonts.families.get_mut(&FontFamily::Proportional).unwrap()
+///     .insert(0, "my_font".to_owned());
+///
+/// // Put my font as last fallback for monospace:
+/// fonts.families.get_mut(&FontFamily::Monospace).unwrap()
+///     .push("my_font".to_owned());
+///
+/// egui_ctx.set_fonts(fonts);
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct FontDefinitions {
+    /// List of font names and their definitions.
+    ///
+    /// `epaint` has built-in-default for these, but you can override them if you like.
+    pub font_data: BTreeMap<String, FontData>,
+
+    /// Which fonts (names) to use for each [`FontFamily`].
+    ///
+    /// The list should be a list of keys into [`Self::font_data`].
+    /// When looking for a character glyph `epaint` will start with
+    /// the first font and then move to the second, and so on.
+    /// So the first font is the primary, and then comes a list of fallbacks in order of priority.
+    pub families: BTreeMap<FontFamily, Vec<String>>,
+}
+
+impl Default for FontDefinitions {
+    /// Specifies the default fonts if the feature `default_fonts` is enabled,
+    /// otherwise this is the same as [`Self::empty`].
+    #[cfg(not(feature = "default_fonts"))]
+    fn default() -> Self {
+        Self::empty()
+    }
+
+    /// Specifies the default fonts if the feature `default_fonts` is enabled,
+    /// otherwise this is the same as [`Self::empty`].
+    #[cfg(feature = "default_fonts")]
+    fn default() -> Self {
+        let mut font_data: BTreeMap<String, FontData> = BTreeMap::new();
+
+        let mut families = BTreeMap::new();
+
+        font_data.insert(
+            "Hack".to_owned(),
+            FontData::from_static(include_bytes!("../../fonts/Hack-Regular.ttf")),
+        );
+        font_data.insert(
+            "Ubuntu-Light".to_owned(),
+            FontData::from_static(include_bytes!("../../fonts/Ubuntu-Light.ttf")),
+        );
+
+        // Some good looking emojis. Use as first priority:
+        font_data.insert(
+            "NotoEmoji-Regular".to_owned(),
+            FontData::from_static(include_bytes!("../../fonts/NotoEmoji-Regular.ttf")).tweak(
+                FontTweak {
+                    scale: 0.81, // make it smaller
+                    ..Default::default()
+                },
+            ),
+        );
+
+        // Bigger emojis, and more. <http://jslegers.github.io/emoji-icon-font/>:
+        font_data.insert(
+            "emoji-icon-font".to_owned(),
+            FontData::from_static(include_bytes!("../../fonts/emoji-icon-font.ttf")).tweak(
+                FontTweak {
+                    scale: 0.88, // make it smaller
+
+                    // probably not correct, but this does make texts look better (#2724 for details)
+                    y_offset_factor: 0.11, // move glyphs down to better align with common fonts
+                    baseline_offset_factor: -0.11, // ...now the entire row is a bit down so shift it back
+                    ..Default::default()
+                },
+            ),
+        );
+
+        families.insert(
+            FontFamily::Monospace,
+            vec![
+                "Hack".to_owned(),
+                "Ubuntu-Light".to_owned(), // fallback for √ etc
+                "NotoEmoji-Regular".to_owned(),
+                "emoji-icon-font".to_owned(),
+            ],
+        );
+        families.insert(
+            FontFamily::Proportional,
+            vec![
+                "Ubuntu-Light".to_owned(),
+                "NotoEmoji-Regular".to_owned(),
+                "emoji-icon-font".to_owned(),
+            ],
+        );
+
+        Self {
+            font_data,
+            families,
+        }
+    }
+}
+
+impl FontDefinitions {
+    /// No fonts.
+    pub fn empty() -> Self {
+        let mut families = BTreeMap::new();
+        families.insert(FontFamily::Monospace, vec![]);
+        families.insert(FontFamily::Proportional, vec![]);
+
+        Self {
+            font_data: Default::default(),
+            families,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// The collection of fonts used by `epaint`.
+///
+/// Required in order to paint text. Create one and reuse. Cheap to clone.
+///
+/// Each [`Fonts`] comes with a font atlas textures that needs to be used when painting.
+///
+/// If you are using `egui`, use `egui::Context::set_fonts` and `egui::Context::fonts`.
+///
+/// You need to call [`Self::begin_frame`] and [`Self::font_image_delta`] once every frame.
+pub struct Fonts(Arc<Mutex<FontsAndCache>>);
+
+impl Fonts {
+    /// Create a new [`Fonts`] for text layout.
+    /// This call is expensive, so only create one [`Fonts`] and then reuse it.
+    ///
+    /// * `pixels_per_point`: how many physical pixels per logical "point".
+    /// * `max_texture_side`: largest supported texture size (one side).
+    pub fn new(
+        pixels_per_point: f32,
+        max_texture_side: usize,
+        definitions: FontDefinitions,
+    ) -> Self {
+        let fonts_and_cache = FontsAndCache {
+            fonts: FontsImpl::new(pixels_per_point, max_texture_side, definitions),
+            galley_cache: Default::default(),
+        };
+        Self(Arc::new(Mutex::new(fonts_and_cache)))
+    }
+
+    /// Call at the start of each frame with the latest known
+    /// `pixels_per_point` and `max_texture_side`.
+    ///
+    /// Call after painting the previous frame, but before using [`Fonts`] for the new frame.
+    ///
+    /// This function will react to changes in `pixels_per_point` and `max_texture_side`,
+    /// as well as notice when the font atlas is getting full, and handle that.
+    pub fn begin_frame(&self, pixels_per_point: f32, max_texture_side: usize) {
+        let mut fonts_and_cache = self.0.lock();
+
+        let pixels_per_point_changed =
+            (fonts_and_cache.fonts.pixels_per_point - pixels_per_point).abs() > 1e-3;
+        let max_texture_side_changed = fonts_and_cache.fonts.max_texture_side != max_texture_side;
+        let font_atlas_almost_full = fonts_and_cache.fonts.atlas.lock().fill_ratio() > 0.8;
+        let needs_recreate =
+            pixels_per_point_changed || max_texture_side_changed || font_atlas_almost_full;
+
+        if needs_recreate {
+            let definitions = fonts_and_cache.fonts.definitions.clone();
+
+            *fonts_and_cache = FontsAndCache {
+                fonts: FontsImpl::new(pixels_per_point, max_texture_side, definitions),
+                galley_cache: Default::default(),
+            };
+        }
+
+        fonts_and_cache.galley_cache.flush_cache();
+    }
+
+    /// Call at the end of each frame (before painting) to get the change to the font texture since last call.
+    pub fn font_image_delta(&self) -> Option<crate::ImageDelta> {
+        self.lock().fonts.atlas.lock().take_delta()
+    }
+
+    /// Access the underlying [`FontsAndCache`].
+    #[doc(hidden)]
+    #[inline]
+    pub fn lock(&self) -> MutexGuard<'_, FontsAndCache> {
+        self.0.lock()
+    }
+
+    #[inline]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.lock().fonts.pixels_per_point
+    }
+
+    #[inline]
+    pub fn max_texture_side(&self) -> usize {
+        self.lock().fonts.max_texture_side
+    }
+
+    /// The font atlas.
+    /// Pass this to [`crate::Tessellator`].
+    pub fn texture_atlas(&self) -> Arc<Mutex<TextureAtlas>> {
+        self.lock().fonts.atlas.clone()
+    }
+
+    /// Current size of the font image.
+    /// Pass this to [`crate::Tessellator`].
+    pub fn font_image_size(&self) -> [usize; 2] {
+        self.lock().fonts.atlas.lock().size()
+    }
+
+    /// Width of this character in points.
+    #[inline]
+    pub fn glyph_width(&self, font_id: &FontId, c: char) -> f32 {
+        self.lock().fonts.glyph_width(font_id, c)
+    }
+
+    /// Can we display this glyph?
+    #[inline]
+    pub fn has_glyph(&self, font_id: &FontId, c: char) -> bool {
+        self.lock().fonts.has_glyph(font_id, c)
+    }
+
+    /// Can we display all the glyphs in this text?
+    pub fn has_glyphs(&self, font_id: &FontId, s: &str) -> bool {
+        self.lock().fonts.has_glyphs(font_id, s)
+    }
+
+    /// Height of one row of text in points
+    #[inline]
+    pub fn row_height(&self, font_id: &FontId) -> f32 {
+        self.lock().fonts.row_height(font_id)
+    }
+
+    /// List of all known font families.
+    pub fn families(&self) -> Vec<FontFamily> {
+        self.lock()
+            .fonts
+            .definitions
+            .families
+            .keys()
+            .cloned()
+            .collect()
+    }
+
+    /// Layout some text.
+    ///
+    /// This is the most advanced layout function.
+    /// See also [`Self::layout`], [`Self::layout_no_wrap`] and
+    /// [`Self::layout_delayed_color`].
+    ///
+    /// The implementation uses memoization so repeated calls are cheap.
+    #[inline]
+    pub fn layout_job(&self, job: LayoutJob) -> Arc<Galley> {
+        self.lock().layout_job(job)
+    }
+
+    pub fn num_galleys_in_cache(&self) -> usize {
+        self.lock().galley_cache.num_galleys_in_cache()
+    }
+
+    /// How full is the font atlas?
+    ///
+    /// This increases as new fonts and/or glyphs are used,
+    /// but can also decrease in a call to [`Self::begin_frame`].
+    pub fn font_atlas_fill_ratio(&self) -> f32 {
+        self.lock().fonts.atlas.lock().fill_ratio()
+    }
+
+    /// Will wrap text at the given width and line break at `\n`.
+    ///
+    /// The implementation uses memoization so repeated calls are cheap.
+    pub fn layout(
+        &self,
+        text: String,
+        font_id: FontId,
+        color: crate::Color32,
+        wrap_width: f32,
+    ) -> Arc<Galley> {
+        let job = LayoutJob::simple(text, font_id, color, wrap_width);
+        self.layout_job(job)
+    }
+
+    /// Will line break at `\n`.
+    ///
+    /// The implementation uses memoization so repeated calls are cheap.
+    pub fn layout_no_wrap(
+        &self,
+        text: String,
+        font_id: FontId,
+        color: crate::Color32,
+    ) -> Arc<Galley> {
+        let job = LayoutJob::simple(text, font_id, color, f32::INFINITY);
+        self.layout_job(job)
+    }
+
+    /// Like [`Self::layout`], made for when you want to pick a color for the text later.
+    ///
+    /// The implementation uses memoization so repeated calls are cheap.
+    pub fn layout_delayed_color(
+        &self,
+        text: String,
+        font_id: FontId,
+        wrap_width: f32,
+    ) -> Arc<Galley> {
+        self.layout_job(LayoutJob::simple(
+            text,
+            font_id,
+            crate::Color32::TEMPORARY_COLOR,
+            wrap_width,
+        ))
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub struct FontsAndCache {
+    pub fonts: FontsImpl,
+    galley_cache: GalleyCache,
+}
+
+impl FontsAndCache {
+    fn layout_job(&mut self, job: LayoutJob) -> Arc<Galley> {
+        self.galley_cache.layout(&mut self.fonts, job)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct HashableF32(f32);
+
+#[allow(clippy::derive_hash_xor_eq)]
+impl std::hash::Hash for HashableF32 {
+    #[inline(always)]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        crate::f32_hash(state, self.0);
+    }
+}
+
+impl Eq for HashableF32 {}
+
+// ----------------------------------------------------------------------------
+
+/// The collection of fonts used by `epaint`.
+///
+/// Required in order to paint text.
+pub struct FontsImpl {
+    pixels_per_point: f32,
+    max_texture_side: usize,
+    definitions: FontDefinitions,
+    atlas: Arc<Mutex<TextureAtlas>>,
+    font_impl_cache: FontImplCache,
+    sized_family: ahash::HashMap<(HashableF32, FontFamily), Font>,
+}
+
+impl FontsImpl {
+    /// Create a new [`FontsImpl`] for text layout.
+    /// This call is expensive, so only create one [`FontsImpl`] and then reuse it.
+    pub fn new(
+        pixels_per_point: f32,
+        max_texture_side: usize,
+        definitions: FontDefinitions,
+    ) -> Self {
+        assert!(
+            0.0 < pixels_per_point && pixels_per_point < 100.0,
+            "pixels_per_point out of range: {}",
+            pixels_per_point
+        );
+
+        let texture_width = max_texture_side.at_most(8 * 1024);
+        let initial_height = 64;
+        let atlas = TextureAtlas::new([texture_width, initial_height]);
+
+        let atlas = Arc::new(Mutex::new(atlas));
+
+        let font_impl_cache =
+            FontImplCache::new(atlas.clone(), pixels_per_point, &definitions.font_data);
+
+        Self {
+            pixels_per_point,
+            max_texture_side,
+            definitions,
+            atlas,
+            font_impl_cache,
+            sized_family: Default::default(),
+        }
+    }
+
+    #[inline(always)]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.pixels_per_point
+    }
+
+    #[inline]
+    pub fn definitions(&self) -> &FontDefinitions {
+        &self.definitions
+    }
+
+    /// Get the right font implementation from size and [`FontFamily`].
+    pub fn font(&mut self, font_id: &FontId) -> &mut Font {
+        let FontId { size, family } = font_id;
+
+        self.sized_family
+            .entry((HashableF32(*size), family.clone()))
+            .or_insert_with(|| {
+                let fonts = &self.definitions.families.get(family);
+                let fonts = fonts.unwrap_or_else(|| {
+                    panic!("FontFamily::{:?} is not bound to any fonts", family)
+                });
+
+                let fonts: Vec<Arc<FontImpl>> = fonts
+                    .iter()
+                    .map(|font_name| self.font_impl_cache.font_impl(*size, font_name))
+                    .collect();
+
+                Font::new(fonts)
+            })
+    }
+
+    /// Width of this character in points.
+    fn glyph_width(&mut self, font_id: &FontId, c: char) -> f32 {
+        self.font(font_id).glyph_width(c)
+    }
+
+    /// Can we display this glyph?
+    pub fn has_glyph(&mut self, font_id: &FontId, c: char) -> bool {
+        self.font(font_id).has_glyph(c)
+    }
+
+    /// Can we display all the glyphs in this text?
+    pub fn has_glyphs(&mut self, font_id: &FontId, s: &str) -> bool {
+        self.font(font_id).has_glyphs(s)
+    }
+
+    /// Height of one row of text. In points
+    fn row_height(&mut self, font_id: &FontId) -> f32 {
+        self.font(font_id).row_height()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+struct CachedGalley {
+    /// When it was last used
+    last_used: u32,
+    galley: Arc<Galley>,
+}
+
+#[derive(Default)]
+struct GalleyCache {
+    /// Frame counter used to do garbage collection on the cache
+    generation: u32,
+    cache: nohash_hasher::IntMap<u64, CachedGalley>,
+}
+
+impl GalleyCache {
+    fn layout(&mut self, fonts: &mut FontsImpl, job: LayoutJob) -> Arc<Galley> {
+        let hash = crate::util::hash(&job); // TODO(emilk): even faster hasher?
+
+        match self.cache.entry(hash) {
+            std::collections::hash_map::Entry::Occupied(entry) => {
+                let cached = entry.into_mut();
+                cached.last_used = self.generation;
+                cached.galley.clone()
+            }
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                let galley = super::layout(fonts, job.into());
+                let galley = Arc::new(galley);
+                entry.insert(CachedGalley {
+                    last_used: self.generation,
+                    galley: galley.clone(),
+                });
+                galley
+            }
+        }
+    }
+
+    pub fn num_galleys_in_cache(&self) -> usize {
+        self.cache.len()
+    }
+
+    /// Must be called once per frame to clear the [`Galley`] cache.
+    pub fn flush_cache(&mut self) {
+        let current_generation = self.generation;
+        self.cache.retain(|_key, cached| {
+            cached.last_used == current_generation // only keep those that were used this frame
+        });
+        self.generation = self.generation.wrapping_add(1);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+struct FontImplCache {
+    atlas: Arc<Mutex<TextureAtlas>>,
+    pixels_per_point: f32,
+    ab_glyph_fonts: BTreeMap<String, (FontTweak, ab_glyph::FontArc)>,
+
+    /// Map font pixel sizes and names to the cached [`FontImpl`].
+    cache: ahash::HashMap<(u32, String), Arc<FontImpl>>,
+}
+
+impl FontImplCache {
+    pub fn new(
+        atlas: Arc<Mutex<TextureAtlas>>,
+        pixels_per_point: f32,
+        font_data: &BTreeMap<String, FontData>,
+    ) -> Self {
+        let ab_glyph_fonts = font_data
+            .iter()
+            .map(|(name, font_data)| {
+                let tweak = font_data.tweak;
+                let ab_glyph = ab_glyph_font_from_font_data(name, font_data);
+                (name.clone(), (tweak, ab_glyph))
+            })
+            .collect();
+
+        Self {
+            atlas,
+            pixels_per_point,
+            ab_glyph_fonts,
+            cache: Default::default(),
+        }
+    }
+
+    pub fn font_impl(&mut self, scale_in_points: f32, font_name: &str) -> Arc<FontImpl> {
+        use ab_glyph::Font as _;
+
+        let (tweak, ab_glyph_font) = self
+            .ab_glyph_fonts
+            .get(font_name)
+            .unwrap_or_else(|| panic!("No font data found for {:?}", font_name))
+            .clone();
+
+        let scale_in_pixels = self.pixels_per_point * scale_in_points;
+
+        // Scale the font properly (see https://github.com/emilk/egui/issues/2068).
+        let units_per_em = ab_glyph_font.units_per_em().unwrap_or_else(|| {
+            panic!(
+                "The font unit size of {:?} exceeds the expected range (16..=16384)",
+                font_name
+            )
+        });
+        let font_scaling = ab_glyph_font.height_unscaled() / units_per_em;
+        let scale_in_pixels = scale_in_pixels * font_scaling;
+
+        self.cache
+            .entry((
+                (scale_in_pixels * tweak.scale).round() as u32,
+                font_name.to_owned(),
+            ))
+            .or_insert_with(|| {
+                Arc::new(FontImpl::new(
+                    self.atlas.clone(),
+                    self.pixels_per_point,
+                    font_name.to_owned(),
+                    ab_glyph_font,
+                    scale_in_pixels,
+                    tweak,
+                ))
+            })
+            .clone()
+    }
+}
diff --git a/egui/crates/epaint/src/text/mod.rs b/egui/crates/epaint/src/text/mod.rs
new file mode 100644
index 0000000..ca1bc31
--- /dev/null
+++ b/egui/crates/epaint/src/text/mod.rs
@@ -0,0 +1,19 @@
+//! Everything related to text, fonts, text layout, cursors etc.
+
+pub mod cursor;
+mod font;
+mod fonts;
+mod text_layout;
+mod text_layout_types;
+
+/// One `\t` character is this many spaces wide.
+pub const TAB_SIZE: usize = 4;
+
+pub use {
+    fonts::{FontData, FontDefinitions, FontFamily, FontId, FontTweak, Fonts, FontsImpl},
+    text_layout::layout,
+    text_layout_types::*,
+};
+
+/// Suggested character to use to replace those in password text fields.
+pub const PASSWORD_REPLACEMENT_CHAR: char = '•';
diff --git a/egui/crates/epaint/src/text/text_layout.rs b/egui/crates/epaint/src/text/text_layout.rs
new file mode 100644
index 0000000..c493f8f
--- /dev/null
+++ b/egui/crates/epaint/src/text/text_layout.rs
@@ -0,0 +1,873 @@
+use std::ops::RangeInclusive;
+use std::sync::Arc;
+
+use super::{FontsImpl, Galley, Glyph, LayoutJob, LayoutSection, Row, RowVisuals};
+use crate::{Color32, Mesh, Stroke, Vertex};
+use emath::*;
+
+// ----------------------------------------------------------------------------
+
+/// Represents GUI scale and convenience methods for rounding to pixels.
+#[derive(Clone, Copy)]
+struct PointScale {
+    pub pixels_per_point: f32,
+}
+
+impl PointScale {
+    #[inline(always)]
+    pub fn new(pixels_per_point: f32) -> Self {
+        Self { pixels_per_point }
+    }
+
+    #[inline(always)]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.pixels_per_point
+    }
+
+    #[inline(always)]
+    pub fn round_to_pixel(&self, point: f32) -> f32 {
+        (point * self.pixels_per_point).round() / self.pixels_per_point
+    }
+
+    #[inline(always)]
+    pub fn floor_to_pixel(&self, point: f32) -> f32 {
+        (point * self.pixels_per_point).floor() / self.pixels_per_point
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Temporary storage before line-wrapping.
+#[derive(Default, Clone)]
+struct Paragraph {
+    /// Start of the next glyph to be added.
+    pub cursor_x: f32,
+
+    pub glyphs: Vec<Glyph>,
+
+    /// In case of an empty paragraph ("\n"), use this as height.
+    pub empty_paragraph_height: f32,
+}
+
+/// Layout text into a [`Galley`].
+///
+/// In most cases you should use [`crate::Fonts::layout_job`] instead
+/// since that memoizes the input, making subsequent layouting of the same text much faster.
+pub fn layout(fonts: &mut FontsImpl, job: Arc<LayoutJob>) -> Galley {
+    let mut paragraphs = vec![Paragraph::default()];
+    for (section_index, section) in job.sections.iter().enumerate() {
+        layout_section(fonts, &job, section_index as u32, section, &mut paragraphs);
+    }
+
+    let point_scale = PointScale::new(fonts.pixels_per_point());
+
+    let mut rows = rows_from_paragraphs(fonts, paragraphs, &job);
+
+    let justify = job.justify && job.wrap.max_width.is_finite();
+
+    if justify || job.halign != Align::LEFT {
+        let num_rows = rows.len();
+        for (i, row) in rows.iter_mut().enumerate() {
+            let is_last_row = i + 1 == num_rows;
+            let justify_row = justify && !row.ends_with_newline && !is_last_row;
+            halign_and_justify_row(
+                point_scale,
+                row,
+                job.halign,
+                job.wrap.max_width,
+                justify_row,
+            );
+        }
+    }
+
+    galley_from_rows(point_scale, job, rows)
+}
+
+fn layout_section(
+    fonts: &mut FontsImpl,
+    job: &LayoutJob,
+    section_index: u32,
+    section: &LayoutSection,
+    out_paragraphs: &mut Vec<Paragraph>,
+) {
+    let LayoutSection {
+        leading_space,
+        byte_range,
+        format,
+    } = section;
+    let font = fonts.font(&format.font_id);
+    let font_height = font.row_height();
+
+    let mut paragraph = out_paragraphs.last_mut().unwrap();
+    if paragraph.glyphs.is_empty() {
+        paragraph.empty_paragraph_height = font_height; // TODO(emilk): replace this hack with actually including `\n` in the glyphs?
+    }
+
+    paragraph.cursor_x += leading_space;
+
+    let mut last_glyph_id = None;
+
+    for chr in job.text[byte_range.clone()].chars() {
+        if job.break_on_newline && chr == '\n' {
+            out_paragraphs.push(Paragraph::default());
+            paragraph = out_paragraphs.last_mut().unwrap();
+            paragraph.empty_paragraph_height = font_height; // TODO(emilk): replace this hack with actually including `\n` in the glyphs?
+        } else {
+            let (font_impl, glyph_info) = font.glyph_info_and_font_impl(chr);
+            if let Some(font_impl) = font_impl {
+                if let Some(last_glyph_id) = last_glyph_id {
+                    paragraph.cursor_x += font_impl.pair_kerning(last_glyph_id, glyph_info.id);
+                }
+            }
+
+            paragraph.glyphs.push(Glyph {
+                chr,
+                pos: pos2(paragraph.cursor_x, f32::NAN),
+                size: vec2(glyph_info.advance_width, glyph_info.row_height),
+                ascent: glyph_info.ascent,
+                uv_rect: glyph_info.uv_rect,
+                section_index,
+            });
+
+            paragraph.cursor_x += glyph_info.advance_width;
+            paragraph.cursor_x = font.round_to_pixel(paragraph.cursor_x);
+            last_glyph_id = Some(glyph_info.id);
+        }
+    }
+}
+
+/// We ignore y at this stage
+fn rect_from_x_range(x_range: RangeInclusive<f32>) -> Rect {
+    Rect::from_x_y_ranges(x_range, 0.0..=0.0)
+}
+
+fn rows_from_paragraphs(
+    fonts: &mut FontsImpl,
+    paragraphs: Vec<Paragraph>,
+    job: &LayoutJob,
+) -> Vec<Row> {
+    let num_paragraphs = paragraphs.len();
+
+    let mut rows = vec![];
+
+    for (i, paragraph) in paragraphs.into_iter().enumerate() {
+        let is_last_paragraph = (i + 1) == num_paragraphs;
+
+        if paragraph.glyphs.is_empty() {
+            rows.push(Row {
+                glyphs: vec![],
+                visuals: Default::default(),
+                rect: Rect::from_min_size(
+                    pos2(paragraph.cursor_x, 0.0),
+                    vec2(0.0, paragraph.empty_paragraph_height),
+                ),
+                ends_with_newline: !is_last_paragraph,
+            });
+        } else {
+            let paragraph_max_x = paragraph.glyphs.last().unwrap().max_x();
+            if paragraph_max_x <= job.wrap.max_width {
+                // early-out optimization
+                let paragraph_min_x = paragraph.glyphs[0].pos.x;
+                rows.push(Row {
+                    glyphs: paragraph.glyphs,
+                    visuals: Default::default(),
+                    rect: rect_from_x_range(paragraph_min_x..=paragraph_max_x),
+                    ends_with_newline: !is_last_paragraph,
+                });
+            } else {
+                line_break(fonts, &paragraph, job, &mut rows);
+                rows.last_mut().unwrap().ends_with_newline = !is_last_paragraph;
+            }
+        }
+    }
+
+    rows
+}
+
+fn line_break(
+    fonts: &mut FontsImpl,
+    paragraph: &Paragraph,
+    job: &LayoutJob,
+    out_rows: &mut Vec<Row>,
+) {
+    // Keeps track of good places to insert row break if we exceed `wrap_width`.
+    let mut row_break_candidates = RowBreakCandidates::default();
+
+    let mut first_row_indentation = paragraph.glyphs[0].pos.x;
+    let mut row_start_x = 0.0;
+    let mut row_start_idx = 0;
+    let mut non_empty_rows = 0;
+
+    for i in 0..paragraph.glyphs.len() {
+        let potential_row_width = paragraph.glyphs[i].max_x() - row_start_x;
+
+        if job.wrap.max_rows > 0 && non_empty_rows >= job.wrap.max_rows {
+            break;
+        }
+
+        if potential_row_width > job.wrap.max_width {
+            if first_row_indentation > 0.0
+                && !row_break_candidates.has_good_candidate(job.wrap.break_anywhere)
+            {
+                // Allow the first row to be completely empty, because we know there will be more space on the next row:
+                // TODO(emilk): this records the height of this first row as zero, though that is probably fine since first_row_indentation usually comes with a first_row_min_height.
+                out_rows.push(Row {
+                    glyphs: vec![],
+                    visuals: Default::default(),
+                    rect: rect_from_x_range(first_row_indentation..=first_row_indentation),
+                    ends_with_newline: false,
+                });
+                row_start_x += first_row_indentation;
+                first_row_indentation = 0.0;
+            } else if let Some(last_kept_index) = row_break_candidates.get(job.wrap.break_anywhere)
+            {
+                let glyphs: Vec<Glyph> = paragraph.glyphs[row_start_idx..=last_kept_index]
+                    .iter()
+                    .copied()
+                    .map(|mut glyph| {
+                        glyph.pos.x -= row_start_x;
+                        glyph
+                    })
+                    .collect();
+
+                let paragraph_min_x = glyphs[0].pos.x;
+                let paragraph_max_x = glyphs.last().unwrap().max_x();
+
+                out_rows.push(Row {
+                    glyphs,
+                    visuals: Default::default(),
+                    rect: rect_from_x_range(paragraph_min_x..=paragraph_max_x),
+                    ends_with_newline: false,
+                });
+
+                row_start_idx = last_kept_index + 1;
+                row_start_x = paragraph.glyphs[row_start_idx].pos.x;
+                row_break_candidates = Default::default();
+                non_empty_rows += 1;
+            } else {
+                // Found no place to break, so we have to overrun wrap_width.
+            }
+        }
+
+        row_break_candidates.add(i, &paragraph.glyphs[i..]);
+    }
+
+    if row_start_idx < paragraph.glyphs.len() {
+        if job.wrap.max_rows > 0 && non_empty_rows == job.wrap.max_rows {
+            if let Some(last_row) = out_rows.last_mut() {
+                replace_last_glyph_with_overflow_character(fonts, job, last_row);
+            }
+        } else {
+            let glyphs: Vec<Glyph> = paragraph.glyphs[row_start_idx..]
+                .iter()
+                .copied()
+                .map(|mut glyph| {
+                    glyph.pos.x -= row_start_x;
+                    glyph
+                })
+                .collect();
+
+            let paragraph_min_x = glyphs[0].pos.x;
+            let paragraph_max_x = glyphs.last().unwrap().max_x();
+
+            out_rows.push(Row {
+                glyphs,
+                visuals: Default::default(),
+                rect: rect_from_x_range(paragraph_min_x..=paragraph_max_x),
+                ends_with_newline: false,
+            });
+        }
+    }
+}
+
+fn replace_last_glyph_with_overflow_character(
+    fonts: &mut FontsImpl,
+    job: &LayoutJob,
+    row: &mut Row,
+) {
+    let overflow_character = match job.wrap.overflow_character {
+        Some(c) => c,
+        None => return,
+    };
+
+    loop {
+        let (prev_glyph, last_glyph) = match row.glyphs.as_mut_slice() {
+            [.., prev, last] => (Some(prev), last),
+            [.., last] => (None, last),
+            _ => break,
+        };
+
+        let section = &job.sections[last_glyph.section_index as usize];
+        let font = fonts.font(&section.format.font_id);
+        let font_height = font.row_height();
+
+        let prev_glyph_id = prev_glyph.map(|prev_glyph| {
+            let (_, prev_glyph_info) = font.glyph_info_and_font_impl(prev_glyph.chr);
+            prev_glyph_info.id
+        });
+
+        // undo kerning with previous glyph
+        let (font_impl, glyph_info) = font.glyph_info_and_font_impl(last_glyph.chr);
+        last_glyph.pos.x -= font_impl
+            .zip(prev_glyph_id)
+            .map(|(font_impl, prev_glyph_id)| font_impl.pair_kerning(prev_glyph_id, glyph_info.id))
+            .unwrap_or_default();
+
+        // replace the glyph
+        last_glyph.chr = overflow_character;
+        let (font_impl, glyph_info) = font.glyph_info_and_font_impl(last_glyph.chr);
+        last_glyph.size = vec2(glyph_info.advance_width, font_height);
+        last_glyph.uv_rect = glyph_info.uv_rect;
+
+        // reapply kerning
+        last_glyph.pos.x += font_impl
+            .zip(prev_glyph_id)
+            .map(|(font_impl, prev_glyph_id)| font_impl.pair_kerning(prev_glyph_id, glyph_info.id))
+            .unwrap_or_default();
+
+        // check if we're still within width budget
+        let row_end_x = last_glyph.max_x();
+        let row_start_x = row.glyphs.first().unwrap().pos.x; // if `last_mut()` returned `Some`, then so will `first()`
+        let row_width = row_end_x - row_start_x;
+        if row_width <= job.wrap.max_width {
+            break;
+        }
+
+        row.glyphs.pop();
+    }
+}
+
+fn halign_and_justify_row(
+    point_scale: PointScale,
+    row: &mut Row,
+    halign: Align,
+    wrap_width: f32,
+    justify: bool,
+) {
+    if row.glyphs.is_empty() {
+        return;
+    }
+
+    let num_leading_spaces = row
+        .glyphs
+        .iter()
+        .take_while(|glyph| glyph.chr.is_whitespace())
+        .count();
+
+    let glyph_range = if num_leading_spaces == row.glyphs.len() {
+        // There is only whitespace
+        (0, row.glyphs.len())
+    } else {
+        let num_trailing_spaces = row
+            .glyphs
+            .iter()
+            .rev()
+            .take_while(|glyph| glyph.chr.is_whitespace())
+            .count();
+
+        (num_leading_spaces, row.glyphs.len() - num_trailing_spaces)
+    };
+    let num_glyphs_in_range = glyph_range.1 - glyph_range.0;
+    assert!(num_glyphs_in_range > 0);
+
+    let original_min_x = row.glyphs[glyph_range.0].logical_rect().min.x;
+    let original_max_x = row.glyphs[glyph_range.1 - 1].logical_rect().max.x;
+    let original_width = original_max_x - original_min_x;
+
+    let target_width = if justify && num_glyphs_in_range > 1 {
+        wrap_width
+    } else {
+        original_width
+    };
+
+    let (target_min_x, target_max_x) = match halign {
+        Align::LEFT => (0.0, target_width),
+        Align::Center => (-target_width / 2.0, target_width / 2.0),
+        Align::RIGHT => (-target_width, 0.0),
+    };
+
+    let num_spaces_in_range = row.glyphs[glyph_range.0..glyph_range.1]
+        .iter()
+        .filter(|glyph| glyph.chr.is_whitespace())
+        .count();
+
+    let mut extra_x_per_glyph = if num_glyphs_in_range == 1 {
+        0.0
+    } else {
+        (target_width - original_width) / (num_glyphs_in_range as f32 - 1.0)
+    };
+    extra_x_per_glyph = extra_x_per_glyph.at_least(0.0); // Don't contract
+
+    let mut extra_x_per_space = 0.0;
+    if 0 < num_spaces_in_range && num_spaces_in_range < num_glyphs_in_range {
+        // Add an integral number of pixels between each glyph,
+        // and add the balance to the spaces:
+
+        extra_x_per_glyph = point_scale.floor_to_pixel(extra_x_per_glyph);
+
+        extra_x_per_space = (target_width
+            - original_width
+            - extra_x_per_glyph * (num_glyphs_in_range as f32 - 1.0))
+            / (num_spaces_in_range as f32);
+    }
+
+    let mut translate_x = target_min_x - original_min_x - extra_x_per_glyph * glyph_range.0 as f32;
+
+    for glyph in &mut row.glyphs {
+        glyph.pos.x += translate_x;
+        glyph.pos.x = point_scale.round_to_pixel(glyph.pos.x);
+        translate_x += extra_x_per_glyph;
+        if glyph.chr.is_whitespace() {
+            translate_x += extra_x_per_space;
+        }
+    }
+
+    // Note we ignore the leading/trailing whitespace here!
+    row.rect.min.x = target_min_x;
+    row.rect.max.x = target_max_x;
+}
+
+/// Calculate the Y positions and tessellate the text.
+fn galley_from_rows(point_scale: PointScale, job: Arc<LayoutJob>, mut rows: Vec<Row>) -> Galley {
+    let mut first_row_min_height = job.first_row_min_height;
+    let mut cursor_y = 0.0;
+    let mut min_x: f32 = 0.0;
+    let mut max_x: f32 = 0.0;
+    for row in &mut rows {
+        let mut row_height = first_row_min_height.max(row.rect.height());
+        let mut row_ascent = 0.0f32;
+        first_row_min_height = 0.0;
+
+        // take metrics from the highest font in this row
+        if let Some(glyph) = row
+            .glyphs
+            .iter()
+            .max_by(|a, b| a.size.y.partial_cmp(&b.size.y).unwrap())
+        {
+            row_height = glyph.size.y;
+            row_ascent = glyph.ascent;
+        }
+        row_height = point_scale.round_to_pixel(row_height);
+
+        // Now positions each glyph:
+        for glyph in &mut row.glyphs {
+            let format = &job.sections[glyph.section_index as usize].format;
+
+            let align_offset = match format.valign {
+                Align::Center | Align::Max => row_ascent,
+
+                // raised text.
+                Align::Min => glyph.ascent,
+            };
+            glyph.pos.y = cursor_y + align_offset;
+        }
+
+        row.rect.min.y = cursor_y;
+        row.rect.max.y = cursor_y + row_height;
+
+        min_x = min_x.min(row.rect.min.x);
+        max_x = max_x.max(row.rect.max.x);
+        cursor_y += row_height;
+        cursor_y = point_scale.round_to_pixel(cursor_y);
+    }
+
+    let format_summary = format_summary(&job);
+
+    let mut mesh_bounds = Rect::NOTHING;
+    let mut num_vertices = 0;
+    let mut num_indices = 0;
+
+    for row in &mut rows {
+        row.visuals = tessellate_row(point_scale, &job, &format_summary, row);
+        mesh_bounds = mesh_bounds.union(row.visuals.mesh_bounds);
+        num_vertices += row.visuals.mesh.vertices.len();
+        num_indices += row.visuals.mesh.indices.len();
+    }
+
+    let rect = Rect::from_min_max(pos2(min_x, 0.0), pos2(max_x, cursor_y));
+
+    Galley {
+        job,
+        rows,
+        rect,
+        mesh_bounds,
+        num_vertices,
+        num_indices,
+        pixels_per_point: point_scale.pixels_per_point,
+    }
+}
+
+#[derive(Default)]
+struct FormatSummary {
+    any_background: bool,
+    any_underline: bool,
+    any_strikethrough: bool,
+}
+
+fn format_summary(job: &LayoutJob) -> FormatSummary {
+    let mut format_summary = FormatSummary::default();
+    for section in &job.sections {
+        format_summary.any_background |= section.format.background != Color32::TRANSPARENT;
+        format_summary.any_underline |= section.format.underline != Stroke::NONE;
+        format_summary.any_strikethrough |= section.format.strikethrough != Stroke::NONE;
+    }
+    format_summary
+}
+
+fn tessellate_row(
+    point_scale: PointScale,
+    job: &LayoutJob,
+    format_summary: &FormatSummary,
+    row: &mut Row,
+) -> RowVisuals {
+    if row.glyphs.is_empty() {
+        return Default::default();
+    }
+
+    let mut mesh = Mesh::default();
+
+    mesh.reserve_triangles(row.glyphs.len() * 2);
+    mesh.reserve_vertices(row.glyphs.len() * 4);
+
+    if format_summary.any_background {
+        add_row_backgrounds(job, row, &mut mesh);
+    }
+
+    let glyph_vertex_start = mesh.vertices.len();
+    tessellate_glyphs(point_scale, job, row, &mut mesh);
+    let glyph_vertex_end = mesh.vertices.len();
+
+    if format_summary.any_underline {
+        add_row_hline(point_scale, row, &mut mesh, |glyph| {
+            let format = &job.sections[glyph.section_index as usize].format;
+            let stroke = format.underline;
+            let y = glyph.logical_rect().bottom();
+            (stroke, y)
+        });
+    }
+
+    if format_summary.any_strikethrough {
+        add_row_hline(point_scale, row, &mut mesh, |glyph| {
+            let format = &job.sections[glyph.section_index as usize].format;
+            let stroke = format.strikethrough;
+            let y = glyph.logical_rect().center().y;
+            (stroke, y)
+        });
+    }
+
+    let mesh_bounds = mesh.calc_bounds();
+
+    RowVisuals {
+        mesh,
+        mesh_bounds,
+        glyph_vertex_range: glyph_vertex_start..glyph_vertex_end,
+    }
+}
+
+/// Create background for glyphs that have them.
+/// Creates as few rectangular regions as possible.
+fn add_row_backgrounds(job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
+    if row.glyphs.is_empty() {
+        return;
+    }
+
+    let mut end_run = |start: Option<(Color32, Rect)>, stop_x: f32| {
+        if let Some((color, start_rect)) = start {
+            let rect = Rect::from_min_max(start_rect.left_top(), pos2(stop_x, start_rect.bottom()));
+            let rect = rect.expand(1.0); // looks better
+            mesh.add_colored_rect(rect, color);
+        }
+    };
+
+    let mut run_start = None;
+    let mut last_rect = Rect::NAN;
+
+    for glyph in &row.glyphs {
+        let format = &job.sections[glyph.section_index as usize].format;
+        let color = format.background;
+        let rect = glyph.logical_rect();
+
+        if color == Color32::TRANSPARENT {
+            end_run(run_start.take(), last_rect.right());
+        } else if let Some((existing_color, start)) = run_start {
+            if existing_color == color
+                && start.top() == rect.top()
+                && start.bottom() == rect.bottom()
+            {
+                // continue the same background rectangle
+            } else {
+                end_run(run_start.take(), last_rect.right());
+                run_start = Some((color, rect));
+            }
+        } else {
+            run_start = Some((color, rect));
+        }
+
+        last_rect = rect;
+    }
+
+    end_run(run_start.take(), last_rect.right());
+}
+
+fn tessellate_glyphs(point_scale: PointScale, job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
+    for glyph in &row.glyphs {
+        let uv_rect = glyph.uv_rect;
+        if !uv_rect.is_nothing() {
+            let mut left_top = glyph.pos + uv_rect.offset;
+            left_top.x = point_scale.round_to_pixel(left_top.x);
+            left_top.y = point_scale.round_to_pixel(left_top.y);
+
+            let rect = Rect::from_min_max(left_top, left_top + uv_rect.size);
+            let uv = Rect::from_min_max(
+                pos2(uv_rect.min[0] as f32, uv_rect.min[1] as f32),
+                pos2(uv_rect.max[0] as f32, uv_rect.max[1] as f32),
+            );
+
+            let format = &job.sections[glyph.section_index as usize].format;
+
+            let color = format.color;
+
+            if format.italics {
+                let idx = mesh.vertices.len() as u32;
+                mesh.add_triangle(idx, idx + 1, idx + 2);
+                mesh.add_triangle(idx + 2, idx + 1, idx + 3);
+
+                let top_offset = rect.height() * 0.25 * Vec2::X;
+
+                mesh.vertices.push(Vertex {
+                    pos: rect.left_top() + top_offset,
+                    uv: uv.left_top(),
+                    color,
+                });
+                mesh.vertices.push(Vertex {
+                    pos: rect.right_top() + top_offset,
+                    uv: uv.right_top(),
+                    color,
+                });
+                mesh.vertices.push(Vertex {
+                    pos: rect.left_bottom(),
+                    uv: uv.left_bottom(),
+                    color,
+                });
+                mesh.vertices.push(Vertex {
+                    pos: rect.right_bottom(),
+                    uv: uv.right_bottom(),
+                    color,
+                });
+            } else {
+                mesh.add_rect_with_uv(rect, uv, color);
+            }
+        }
+    }
+}
+
+/// Add a horizontal line over a row of glyphs with a stroke and y decided by a callback.
+fn add_row_hline(
+    point_scale: PointScale,
+    row: &Row,
+    mesh: &mut Mesh,
+    stroke_and_y: impl Fn(&Glyph) -> (Stroke, f32),
+) {
+    let mut end_line = |start: Option<(Stroke, Pos2)>, stop_x: f32| {
+        if let Some((stroke, start)) = start {
+            add_hline(point_scale, [start, pos2(stop_x, start.y)], stroke, mesh);
+        }
+    };
+
+    let mut line_start = None;
+    let mut last_right_x = f32::NAN;
+
+    for glyph in &row.glyphs {
+        let (stroke, y) = stroke_and_y(glyph);
+
+        if stroke == Stroke::NONE {
+            end_line(line_start.take(), last_right_x);
+        } else if let Some((existing_stroke, start)) = line_start {
+            if existing_stroke == stroke && start.y == y {
+                // continue the same line
+            } else {
+                end_line(line_start.take(), last_right_x);
+                line_start = Some((stroke, pos2(glyph.pos.x, y)));
+            }
+        } else {
+            line_start = Some((stroke, pos2(glyph.pos.x, y)));
+        }
+
+        last_right_x = glyph.max_x();
+    }
+
+    end_line(line_start.take(), last_right_x);
+}
+
+fn add_hline(point_scale: PointScale, [start, stop]: [Pos2; 2], stroke: Stroke, mesh: &mut Mesh) {
+    let antialiased = true;
+
+    if antialiased {
+        let mut path = crate::tessellator::Path::default(); // TODO(emilk): reuse this to avoid re-allocations.
+        path.add_line_segment([start, stop]);
+        let feathering = 1.0 / point_scale.pixels_per_point();
+        path.stroke_open(feathering, stroke, mesh);
+    } else {
+        // Thin lines often lost, so this is a bad idea
+
+        assert_eq!(start.y, stop.y);
+
+        let min_y = point_scale.round_to_pixel(start.y - 0.5 * stroke.width);
+        let max_y = point_scale.round_to_pixel(min_y + stroke.width);
+
+        let rect = Rect::from_min_max(
+            pos2(point_scale.round_to_pixel(start.x), min_y),
+            pos2(point_scale.round_to_pixel(stop.x), max_y),
+        );
+
+        mesh.add_colored_rect(rect, stroke.color);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Keeps track of good places to break a long row of text.
+/// Will focus primarily on spaces, secondarily on things like `-`
+#[derive(Clone, Copy, Default)]
+struct RowBreakCandidates {
+    /// Breaking at ` ` or other whitespace
+    /// is always the primary candidate.
+    space: Option<usize>,
+
+    /// Logograms (single character representing a whole word) or kana (Japanese hiragana and katakana) are good candidates for line break.
+    cjk: Option<usize>,
+
+    /// Breaking anywhere before a CJK character is acceptable too.
+    pre_cjk: Option<usize>,
+
+    /// Breaking at a dash is a super-
+    /// good idea.
+    dash: Option<usize>,
+
+    /// This is nicer for things like URLs, e.g. www.
+    /// example.com.
+    punctuation: Option<usize>,
+
+    /// Breaking after just random character is some
+    /// times necessary.
+    any: Option<usize>,
+}
+
+impl RowBreakCandidates {
+    fn add(&mut self, index: usize, glyphs: &[Glyph]) {
+        let chr = glyphs[0].chr;
+        const NON_BREAKING_SPACE: char = '\u{A0}';
+        if chr.is_whitespace() && chr != NON_BREAKING_SPACE {
+            self.space = Some(index);
+        } else if is_cjk(chr) && (glyphs.len() == 1 || is_cjk_break_allowed(glyphs[1].chr)) {
+            self.cjk = Some(index);
+        } else if chr == '-' {
+            self.dash = Some(index);
+        } else if chr.is_ascii_punctuation() {
+            self.punctuation = Some(index);
+        } else if glyphs.len() > 1 && is_cjk(glyphs[1].chr) {
+            self.pre_cjk = Some(index);
+        }
+        self.any = Some(index);
+    }
+
+    fn word_boundary(&self) -> Option<usize> {
+        [self.space, self.cjk, self.pre_cjk]
+            .into_iter()
+            .max()
+            .flatten()
+    }
+
+    fn has_good_candidate(&self, break_anywhere: bool) -> bool {
+        if break_anywhere {
+            self.any.is_some()
+        } else {
+            self.word_boundary().is_some()
+        }
+    }
+
+    fn get(&self, break_anywhere: bool) -> Option<usize> {
+        if break_anywhere {
+            self.any
+        } else {
+            self.word_boundary()
+                .or(self.dash)
+                .or(self.punctuation)
+                .or(self.any)
+        }
+    }
+}
+
+#[inline]
+fn is_cjk_ideograph(c: char) -> bool {
+    ('\u{4E00}' <= c && c <= '\u{9FFF}')
+        || ('\u{3400}' <= c && c <= '\u{4DBF}')
+        || ('\u{2B740}' <= c && c <= '\u{2B81F}')
+}
+
+#[inline]
+fn is_kana(c: char) -> bool {
+    ('\u{3040}' <= c && c <= '\u{309F}') // Hiragana block
+        || ('\u{30A0}' <= c && c <= '\u{30FF}') // Katakana block
+}
+
+#[inline]
+fn is_cjk(c: char) -> bool {
+    // TODO: Add support for Korean Hangul.
+    is_cjk_ideograph(c) || is_kana(c)
+}
+
+#[inline]
+fn is_cjk_break_allowed(c: char) -> bool {
+    // See: https://en.wikipedia.org/wiki/Line_breaking_rules_in_East_Asian_languages#Characters_not_permitted_on_the_start_of_a_line.
+    !")]｝〕〉》」』】〙〗〟'\"｠»ヽヾーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ々〻‐゠–〜?!‼⁇⁈⁉・、:;,。.".contains(c)
+}
+
+// ----------------------------------------------------------------------------
+
+#[test]
+fn test_zero_max_width() {
+    let mut fonts = FontsImpl::new(1.0, 1024, super::FontDefinitions::default());
+    let mut layout_job = LayoutJob::single_section("W".into(), super::TextFormat::default());
+    layout_job.wrap.max_width = 0.0;
+    let galley = super::layout(&mut fonts, layout_job.into());
+    assert_eq!(galley.rows.len(), 1);
+}
+
+#[test]
+fn test_cjk() {
+    let mut fonts = FontsImpl::new(1.0, 1024, super::FontDefinitions::default());
+    let mut layout_job = LayoutJob::single_section(
+        "日本語とEnglishの混在した文章".into(),
+        super::TextFormat::default(),
+    );
+    layout_job.wrap.max_width = 90.0;
+    let galley = super::layout(&mut fonts, layout_job.into());
+    assert_eq!(
+        galley
+            .rows
+            .iter()
+            .map(|row| row.glyphs.iter().map(|g| g.chr).collect::<String>())
+            .collect::<Vec<_>>(),
+        vec!["日本語と", "Englishの混在", "した文章"]
+    );
+}
+
+#[test]
+fn test_pre_cjk() {
+    let mut fonts = FontsImpl::new(1.0, 1024, super::FontDefinitions::default());
+    let mut layout_job = LayoutJob::single_section(
+        "日本語とEnglishの混在した文章".into(),
+        super::TextFormat::default(),
+    );
+    layout_job.wrap.max_width = 110.0;
+    let galley = super::layout(&mut fonts, layout_job.into());
+    assert_eq!(
+        galley
+            .rows
+            .iter()
+            .map(|row| row.glyphs.iter().map(|g| g.chr).collect::<String>())
+            .collect::<Vec<_>>(),
+        vec!["日本語とEnglish", "の混在した文章"]
+    );
+}
diff --git a/egui/crates/epaint/src/text/text_layout_types.rs b/egui/crates/epaint/src/text/text_layout_types.rs
new file mode 100644
index 0000000..d6d81d8
--- /dev/null
+++ b/egui/crates/epaint/src/text/text_layout_types.rs
@@ -0,0 +1,914 @@
+#![allow(clippy::derive_hash_xor_eq)] // We need to impl Hash for f32, but we don't implement Eq, which is fine
+
+use std::ops::Range;
+use std::sync::Arc;
+
+use super::{cursor::*, font::UvRect};
+use crate::{Color32, FontId, Mesh, Stroke};
+use emath::*;
+
+/// Describes the task of laying out text.
+///
+/// This supports mixing different fonts, color and formats (underline etc).
+///
+/// Pass this to [`crate::Fonts::layout_job`] or [`crate::text::layout`].
+///
+/// ## Example:
+/// ```
+/// use epaint::{Color32, text::{LayoutJob, TextFormat}, FontFamily, FontId};
+///
+/// let mut job = LayoutJob::default();
+/// job.append(
+///     "Hello ",
+///     0.0,
+///     TextFormat {
+///         font_id: FontId::new(14.0, FontFamily::Proportional),
+///         color: Color32::WHITE,
+///         ..Default::default()
+///     },
+/// );
+/// job.append(
+///     "World!",
+///     0.0,
+///     TextFormat {
+///         font_id: FontId::new(14.0, FontFamily::Monospace),
+///         color: Color32::BLACK,
+///         ..Default::default()
+///     },
+/// );
+/// ```
+///
+/// As you can see, constructing a [`LayoutJob`] is currently a lot of work.
+/// It would be nice to have a helper macro for it!
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct LayoutJob {
+    /// The complete text of this job, referenced by [`LayoutSection`].
+    pub text: String,
+
+    /// The different section, which can have different fonts, colors, etc.
+    pub sections: Vec<LayoutSection>,
+
+    pub wrap: TextWrapping,
+
+    /// The first row must be at least this high.
+    /// This is in case we lay out text that is the continuation
+    /// of some earlier text (sharing the same row),
+    /// in which case this will be the height of the earlier text.
+    /// In other cases, set this to `0.0`.
+    pub first_row_min_height: f32,
+
+    /// If `false`, all newlines characters will be ignored
+    /// and show up as the replacement character.
+    /// Default: `true`.
+    pub break_on_newline: bool,
+
+    /// How to horizontally align the text (`Align::LEFT`, `Align::Center`, `Align::RIGHT`).
+    pub halign: Align,
+
+    /// Justify text so that word-wrapped rows fill the whole [`TextWrapping::max_width`]
+    pub justify: bool,
+}
+
+impl Default for LayoutJob {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            text: Default::default(),
+            sections: Default::default(),
+            wrap: Default::default(),
+            first_row_min_height: 0.0,
+            break_on_newline: true,
+            halign: Align::LEFT,
+            justify: false,
+        }
+    }
+}
+
+impl LayoutJob {
+    /// Break on `\n` and at the given wrap width.
+    #[inline]
+    pub fn simple(text: String, font_id: FontId, color: Color32, wrap_width: f32) -> Self {
+        Self {
+            sections: vec![LayoutSection {
+                leading_space: 0.0,
+                byte_range: 0..text.len(),
+                format: TextFormat::simple(font_id, color),
+            }],
+            text,
+            wrap: TextWrapping {
+                max_width: wrap_width,
+                ..Default::default()
+            },
+            break_on_newline: true,
+            ..Default::default()
+        }
+    }
+
+    /// Does not break on `\n`, but shows the replacement character instead.
+    #[inline]
+    pub fn simple_singleline(text: String, font_id: FontId, color: Color32) -> Self {
+        Self {
+            sections: vec![LayoutSection {
+                leading_space: 0.0,
+                byte_range: 0..text.len(),
+                format: TextFormat::simple(font_id, color),
+            }],
+            text,
+            wrap: Default::default(),
+            break_on_newline: false,
+            ..Default::default()
+        }
+    }
+
+    #[inline]
+    pub fn single_section(text: String, format: TextFormat) -> Self {
+        Self {
+            sections: vec![LayoutSection {
+                leading_space: 0.0,
+                byte_range: 0..text.len(),
+                format,
+            }],
+            text,
+            wrap: Default::default(),
+            break_on_newline: true,
+            ..Default::default()
+        }
+    }
+
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.sections.is_empty()
+    }
+
+    /// Helper for adding a new section when building a [`LayoutJob`].
+    pub fn append(&mut self, text: &str, leading_space: f32, format: TextFormat) {
+        let start = self.text.len();
+        self.text += text;
+        let byte_range = start..self.text.len();
+        self.sections.push(LayoutSection {
+            leading_space,
+            byte_range,
+            format,
+        });
+    }
+
+    /// The height of the tallest used font in the job.
+    pub fn font_height(&self, fonts: &crate::Fonts) -> f32 {
+        let mut max_height = 0.0_f32;
+        for section in &self.sections {
+            max_height = max_height.max(fonts.row_height(&section.format.font_id));
+        }
+        max_height
+    }
+}
+
+impl std::hash::Hash for LayoutJob {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let Self {
+            text,
+            sections,
+            wrap,
+            first_row_min_height,
+            break_on_newline,
+            halign,
+            justify,
+        } = self;
+
+        text.hash(state);
+        sections.hash(state);
+        wrap.hash(state);
+        crate::f32_hash(state, *first_row_min_height);
+        break_on_newline.hash(state);
+        halign.hash(state);
+        justify.hash(state);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct LayoutSection {
+    /// Can be used for first row indentation.
+    pub leading_space: f32,
+    /// Range into the galley text
+    pub byte_range: Range<usize>,
+    pub format: TextFormat,
+}
+
+impl std::hash::Hash for LayoutSection {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let Self {
+            leading_space,
+            byte_range,
+            format,
+        } = self;
+        crate::f32_hash(state, *leading_space);
+        byte_range.hash(state);
+        format.hash(state);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TextFormat {
+    pub font_id: FontId,
+    /// Text color
+    pub color: Color32,
+    pub background: Color32,
+    pub italics: bool,
+    pub underline: Stroke,
+    pub strikethrough: Stroke,
+    /// If you use a small font and [`Align::TOP`] you
+    /// can get the effect of raised text.
+    pub valign: Align,
+    // TODO(emilk): lowered
+}
+
+impl Default for TextFormat {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            font_id: FontId::default(),
+            color: Color32::GRAY,
+            background: Color32::TRANSPARENT,
+            italics: false,
+            underline: Stroke::NONE,
+            strikethrough: Stroke::NONE,
+            valign: Align::BOTTOM,
+        }
+    }
+}
+
+impl TextFormat {
+    #[inline]
+    pub fn simple(font_id: FontId, color: Color32) -> Self {
+        Self {
+            font_id,
+            color,
+            ..Default::default()
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TextWrapping {
+    /// Try to break text so that no row is wider than this.
+    /// Set to [`f32::INFINITY`] to turn off wrapping.
+    /// Note that `\n` always produces a new line.
+    pub max_width: f32,
+
+    /// Maximum amount of rows the text should have.
+    /// Set to `0` to disable this.
+    pub max_rows: usize,
+
+    /// Don't try to break text at an appropriate place.
+    pub break_anywhere: bool,
+
+    /// Character to use to represent clipped text, `…` for example, which is the default.
+    pub overflow_character: Option<char>,
+}
+
+impl std::hash::Hash for TextWrapping {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let Self {
+            max_width,
+            max_rows,
+            break_anywhere,
+            overflow_character,
+        } = self;
+        crate::f32_hash(state, *max_width);
+        max_rows.hash(state);
+        break_anywhere.hash(state);
+        overflow_character.hash(state);
+    }
+}
+
+impl Default for TextWrapping {
+    fn default() -> Self {
+        Self {
+            max_width: f32::INFINITY,
+            max_rows: 0,
+            break_anywhere: false,
+            overflow_character: Some('…'),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Text that has been laid out, ready for painting.
+///
+/// You can create a [`Galley`] using [`crate::Fonts::layout_job`];
+///
+/// This needs to be recreated if `pixels_per_point` (dpi scale) changes.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Galley {
+    /// The job that this galley is the result of.
+    /// Contains the original string and style sections.
+    pub job: Arc<LayoutJob>,
+
+    /// Rows of text, from top to bottom.
+    /// The number of characters in all rows sum up to `job.text.chars().count()`.
+    /// Note that each paragraph (pieces of text separated with `\n`)
+    /// can be split up into multiple rows.
+    pub rows: Vec<Row>,
+
+    /// Bounding rect.
+    ///
+    /// `rect.top()` is always 0.0.
+    ///
+    /// With [`LayoutJob::halign`]:
+    /// * [`Align::LEFT`]: rect.left() == 0.0
+    /// * [`Align::Center`]: rect.center() == 0.0
+    /// * [`Align::RIGHT`]: rect.right() == 0.0
+    pub rect: Rect,
+
+    /// Tight bounding box around all the meshes in all the rows.
+    /// Can be used for culling.
+    pub mesh_bounds: Rect,
+
+    /// Total number of vertices in all the row meshes.
+    pub num_vertices: usize,
+
+    /// Total number of indices in all the row meshes.
+    pub num_indices: usize,
+
+    /// The number of physical pixels for each logical point.
+    /// Since this affects the layout, we keep track of it
+    /// so that we can warn if this has changed once we get to
+    /// tessellation.
+    pub pixels_per_point: f32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Row {
+    /// One for each `char`.
+    pub glyphs: Vec<Glyph>,
+
+    /// Logical bounding rectangle based on font heights etc.
+    /// Use this when drawing a selection or similar!
+    /// Includes leading and trailing whitespace.
+    pub rect: Rect,
+
+    /// The mesh, ready to be rendered.
+    pub visuals: RowVisuals,
+
+    /// If true, this [`Row`] came from a paragraph ending with a `\n`.
+    /// The `\n` itself is omitted from [`Self::glyphs`].
+    /// A `\n` in the input text always creates a new [`Row`] below it,
+    /// so that text that ends with `\n` has an empty [`Row`] last.
+    /// This also implies that the last [`Row`] in a [`Galley`] always has `ends_with_newline == false`.
+    pub ends_with_newline: bool,
+}
+
+/// The tessellated output of a row.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct RowVisuals {
+    /// The tessellated text, using non-normalized (texel) UV coordinates.
+    /// That is, you need to divide the uv coordinates by the texture size.
+    pub mesh: Mesh,
+
+    /// Bounds of the mesh, and can be used for culling.
+    /// Does NOT include leading or trailing whitespace glyphs!!
+    pub mesh_bounds: Rect,
+
+    /// The range of vertices in the mesh the contain glyphs.
+    /// Before comes backgrounds (if any), and after any underlines and strikethrough.
+    pub glyph_vertex_range: Range<usize>,
+}
+
+impl Default for RowVisuals {
+    fn default() -> Self {
+        Self {
+            mesh: Default::default(),
+            mesh_bounds: Rect::NOTHING,
+            glyph_vertex_range: 0..0,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Glyph {
+    /// The character this glyph represents.
+    pub chr: char,
+
+    /// Baseline position, relative to the galley.
+    /// Logical position: pos.y is the same for all chars of the same [`TextFormat`].
+    pub pos: Pos2,
+
+    /// `ascent` value from the font
+    pub ascent: f32,
+
+    /// Advance width and font row height.
+    pub size: Vec2,
+
+    /// Position of the glyph in the font texture, in texels.
+    pub uv_rect: UvRect,
+
+    /// Index into [`LayoutJob::sections`]. Decides color etc.
+    pub section_index: u32,
+}
+
+impl Glyph {
+    pub fn max_x(&self) -> f32 {
+        self.pos.x + self.size.x
+    }
+
+    /// Same y range for all characters with the same [`TextFormat`].
+    #[inline]
+    pub fn logical_rect(&self) -> Rect {
+        Rect::from_min_size(self.pos - vec2(0.0, self.ascent), self.size)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+impl Row {
+    /// Excludes the implicit `\n` after the [`Row`], if any.
+    #[inline]
+    pub fn char_count_excluding_newline(&self) -> usize {
+        self.glyphs.len()
+    }
+
+    /// Includes the implicit `\n` after the [`Row`], if any.
+    #[inline]
+    pub fn char_count_including_newline(&self) -> usize {
+        self.glyphs.len() + (self.ends_with_newline as usize)
+    }
+
+    #[inline]
+    pub fn min_y(&self) -> f32 {
+        self.rect.top()
+    }
+
+    #[inline]
+    pub fn max_y(&self) -> f32 {
+        self.rect.bottom()
+    }
+
+    #[inline]
+    pub fn height(&self) -> f32 {
+        self.rect.height()
+    }
+
+    /// Closest char at the desired x coordinate.
+    /// Returns something in the range `[0, char_count_excluding_newline()]`.
+    pub fn char_at(&self, desired_x: f32) -> usize {
+        for (i, glyph) in self.glyphs.iter().enumerate() {
+            if desired_x < glyph.logical_rect().center().x {
+                return i;
+            }
+        }
+        self.char_count_excluding_newline()
+    }
+
+    pub fn x_offset(&self, column: usize) -> f32 {
+        if let Some(glyph) = self.glyphs.get(column) {
+            glyph.pos.x
+        } else {
+            self.rect.right()
+        }
+    }
+}
+
+impl Galley {
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.job.is_empty()
+    }
+
+    #[inline(always)]
+    pub fn text(&self) -> &str {
+        &self.job.text
+    }
+
+    pub fn size(&self) -> Vec2 {
+        self.rect.size()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// ## Physical positions
+impl Galley {
+    /// Zero-width rect past the last character.
+    fn end_pos(&self) -> Rect {
+        if let Some(row) = self.rows.last() {
+            let x = row.rect.right();
+            Rect::from_min_max(pos2(x, row.min_y()), pos2(x, row.max_y()))
+        } else {
+            // Empty galley
+            Rect::from_min_max(pos2(0.0, 0.0), pos2(0.0, 0.0))
+        }
+    }
+
+    /// Returns a 0-width Rect.
+    pub fn pos_from_pcursor(&self, pcursor: PCursor) -> Rect {
+        let mut it = PCursor::default();
+
+        for row in &self.rows {
+            if it.paragraph == pcursor.paragraph {
+                // Right paragraph, but is it the right row in the paragraph?
+
+                if it.offset <= pcursor.offset
+                    && (pcursor.offset <= it.offset + row.char_count_excluding_newline()
+                        || row.ends_with_newline)
+                {
+                    let column = pcursor.offset - it.offset;
+
+                    let select_next_row_instead = pcursor.prefer_next_row
+                        && !row.ends_with_newline
+                        && column >= row.char_count_excluding_newline();
+                    if !select_next_row_instead {
+                        let x = row.x_offset(column);
+                        return Rect::from_min_max(pos2(x, row.min_y()), pos2(x, row.max_y()));
+                    }
+                }
+            }
+
+            if row.ends_with_newline {
+                it.paragraph += 1;
+                it.offset = 0;
+            } else {
+                it.offset += row.char_count_including_newline();
+            }
+        }
+
+        self.end_pos()
+    }
+
+    /// Returns a 0-width Rect.
+    pub fn pos_from_cursor(&self, cursor: &Cursor) -> Rect {
+        self.pos_from_pcursor(cursor.pcursor) // pcursor is what TextEdit stores
+    }
+
+    /// Cursor at the given position within the galley
+    pub fn cursor_from_pos(&self, pos: Vec2) -> Cursor {
+        let mut best_y_dist = f32::INFINITY;
+        let mut cursor = Cursor::default();
+
+        let mut ccursor_index = 0;
+        let mut pcursor_it = PCursor::default();
+
+        for (row_nr, row) in self.rows.iter().enumerate() {
+            let is_pos_within_row = pos.y >= row.min_y() && pos.y <= row.max_y();
+            let y_dist = (row.min_y() - pos.y).abs().min((row.max_y() - pos.y).abs());
+            if is_pos_within_row || y_dist < best_y_dist {
+                best_y_dist = y_dist;
+                let column = row.char_at(pos.x);
+                let prefer_next_row = column < row.char_count_excluding_newline();
+                cursor = Cursor {
+                    ccursor: CCursor {
+                        index: ccursor_index + column,
+                        prefer_next_row,
+                    },
+                    rcursor: RCursor {
+                        row: row_nr,
+                        column,
+                    },
+                    pcursor: PCursor {
+                        paragraph: pcursor_it.paragraph,
+                        offset: pcursor_it.offset + column,
+                        prefer_next_row,
+                    },
+                };
+
+                if is_pos_within_row {
+                    return cursor;
+                }
+            }
+            ccursor_index += row.char_count_including_newline();
+            if row.ends_with_newline {
+                pcursor_it.paragraph += 1;
+                pcursor_it.offset = 0;
+            } else {
+                pcursor_it.offset += row.char_count_including_newline();
+            }
+        }
+        cursor
+    }
+}
+
+/// ## Cursor positions
+impl Galley {
+    /// Cursor to one-past last character.
+    pub fn end(&self) -> Cursor {
+        if self.rows.is_empty() {
+            return Default::default();
+        }
+        let mut ccursor = CCursor {
+            index: 0,
+            prefer_next_row: true,
+        };
+        let mut pcursor = PCursor {
+            paragraph: 0,
+            offset: 0,
+            prefer_next_row: true,
+        };
+        for row in &self.rows {
+            let row_char_count = row.char_count_including_newline();
+            ccursor.index += row_char_count;
+            if row.ends_with_newline {
+                pcursor.paragraph += 1;
+                pcursor.offset = 0;
+            } else {
+                pcursor.offset += row_char_count;
+            }
+        }
+        Cursor {
+            ccursor,
+            rcursor: self.end_rcursor(),
+            pcursor,
+        }
+    }
+
+    pub fn end_rcursor(&self) -> RCursor {
+        if let Some(last_row) = self.rows.last() {
+            crate::epaint_assert!(!last_row.ends_with_newline);
+            RCursor {
+                row: self.rows.len() - 1,
+                column: last_row.char_count_excluding_newline(),
+            }
+        } else {
+            Default::default()
+        }
+    }
+}
+
+/// ## Cursor conversions
+impl Galley {
+    // The returned cursor is clamped.
+    pub fn from_ccursor(&self, ccursor: CCursor) -> Cursor {
+        let prefer_next_row = ccursor.prefer_next_row;
+        let mut ccursor_it = CCursor {
+            index: 0,
+            prefer_next_row,
+        };
+        let mut pcursor_it = PCursor {
+            paragraph: 0,
+            offset: 0,
+            prefer_next_row,
+        };
+
+        for (row_nr, row) in self.rows.iter().enumerate() {
+            let row_char_count = row.char_count_excluding_newline();
+
+            if ccursor_it.index <= ccursor.index
+                && ccursor.index <= ccursor_it.index + row_char_count
+            {
+                let column = ccursor.index - ccursor_it.index;
+
+                let select_next_row_instead = prefer_next_row
+                    && !row.ends_with_newline
+                    && column >= row.char_count_excluding_newline();
+                if !select_next_row_instead {
+                    pcursor_it.offset += column;
+                    return Cursor {
+                        ccursor,
+                        rcursor: RCursor {
+                            row: row_nr,
+                            column,
+                        },
+                        pcursor: pcursor_it,
+                    };
+                }
+            }
+            ccursor_it.index += row.char_count_including_newline();
+            if row.ends_with_newline {
+                pcursor_it.paragraph += 1;
+                pcursor_it.offset = 0;
+            } else {
+                pcursor_it.offset += row.char_count_including_newline();
+            }
+        }
+        crate::epaint_assert!(ccursor_it == self.end().ccursor);
+        Cursor {
+            ccursor: ccursor_it, // clamp
+            rcursor: self.end_rcursor(),
+            pcursor: pcursor_it,
+        }
+    }
+
+    pub fn from_rcursor(&self, rcursor: RCursor) -> Cursor {
+        if rcursor.row >= self.rows.len() {
+            return self.end();
+        }
+
+        let prefer_next_row =
+            rcursor.column < self.rows[rcursor.row].char_count_excluding_newline();
+        let mut ccursor_it = CCursor {
+            index: 0,
+            prefer_next_row,
+        };
+        let mut pcursor_it = PCursor {
+            paragraph: 0,
+            offset: 0,
+            prefer_next_row,
+        };
+
+        for (row_nr, row) in self.rows.iter().enumerate() {
+            if row_nr == rcursor.row {
+                ccursor_it.index += rcursor.column.at_most(row.char_count_excluding_newline());
+
+                if row.ends_with_newline {
+                    // Allow offset to go beyond the end of the paragraph
+                    pcursor_it.offset += rcursor.column;
+                } else {
+                    pcursor_it.offset += rcursor.column.at_most(row.char_count_excluding_newline());
+                }
+                return Cursor {
+                    ccursor: ccursor_it,
+                    rcursor,
+                    pcursor: pcursor_it,
+                };
+            }
+            ccursor_it.index += row.char_count_including_newline();
+            if row.ends_with_newline {
+                pcursor_it.paragraph += 1;
+                pcursor_it.offset = 0;
+            } else {
+                pcursor_it.offset += row.char_count_including_newline();
+            }
+        }
+        Cursor {
+            ccursor: ccursor_it,
+            rcursor: self.end_rcursor(),
+            pcursor: pcursor_it,
+        }
+    }
+
+    // TODO(emilk): return identical cursor, or clamp?
+    pub fn from_pcursor(&self, pcursor: PCursor) -> Cursor {
+        let prefer_next_row = pcursor.prefer_next_row;
+        let mut ccursor_it = CCursor {
+            index: 0,
+            prefer_next_row,
+        };
+        let mut pcursor_it = PCursor {
+            paragraph: 0,
+            offset: 0,
+            prefer_next_row,
+        };
+
+        for (row_nr, row) in self.rows.iter().enumerate() {
+            if pcursor_it.paragraph == pcursor.paragraph {
+                // Right paragraph, but is it the right row in the paragraph?
+
+                if pcursor_it.offset <= pcursor.offset
+                    && (pcursor.offset <= pcursor_it.offset + row.char_count_excluding_newline()
+                        || row.ends_with_newline)
+                {
+                    let column = pcursor.offset - pcursor_it.offset;
+
+                    let select_next_row_instead = pcursor.prefer_next_row
+                        && !row.ends_with_newline
+                        && column >= row.char_count_excluding_newline();
+
+                    if !select_next_row_instead {
+                        ccursor_it.index += column.at_most(row.char_count_excluding_newline());
+
+                        return Cursor {
+                            ccursor: ccursor_it,
+                            rcursor: RCursor {
+                                row: row_nr,
+                                column,
+                            },
+                            pcursor,
+                        };
+                    }
+                }
+            }
+
+            ccursor_it.index += row.char_count_including_newline();
+            if row.ends_with_newline {
+                pcursor_it.paragraph += 1;
+                pcursor_it.offset = 0;
+            } else {
+                pcursor_it.offset += row.char_count_including_newline();
+            }
+        }
+        Cursor {
+            ccursor: ccursor_it,
+            rcursor: self.end_rcursor(),
+            pcursor,
+        }
+    }
+}
+
+/// ## Cursor positions
+impl Galley {
+    pub fn cursor_left_one_character(&self, cursor: &Cursor) -> Cursor {
+        if cursor.ccursor.index == 0 {
+            Default::default()
+        } else {
+            let ccursor = CCursor {
+                index: cursor.ccursor.index,
+                prefer_next_row: true, // default to this when navigating. It is more often useful to put cursor at the begging of a row than at the end.
+            };
+            self.from_ccursor(ccursor - 1)
+        }
+    }
+
+    pub fn cursor_right_one_character(&self, cursor: &Cursor) -> Cursor {
+        let ccursor = CCursor {
+            index: cursor.ccursor.index,
+            prefer_next_row: true, // default to this when navigating. It is more often useful to put cursor at the begging of a row than at the end.
+        };
+        self.from_ccursor(ccursor + 1)
+    }
+
+    pub fn cursor_up_one_row(&self, cursor: &Cursor) -> Cursor {
+        if cursor.rcursor.row == 0 {
+            Cursor::default()
+        } else {
+            let new_row = cursor.rcursor.row - 1;
+
+            let cursor_is_beyond_end_of_current_row = cursor.rcursor.column
+                >= self.rows[cursor.rcursor.row].char_count_excluding_newline();
+
+            let new_rcursor = if cursor_is_beyond_end_of_current_row {
+                // keep same column
+                RCursor {
+                    row: new_row,
+                    column: cursor.rcursor.column,
+                }
+            } else {
+                // keep same X coord
+                let x = self.pos_from_cursor(cursor).center().x;
+                let column = if x > self.rows[new_row].rect.right() {
+                    // beyond the end of this row - keep same column
+                    cursor.rcursor.column
+                } else {
+                    self.rows[new_row].char_at(x)
+                };
+                RCursor {
+                    row: new_row,
+                    column,
+                }
+            };
+            self.from_rcursor(new_rcursor)
+        }
+    }
+
+    pub fn cursor_down_one_row(&self, cursor: &Cursor) -> Cursor {
+        if cursor.rcursor.row + 1 < self.rows.len() {
+            let new_row = cursor.rcursor.row + 1;
+
+            let cursor_is_beyond_end_of_current_row = cursor.rcursor.column
+                >= self.rows[cursor.rcursor.row].char_count_excluding_newline();
+
+            let new_rcursor = if cursor_is_beyond_end_of_current_row {
+                // keep same column
+                RCursor {
+                    row: new_row,
+                    column: cursor.rcursor.column,
+                }
+            } else {
+                // keep same X coord
+                let x = self.pos_from_cursor(cursor).center().x;
+                let column = if x > self.rows[new_row].rect.right() {
+                    // beyond the end of the next row - keep same column
+                    cursor.rcursor.column
+                } else {
+                    self.rows[new_row].char_at(x)
+                };
+                RCursor {
+                    row: new_row,
+                    column,
+                }
+            };
+
+            self.from_rcursor(new_rcursor)
+        } else {
+            self.end()
+        }
+    }
+
+    pub fn cursor_begin_of_row(&self, cursor: &Cursor) -> Cursor {
+        self.from_rcursor(RCursor {
+            row: cursor.rcursor.row,
+            column: 0,
+        })
+    }
+
+    pub fn cursor_end_of_row(&self, cursor: &Cursor) -> Cursor {
+        self.from_rcursor(RCursor {
+            row: cursor.rcursor.row,
+            column: self.rows[cursor.rcursor.row].char_count_excluding_newline(),
+        })
+    }
+}
diff --git a/egui/crates/epaint/src/texture_atlas.rs b/egui/crates/epaint/src/texture_atlas.rs
new file mode 100644
index 0000000..d83a089
--- /dev/null
+++ b/egui/crates/epaint/src/texture_atlas.rs
@@ -0,0 +1,252 @@
+use emath::{remap_clamp, Rect};
+
+use crate::{FontImage, ImageDelta};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Rectu {
+    /// inclusive
+    min_x: usize,
+
+    /// inclusive
+    min_y: usize,
+
+    /// exclusive
+    max_x: usize,
+
+    /// exclusive
+    max_y: usize,
+}
+
+impl Rectu {
+    const NOTHING: Self = Self {
+        min_x: usize::MAX,
+        min_y: usize::MAX,
+        max_x: 0,
+        max_y: 0,
+    };
+    const EVERYTHING: Self = Self {
+        min_x: 0,
+        min_y: 0,
+        max_x: usize::MAX,
+        max_y: usize::MAX,
+    };
+}
+
+#[derive(Copy, Clone, Debug)]
+struct PrerasterizedDisc {
+    r: f32,
+    uv: Rectu,
+}
+
+/// A pre-rasterized disc (filled circle), somewhere in the texture atlas.
+#[derive(Copy, Clone, Debug)]
+pub struct PreparedDisc {
+    /// The radius of this disc in texels.
+    pub r: f32,
+
+    /// Width in texels.
+    pub w: f32,
+
+    /// Where in the texture atlas the disc is.
+    /// Normalized in 0-1 range.
+    pub uv: Rect,
+}
+
+/// Contains font data in an atlas, where each character occupied a small rectangle.
+///
+/// More characters can be added, possibly expanding the texture.
+#[derive(Clone)]
+pub struct TextureAtlas {
+    image: FontImage,
+
+    /// What part of the image that is dirty
+    dirty: Rectu,
+
+    /// Used for when allocating new rectangles.
+    cursor: (usize, usize),
+
+    row_height: usize,
+
+    /// Set when someone requested more space than was available.
+    overflowed: bool,
+
+    /// pre-rasterized discs of radii `2^i`, where `i` is the index.
+    discs: Vec<PrerasterizedDisc>,
+}
+
+impl TextureAtlas {
+    pub fn new(size: [usize; 2]) -> Self {
+        assert!(size[0] >= 1024, "Tiny texture atlas");
+        let mut atlas = Self {
+            image: FontImage::new(size),
+            dirty: Rectu::EVERYTHING,
+            cursor: (0, 0),
+            row_height: 0,
+            overflowed: false,
+            discs: vec![], // will be filled in below
+        };
+
+        // Make the top left pixel fully white for `WHITE_UV`, i.e. painting something with solid color:
+        let (pos, image) = atlas.allocate((1, 1));
+        assert_eq!(pos, (0, 0));
+        image[pos] = 1.0;
+
+        // Allocate a series of anti-aliased discs used to render small filled circles:
+        // TODO(emilk): these circles can be packed A LOT better.
+        // In fact, the whole texture atlas could be packed a lot better.
+        // for r in [1, 2, 4, 8, 16, 32, 64] {
+        //     let w = 2 * r + 3;
+        //     let hw = w as i32 / 2;
+        const LARGEST_CIRCLE_RADIUS: f32 = 64.0;
+        for i in 0.. {
+            let r = 2.0_f32.powf(i as f32 / 2.0 - 1.0);
+            if r > LARGEST_CIRCLE_RADIUS {
+                break;
+            }
+            let hw = (r + 0.5).ceil() as i32;
+            let w = (2 * hw + 1) as usize;
+            let ((x, y), image) = atlas.allocate((w, w));
+            for dx in -hw..=hw {
+                for dy in -hw..=hw {
+                    let distance_to_center = ((dx * dx + dy * dy) as f32).sqrt();
+                    let coverage =
+                        remap_clamp(distance_to_center, (r - 0.5)..=(r + 0.5), 1.0..=0.0);
+                    image[((x as i32 + hw + dx) as usize, (y as i32 + hw + dy) as usize)] =
+                        coverage;
+                }
+            }
+            atlas.discs.push(PrerasterizedDisc {
+                r,
+                uv: Rectu {
+                    min_x: x,
+                    min_y: y,
+                    max_x: x + w,
+                    max_y: y + w,
+                },
+            });
+        }
+
+        atlas
+    }
+
+    pub fn size(&self) -> [usize; 2] {
+        self.image.size
+    }
+
+    /// Returns the locations and sizes of pre-rasterized discs (filled circles) in this atlas.
+    pub fn prepared_discs(&self) -> Vec<PreparedDisc> {
+        let size = self.size();
+        let inv_w = 1.0 / size[0] as f32;
+        let inv_h = 1.0 / size[1] as f32;
+        self.discs
+            .iter()
+            .map(|disc| {
+                let r = disc.r;
+                let Rectu {
+                    min_x,
+                    min_y,
+                    max_x,
+                    max_y,
+                } = disc.uv;
+                let w = max_x - min_x;
+                let uv = Rect::from_min_max(
+                    emath::pos2(min_x as f32 * inv_w, min_y as f32 * inv_h),
+                    emath::pos2(max_x as f32 * inv_w, max_y as f32 * inv_h),
+                );
+                PreparedDisc { r, w: w as f32, uv }
+            })
+            .collect()
+    }
+
+    fn max_height(&self) -> usize {
+        // the initial width is likely the max texture side size
+        self.image.width()
+    }
+
+    /// When this get high, it might be time to clear and start over!
+    pub fn fill_ratio(&self) -> f32 {
+        if self.overflowed {
+            1.0
+        } else {
+            (self.cursor.1 + self.row_height) as f32 / self.max_height() as f32
+        }
+    }
+
+    /// Call to get the change to the image since last call.
+    pub fn take_delta(&mut self) -> Option<ImageDelta> {
+        let texture_options = crate::textures::TextureOptions::LINEAR;
+
+        let dirty = std::mem::replace(&mut self.dirty, Rectu::NOTHING);
+        if dirty == Rectu::NOTHING {
+            None
+        } else if dirty == Rectu::EVERYTHING {
+            Some(ImageDelta::full(self.image.clone(), texture_options))
+        } else {
+            let pos = [dirty.min_x, dirty.min_y];
+            let size = [dirty.max_x - dirty.min_x, dirty.max_y - dirty.min_y];
+            let region = self.image.region(pos, size);
+            Some(ImageDelta::partial(pos, region, texture_options))
+        }
+    }
+
+    /// Returns the coordinates of where the rect ended up,
+    /// and invalidates the region.
+    pub fn allocate(&mut self, (w, h): (usize, usize)) -> ((usize, usize), &mut FontImage) {
+        /// On some low-precision GPUs (my old iPad) characters get muddled up
+        /// if we don't add some empty pixels between the characters.
+        /// On modern high-precision GPUs this is not needed.
+        const PADDING: usize = 1;
+
+        assert!(
+            w <= self.image.width(),
+            "Tried to allocate a {} wide glyph in a {} wide texture atlas",
+            w,
+            self.image.width()
+        );
+        if self.cursor.0 + w > self.image.width() {
+            // New row:
+            self.cursor.0 = 0;
+            self.cursor.1 += self.row_height + PADDING;
+            self.row_height = 0;
+        }
+
+        self.row_height = self.row_height.max(h);
+
+        let required_height = self.cursor.1 + self.row_height;
+
+        if required_height > self.max_height() {
+            // This is a bad place to be - we need to start reusing space :/
+
+            #[cfg(feature = "tracing")]
+            tracing::wan!("epaint texture atlas overflowed!");
+
+            self.cursor = (0, self.image.height() / 3); // Restart a bit down - the top of the atlas has too many important things in it
+            self.overflowed = true; // this will signal the user that we need to recreate the texture atlas next frame.
+        } else if resize_to_min_height(&mut self.image, required_height) {
+            self.dirty = Rectu::EVERYTHING;
+        }
+
+        let pos = self.cursor;
+        self.cursor.0 += w + PADDING;
+
+        self.dirty.min_x = self.dirty.min_x.min(pos.0);
+        self.dirty.min_y = self.dirty.min_y.min(pos.1);
+        self.dirty.max_x = self.dirty.max_x.max(pos.0 + w);
+        self.dirty.max_y = self.dirty.max_y.max(pos.1 + h);
+
+        (pos, &mut self.image)
+    }
+}
+
+fn resize_to_min_height(image: &mut FontImage, required_height: usize) -> bool {
+    while required_height >= image.height() {
+        image.size[1] *= 2; // double the height
+    }
+
+    if image.width() * image.height() > image.pixels.len() {
+        image.pixels.resize(image.width() * image.height(), 0.0);
+        true
+    } else {
+        false
+    }
+}
diff --git a/egui/crates/epaint/src/texture_handle.rs b/egui/crates/epaint/src/texture_handle.rs
new file mode 100644
index 0000000..d612b88
--- /dev/null
+++ b/egui/crates/epaint/src/texture_handle.rs
@@ -0,0 +1,122 @@
+use std::sync::Arc;
+
+use crate::{
+    emath::NumExt, mutex::RwLock, textures::TextureOptions, ImageData, ImageDelta, TextureId,
+    TextureManager,
+};
+
+/// Used to paint images.
+///
+/// An _image_ is pixels stored in RAM, and represented using [`ImageData`].
+/// Before you can paint it however, you need to convert it to a _texture_.
+///
+/// If you are using egui, use `egui::Context::load_texture`.
+///
+/// The [`TextureHandle`] can be cloned cheaply.
+/// When the last [`TextureHandle`] for specific texture is dropped, the texture is freed.
+///
+/// See also [`TextureManager`].
+#[must_use]
+pub struct TextureHandle {
+    tex_mngr: Arc<RwLock<TextureManager>>,
+    id: TextureId,
+}
+
+impl Drop for TextureHandle {
+    fn drop(&mut self) {
+        self.tex_mngr.write().free(self.id);
+    }
+}
+
+impl Clone for TextureHandle {
+    fn clone(&self) -> Self {
+        self.tex_mngr.write().retain(self.id);
+        Self {
+            tex_mngr: self.tex_mngr.clone(),
+            id: self.id,
+        }
+    }
+}
+
+impl PartialEq for TextureHandle {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl Eq for TextureHandle {}
+
+impl std::hash::Hash for TextureHandle {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
+impl TextureHandle {
+    /// If you are using egui, use `egui::Context::load_texture` instead.
+    pub fn new(tex_mngr: Arc<RwLock<TextureManager>>, id: TextureId) -> Self {
+        Self { tex_mngr, id }
+    }
+
+    #[inline]
+    pub fn id(&self) -> TextureId {
+        self.id
+    }
+
+    /// Assign a new image to an existing texture.
+    pub fn set(&mut self, image: impl Into<ImageData>, options: TextureOptions) {
+        self.tex_mngr
+            .write()
+            .set(self.id, ImageDelta::full(image.into(), options));
+    }
+
+    /// Assign a new image to a subregion of the whole texture.
+    pub fn set_partial(
+        &mut self,
+        pos: [usize; 2],
+        image: impl Into<ImageData>,
+        options: TextureOptions,
+    ) {
+        self.tex_mngr
+            .write()
+            .set(self.id, ImageDelta::partial(pos, image.into(), options));
+    }
+
+    /// width x height
+    pub fn size(&self) -> [usize; 2] {
+        self.tex_mngr.read().meta(self.id).unwrap().size
+    }
+
+    /// width x height
+    pub fn size_vec2(&self) -> crate::Vec2 {
+        let [w, h] = self.size();
+        crate::Vec2::new(w as f32, h as f32)
+    }
+
+    /// width / height
+    pub fn aspect_ratio(&self) -> f32 {
+        let [w, h] = self.size();
+        w as f32 / h.at_least(1) as f32
+    }
+
+    /// Debug-name.
+    pub fn name(&self) -> String {
+        self.tex_mngr.read().meta(self.id).unwrap().name.clone()
+    }
+}
+
+impl From<&TextureHandle> for TextureId {
+    #[inline(always)]
+    fn from(handle: &TextureHandle) -> Self {
+        handle.id()
+    }
+}
+
+impl From<&mut TextureHandle> for TextureId {
+    #[inline(always)]
+    fn from(handle: &mut TextureHandle) -> Self {
+        handle.id()
+    }
+}
diff --git a/egui/crates/epaint/src/textures.rs b/egui/crates/epaint/src/textures.rs
new file mode 100644
index 0000000..e6b4237
--- /dev/null
+++ b/egui/crates/epaint/src/textures.rs
@@ -0,0 +1,257 @@
+use crate::{ImageData, ImageDelta, TextureId};
+
+// ----------------------------------------------------------------------------
+
+/// Low-level manager for allocating textures.
+///
+/// Communicates with the painting subsystem using [`Self::take_delta`].
+#[derive(Default)]
+pub struct TextureManager {
+    /// We allocate texture id:s linearly.
+    next_id: u64,
+    /// Information about currently allocated textures.
+    metas: ahash::HashMap<TextureId, TextureMeta>,
+    delta: TexturesDelta,
+}
+
+impl TextureManager {
+    /// Allocate a new texture.
+    ///
+    /// The given name can be useful for later debugging.
+    ///
+    /// The returned [`TextureId`] will be [`TextureId::Managed`], with an index
+    /// starting from zero and increasing with each call to [`Self::alloc`].
+    ///
+    /// The first texture you allocate will be `TextureId::Managed(0) == TextureId::default()` and
+    /// MUST have a white pixel at (0,0) ([`crate::WHITE_UV`]).
+    ///
+    /// The texture is given a retain-count of `1`, requiring one call to [`Self::free`] to free it.
+    pub fn alloc(&mut self, name: String, image: ImageData, options: TextureOptions) -> TextureId {
+        let id = TextureId::Managed(self.next_id);
+        self.next_id += 1;
+
+        self.metas.entry(id).or_insert_with(|| TextureMeta {
+            name,
+            size: image.size(),
+            bytes_per_pixel: image.bytes_per_pixel(),
+            retain_count: 1,
+            options,
+        });
+
+        self.delta.set.push((id, ImageDelta::full(image, options)));
+        id
+    }
+
+    /// Assign a new image to an existing texture,
+    /// or update a region of it.
+    pub fn set(&mut self, id: TextureId, delta: ImageDelta) {
+        if let Some(meta) = self.metas.get_mut(&id) {
+            if let Some(pos) = delta.pos {
+                crate::epaint_assert!(
+                    pos[0] + delta.image.width() <= meta.size[0]
+                        && pos[1] + delta.image.height() <= meta.size[1],
+                    "Partial texture update is outside the bounds of texture {id:?}",
+                );
+            } else {
+                // whole update
+                meta.size = delta.image.size();
+                meta.bytes_per_pixel = delta.image.bytes_per_pixel();
+                // since we update the whole image, we can discard all old enqueued deltas
+                self.delta.set.retain(|(x, _)| x != &id);
+            }
+            self.delta.set.push((id, delta));
+        } else {
+            crate::epaint_assert!(false, "Tried setting texture {id:?} which is not allocated");
+        }
+    }
+
+    /// Free an existing texture.
+    pub fn free(&mut self, id: TextureId) {
+        if let std::collections::hash_map::Entry::Occupied(mut entry) = self.metas.entry(id) {
+            let meta = entry.get_mut();
+            meta.retain_count -= 1;
+            if meta.retain_count == 0 {
+                entry.remove();
+                self.delta.free.push(id);
+            }
+        } else {
+            crate::epaint_assert!(false, "Tried freeing texture {id:?} which is not allocated");
+        }
+    }
+
+    /// Increase the retain-count of the given texture.
+    ///
+    /// For each time you call [`Self::retain`] you must call [`Self::free`] on additional time.
+    pub fn retain(&mut self, id: TextureId) {
+        if let Some(meta) = self.metas.get_mut(&id) {
+            meta.retain_count += 1;
+        } else {
+            crate::epaint_assert!(
+                false,
+                "Tried retaining texture {id:?} which is not allocated",
+            );
+        }
+    }
+
+    /// Take and reset changes since last frame.
+    ///
+    /// These should be applied to the painting subsystem each frame.
+    pub fn take_delta(&mut self) -> TexturesDelta {
+        std::mem::take(&mut self.delta)
+    }
+
+    /// Get meta-data about a specific texture.
+    pub fn meta(&self, id: TextureId) -> Option<&TextureMeta> {
+        self.metas.get(&id)
+    }
+
+    /// Get meta-data about all allocated textures in some arbitrary order.
+    pub fn allocated(&self) -> impl ExactSizeIterator<Item = (&TextureId, &TextureMeta)> {
+        self.metas.iter()
+    }
+
+    /// Total number of allocated textures.
+    pub fn num_allocated(&self) -> usize {
+        self.metas.len()
+    }
+}
+
+/// Meta-data about an allocated texture.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TextureMeta {
+    /// A human-readable name useful for debugging.
+    pub name: String,
+
+    /// width x height
+    pub size: [usize; 2],
+
+    /// 4 or 1
+    pub bytes_per_pixel: usize,
+
+    /// Free when this reaches zero.
+    pub retain_count: usize,
+
+    /// The texture filtering mode to use when rendering.
+    pub options: TextureOptions,
+}
+
+impl TextureMeta {
+    /// Size in bytes.
+    /// width x height x [`Self::bytes_per_pixel`].
+    pub fn bytes_used(&self) -> usize {
+        self.size[0] * self.size[1] * self.bytes_per_pixel
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// How the texture texels are filtered.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct TextureOptions {
+    /// How to filter when magnifying (when texels are larger than pixels).
+    pub magnification: TextureFilter,
+
+    /// How to filter when minifying (when texels are smaller than pixels).
+    pub minification: TextureFilter,
+}
+
+impl TextureOptions {
+    /// Linear magnification and minification.
+    pub const LINEAR: Self = Self {
+        magnification: TextureFilter::Linear,
+        minification: TextureFilter::Linear,
+    };
+
+    /// Nearest magnification and minification.
+    pub const NEAREST: Self = Self {
+        magnification: TextureFilter::Nearest,
+        minification: TextureFilter::Nearest,
+    };
+}
+
+impl Default for TextureOptions {
+    /// The default is linear for both magnification and minification.
+    fn default() -> Self {
+        Self::LINEAR
+    }
+}
+
+/// How the texture texels are filtered.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum TextureFilter {
+    /// Show the nearest pixel value.
+    ///
+    /// When zooming in you will get sharp, square pixels/texels.
+    /// When zooming out you will get a very crisp (and aliased) look.
+    Nearest,
+
+    /// Linearly interpolate the nearest neighbors, creating a smoother look when zooming in and out.
+    Linear,
+}
+
+// ----------------------------------------------------------------------------
+
+/// What has been allocated and freed during the last period.
+///
+/// These are commands given to the integration painter.
+#[derive(Clone, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[must_use = "The painter must take care of this"]
+pub struct TexturesDelta {
+    /// New or changed textures. Apply before painting.
+    pub set: Vec<(TextureId, ImageDelta)>,
+
+    /// Textures to free after painting.
+    pub free: Vec<TextureId>,
+}
+
+impl TexturesDelta {
+    pub fn is_empty(&self) -> bool {
+        self.set.is_empty() && self.free.is_empty()
+    }
+
+    pub fn append(&mut self, mut newer: TexturesDelta) {
+        self.set.extend(newer.set.into_iter());
+        self.free.append(&mut newer.free);
+    }
+
+    pub fn clear(&mut self) {
+        self.set.clear();
+        self.free.clear();
+    }
+}
+
+impl std::fmt::Debug for TexturesDelta {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use std::fmt::Write as _;
+
+        let mut debug_struct = f.debug_struct("TexturesDelta");
+        if !self.set.is_empty() {
+            let mut string = String::new();
+            for (tex_id, delta) in &self.set {
+                let size = delta.image.size();
+                if let Some(pos) = delta.pos {
+                    write!(
+                        string,
+                        "{:?} partial ([{} {}] - [{} {}]), ",
+                        tex_id,
+                        pos[0],
+                        pos[1],
+                        pos[0] + size[0],
+                        pos[1] + size[1]
+                    )
+                    .ok();
+                } else {
+                    write!(string, "{:?} full {}x{}, ", tex_id, size[0], size[1]).ok();
+                }
+            }
+            debug_struct.field("set", &string);
+        }
+        if !self.free.is_empty() {
+            debug_struct.field("free", &self.free);
+        }
+        debug_struct.finish()
+    }
+}
diff --git a/egui/crates/epaint/src/util/mod.rs b/egui/crates/epaint/src/util/mod.rs
new file mode 100644
index 0000000..2aa70ee
--- /dev/null
+++ b/egui/crates/epaint/src/util/mod.rs
@@ -0,0 +1,16 @@
+mod ordered_float;
+
+pub use ordered_float::*;
+
+/// Hash the given value with a predictable hasher.
+#[inline]
+pub fn hash(value: impl std::hash::Hash) -> u64 {
+    ahash::RandomState::with_seeds(1, 2, 3, 4).hash_one(value)
+}
+
+/// Hash the given value with the given hasher.
+#[inline]
+pub fn hash_with(value: impl std::hash::Hash, mut hasher: impl std::hash::Hasher) -> u64 {
+    value.hash(&mut hasher);
+    hasher.finish()
+}
diff --git a/egui/crates/epaint/src/util/ordered_float.rs b/egui/crates/epaint/src/util/ordered_float.rs
new file mode 100644
index 0000000..1bef308
--- /dev/null
+++ b/egui/crates/epaint/src/util/ordered_float.rs
@@ -0,0 +1,130 @@
+//! Total order on floating point types.
+//! Can be used for sorting, min/max computation, and other collection algorithms.
+
+use std::cmp::Ordering;
+use std::hash::{Hash, Hasher};
+
+/// Wraps a floating-point value to add total order and hash.
+/// Possible types for `T` are `f32` and `f64`.
+///
+/// See also [`FloatOrd`].
+pub struct OrderedFloat<T>(T);
+
+impl<T: Float> Eq for OrderedFloat<T> {}
+
+impl<T: Float> PartialEq<Self> for OrderedFloat<T> {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        // NaNs are considered equal (equivalent) when it comes to ordering
+        if self.0.is_nan() {
+            other.0.is_nan()
+        } else {
+            self.0 == other.0
+        }
+    }
+}
+
+impl<T: Float> PartialOrd<Self> for OrderedFloat<T> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match self.0.partial_cmp(&other.0) {
+            Some(ord) => Some(ord),
+            None => Some(self.0.is_nan().cmp(&other.0.is_nan())),
+        }
+    }
+}
+
+impl<T: Float> Ord for OrderedFloat<T> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.partial_cmp(other) {
+            Some(ord) => ord,
+            None => unreachable!(),
+        }
+    }
+}
+
+impl<T: Float> Hash for OrderedFloat<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Extension trait to provide `ord()` method.
+///
+/// Example with `f64`:
+/// ```
+/// use epaint::util::FloatOrd;
+///
+/// let array = [1.0, 2.5, 2.0];
+/// let max = array.iter().max_by_key(|val| val.ord());
+///
+/// assert_eq!(max, Some(&2.5));
+/// ```
+pub trait FloatOrd {
+    /// Type to provide total order, useful as key in sorted contexts.
+    fn ord(self) -> OrderedFloat<Self>
+    where
+        Self: Sized;
+}
+
+impl FloatOrd for f32 {
+    #[inline]
+    fn ord(self) -> OrderedFloat<f32> {
+        OrderedFloat(self)
+    }
+}
+
+impl FloatOrd for f64 {
+    #[inline]
+    fn ord(self) -> OrderedFloat<f64> {
+        OrderedFloat(self)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Internal abstraction over floating point types
+#[doc(hidden)]
+pub trait Float: PartialOrd + PartialEq + private::FloatImpl {}
+
+impl Float for f32 {}
+
+impl Float for f64 {}
+
+// Keep this trait in private module, to avoid exposing its methods as extensions in user code
+mod private {
+    use super::*;
+
+    pub trait FloatImpl {
+        fn is_nan(&self) -> bool;
+
+        fn hash<H: Hasher>(&self, state: &mut H);
+    }
+
+    impl FloatImpl for f32 {
+        #[inline]
+        fn is_nan(&self) -> bool {
+            f32::is_nan(*self)
+        }
+
+        #[inline]
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            crate::f32_hash(state, *self);
+        }
+    }
+
+    impl FloatImpl for f64 {
+        #[inline]
+        fn is_nan(&self) -> bool {
+            f64::is_nan(*self)
+        }
+
+        #[inline]
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            crate::f64_hash(state, *self);
+        }
+    }
+}
diff --git a/egui/deny.toml b/egui/deny.toml
new file mode 100644
index 0000000..3d65034
--- /dev/null
+++ b/egui/deny.toml
@@ -0,0 +1,89 @@
+# https://embarkstudios.github.io/cargo-deny/
+
+# Note: running just `cargo deny check` without a `--target` can result in
+# false positives due to https://github.com/EmbarkStudios/cargo-deny/issues/324
+targets = [
+    { triple = "aarch64-apple-darwin" },
+    { triple = "i686-pc-windows-gnu" },
+    { triple = "i686-pc-windows-msvc" },
+    { triple = "i686-unknown-linux-gnu" },
+    { triple = "wasm32-unknown-unknown" },
+    { triple = "x86_64-apple-darwin" },
+    { triple = "x86_64-pc-windows-gnu" },
+    { triple = "x86_64-pc-windows-msvc" },
+    { triple = "x86_64-unknown-linux-gnu" },
+    { triple = "x86_64-unknown-linux-musl" },
+    { triple = "x86_64-unknown-redox" },
+]
+
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+yanked = "deny"
+ignore = [
+    "RUSTSEC-2020-0071", # https://rustsec.org/advisories/RUSTSEC-2020-0071 - chrono/time: Potential segfault in the time crate
+    "RUSTSEC-2020-0159", # https://rustsec.org/advisories/RUSTSEC-2020-0159 - chrono/time: Potential segfault in localtime_r invocations
+    "RUSTSEC-2021-0127", # https://rustsec.org/advisories/RUSTSEC-2021-0127 - https://github.com/bheisler/criterion.rs/issues/534
+]
+
+[bans]
+multiple-versions = "deny"
+wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+deny = [
+    { name = "cmake" },       # Lord no
+    { name = "openssl-sys" }, # prefer rustls
+    { name = "openssl" },     # prefer rustls
+]
+
+skip = [
+    { name = "ahash" },               # old version via dark-light
+    { name = "arrayvec" },            # old version via tiny-skiaz
+    { name = "hashbrown" },           # old version via dark-light
+    { name = "nix" },                 # old version via winit
+    { name = "redox_syscall" },       # old version via winit
+    { name = "time" },                # old version pulled in by unmaintianed crate 'chrono'
+    { name = "tiny-skia" },           # winit uses a different version from egui_extras (TODO(emilk): update egui_extras!)
+    { name = "ttf-parser" },          # different versions pulled in by ab_glyph and usvg
+    { name = "wayland-sys" },         # old version via winit
+    { name = "windows_x86_64_msvc" }, # old version via glutin
+    { name = "windows-sys" },         # old version via glutin
+    { name = "windows" },             # old version via accesskit
+]
+skip-tree = [
+    { name = "criterion" },     # dev-dependency
+    { name = "darling" },       # old version via tts
+    { name = "foreign-types" }, # old version from wgpu
+    { name = "rfd" },           # example dependency
+]
+
+
+[licenses]
+unlicensed = "deny"
+allow-osi-fsf-free = "neither"
+confidence-threshold = 0.92 # We want really high confidence when inferring licenses from text
+copyleft = "deny"
+allow = [
+    "Apache-2.0",         # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
+    "BSD-2-Clause",       # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
+    "BSD-3-Clause",       # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
+    "BSL-1.0",            # https://tldrlegal.com/license/boost-software-license-1.0-explained
+    "CC0-1.0",            # https://creativecommons.org/publicdomain/zero/1.0/
+    "ISC",                # https://tldrlegal.com/license/-isc-license
+    "LicenseRef-UFL-1.0", # https://tldrlegal.com/license/ubuntu-font-license,-1.0 - no official SPDX, see https://github.com/emilk/egui/issues/2321
+    "MIT",                # https://tldrlegal.com/license/mit-license
+    "MPL-2.0",            # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11
+    "OFL-1.1",            # https://spdx.org/licenses/OFL-1.1.html
+    "OpenSSL",            # https://www.openssl.org/source/license.html
+    "Unicode-DFS-2016",   # https://spdx.org/licenses/Unicode-DFS-2016.html
+    "Zlib",               # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
+]
+
+[[licenses.clarify]]
+name = "webpki"
+expression = "ISC"
+license-files = [{ path = "LICENSE", hash = 0x001c7e6c }]
+
+[[licenses.clarify]]
+name = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
diff --git a/egui/docs/CNAME b/egui/docs/CNAME
new file mode 100644
index 0000000..ce62e6b
--- /dev/null
+++ b/egui/docs/CNAME
@@ -0,0 +1 @@
+www.egui.rs
\ No newline at end of file
diff --git a/egui/docs/README.md b/egui/docs/README.md
new file mode 100644
index 0000000..7cc35cf
--- /dev/null
+++ b/egui/docs/README.md
@@ -0,0 +1,3 @@
+This folder contains the files required for the egui web demo hosted at <https://www.egui.rs/>.
+
+The reason the folder is called "docs" is because that is the name that GitHub requires in order to host a web page from the `master` branch of a repository.
diff --git a/egui/docs/egui_demo_app.js b/egui/docs/egui_demo_app.js
new file mode 100644
index 0000000..983239e
--- /dev/null
+++ b/egui/docs/egui_demo_app.js
@@ -0,0 +1,1724 @@
+let wasm_bindgen;
+(function() {
+    const __exports = {};
+    let script_src;
+    if (typeof document === 'undefined') {
+        script_src = location.href;
+    } else {
+        script_src = new URL(document.currentScript.src, location.href).toString();
+    }
+    let wasm;
+
+    const heap = new Array(128).fill(undefined);
+
+    heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+let cachedFloat64Memory0 = null;
+
+function getFloat64Memory0() {
+    if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
+        cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64Memory0;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
+
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+
+    return real;
+}
+function __wbg_adapter_28(arg0, arg1) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h19340d09680f5ee3(retptr, arg0, arg1);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+function __wbg_adapter_31(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h9fbcfb319cb46254(arg0, arg1, addHeapObject(arg2));
+}
+
+function makeClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        try {
+            return f(state.a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b);
+                state.a = 0;
+
+            }
+        }
+    };
+    real.original = state;
+
+    return real;
+}
+function __wbg_adapter_34(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__Fn__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h54f5f38e061a8954(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wbg_adapter_39(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h069ca83408af7cd5(arg0, arg1, addHeapObject(arg2));
+}
+
+/**
+*/
+__exports.init_wasm_hooks = function() {
+    wasm.init_wasm_hooks();
+};
+
+/**
+* @param {string} canvas_id
+* @returns {Promise<WebHandle>}
+*/
+__exports.start_separate = function(canvas_id) {
+    const ptr0 = passStringToWasm0(canvas_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.start_separate(ptr0, len0);
+    return takeObject(ret);
+};
+
+/**
+* This is the entry-point for all the web-assembly.
+* This is called once from the HTML.
+* It loads the app, installs some callbacks, then returns.
+* You can add more callbacks like this if you want to call in to your code.
+* @param {string} canvas_id
+* @returns {Promise<WebHandle>}
+*/
+__exports.start = function(canvas_id) {
+    const ptr0 = passStringToWasm0(canvas_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.start(ptr0, len0);
+    return takeObject(ret);
+};
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+function __wbg_adapter_579(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__hc687418ac2afaba1(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+/**
+*/
+class WebHandle {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WebHandle.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_webhandle_free(ptr);
+    }
+    /**
+    */
+    stop_web() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.webhandle_stop_web(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {string} _some_data
+    */
+    set_some_content_from_javascript(_some_data) {
+        const ptr0 = passStringToWasm0(_some_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.webhandle_set_some_content_from_javascript(this.ptr, ptr0, len0);
+    }
+}
+__exports.WebHandle = WebHandle;
+
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function getImports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_webhandle_new = function(arg0) {
+        const ret = WebHandle.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = takeObject(arg0).original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbg_log_c9486ca5d8e2cbe8 = function(arg0, arg1) {
+        try {
+            console.log(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbg_log_aba5996d9bde071f = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        try {
+            console.log(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbg_mark_40e050a77cc39fea = function(arg0, arg1) {
+        performance.mark(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_measure_aa7a73f17813f708 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        try {
+            performance.measure(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+            wasm.__wbindgen_free(arg2, arg3);
+        }
+    }, arguments) };
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        try {
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
+    imports.wbg.__wbindgen_boolean_get = function(arg0) {
+        const v = getObject(arg0);
+        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_WebGl2RenderingContext_61bb2cb23346dbb7 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof WebGL2RenderingContext;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_bindVertexArray_8b71290041cb6746 = function(arg0, arg1) {
+        getObject(arg0).bindVertexArray(getObject(arg1));
+    };
+    imports.wbg.__wbg_bufferData_16f948547d74c866 = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).bufferData(arg1 >>> 0, getObject(arg2), arg3 >>> 0);
+    };
+    imports.wbg.__wbg_createVertexArray_de7292bbd7ea02dd = function(arg0) {
+        const ret = getObject(arg0).createVertexArray();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_deleteVertexArray_dc4f1b2e5ac93f24 = function(arg0, arg1) {
+        getObject(arg0).deleteVertexArray(getObject(arg1));
+    };
+    imports.wbg.__wbg_texImage2D_8fbe9abcfb4a7c9d = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        getObject(arg0).texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, getObject(arg9));
+    }, arguments) };
+    imports.wbg.__wbg_texSubImage2D_6a8b0f3381d734c3 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        getObject(arg0).texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, getObject(arg9));
+    }, arguments) };
+    imports.wbg.__wbg_texSubImage2D_53b6a050a0b9b24e = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        getObject(arg0).texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+    }, arguments) };
+    imports.wbg.__wbg_activeTexture_0daf7c1698e49f00 = function(arg0, arg1) {
+        getObject(arg0).activeTexture(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_attachShader_3038234860d2d59d = function(arg0, arg1, arg2) {
+        getObject(arg0).attachShader(getObject(arg1), getObject(arg2));
+    };
+    imports.wbg.__wbg_bindBuffer_9cb064991696b79f = function(arg0, arg1, arg2) {
+        getObject(arg0).bindBuffer(arg1 >>> 0, getObject(arg2));
+    };
+    imports.wbg.__wbg_bindTexture_0c284b1604ba527c = function(arg0, arg1, arg2) {
+        getObject(arg0).bindTexture(arg1 >>> 0, getObject(arg2));
+    };
+    imports.wbg.__wbg_blendEquationSeparate_d2fa3b718ee3579f = function(arg0, arg1, arg2) {
+        getObject(arg0).blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
+    };
+    imports.wbg.__wbg_blendFuncSeparate_9a7146974b3cd76d = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+    };
+    imports.wbg.__wbg_clear_c9cc4f9c9ed47946 = function(arg0, arg1) {
+        getObject(arg0).clear(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_clearColor_fbabf47cdedcd16c = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).clearColor(arg1, arg2, arg3, arg4);
+    };
+    imports.wbg.__wbg_colorMask_a7f067283ed312c9 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
+    };
+    imports.wbg.__wbg_compileShader_af777dd3b15798b3 = function(arg0, arg1) {
+        getObject(arg0).compileShader(getObject(arg1));
+    };
+    imports.wbg.__wbg_createBuffer_5ed0554ab35780b5 = function(arg0) {
+        const ret = getObject(arg0).createBuffer();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createProgram_7d25c1dd3bb0ce39 = function(arg0) {
+        const ret = getObject(arg0).createProgram();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createShader_96339db58713e350 = function(arg0, arg1) {
+        const ret = getObject(arg0).createShader(arg1 >>> 0);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createTexture_c651f9e28d1ce9d2 = function(arg0) {
+        const ret = getObject(arg0).createTexture();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_deleteBuffer_cf67a696a7857b3f = function(arg0, arg1) {
+        getObject(arg0).deleteBuffer(getObject(arg1));
+    };
+    imports.wbg.__wbg_deleteProgram_9c8fa1ef341cb01d = function(arg0, arg1) {
+        getObject(arg0).deleteProgram(getObject(arg1));
+    };
+    imports.wbg.__wbg_deleteShader_f48f72524f5ee3ed = function(arg0, arg1) {
+        getObject(arg0).deleteShader(getObject(arg1));
+    };
+    imports.wbg.__wbg_deleteTexture_1b5f5e536e0d5545 = function(arg0, arg1) {
+        getObject(arg0).deleteTexture(getObject(arg1));
+    };
+    imports.wbg.__wbg_detachShader_e1817cff5917432b = function(arg0, arg1, arg2) {
+        getObject(arg0).detachShader(getObject(arg1), getObject(arg2));
+    };
+    imports.wbg.__wbg_disable_3adb8645ea1d92d4 = function(arg0, arg1) {
+        getObject(arg0).disable(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_disableVertexAttribArray_f469283fda607cee = function(arg0, arg1) {
+        getObject(arg0).disableVertexAttribArray(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_drawArrays_84de8a2416396807 = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).drawArrays(arg1 >>> 0, arg2, arg3);
+    };
+    imports.wbg.__wbg_drawElements_dcb8df9c52e2bbd5 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).drawElements(arg1 >>> 0, arg2, arg3 >>> 0, arg4);
+    };
+    imports.wbg.__wbg_enable_1ac9f14a577b7c8b = function(arg0, arg1) {
+        getObject(arg0).enable(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_enableVertexAttribArray_53139716d9c95dba = function(arg0, arg1) {
+        getObject(arg0).enableVertexAttribArray(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_getAttribLocation_398d36222d12b7da = function(arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).getAttribLocation(getObject(arg1), getStringFromWasm0(arg2, arg3));
+        return ret;
+    };
+    imports.wbg.__wbg_getError_a472f86b6aa9ea71 = function(arg0) {
+        const ret = getObject(arg0).getError();
+        return ret;
+    };
+    imports.wbg.__wbg_getExtension_f0070583175271d4 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).getExtension(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getParameter_56d47f9b55e463d4 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).getParameter(arg1 >>> 0);
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getProgramInfoLog_7654794297967ac0 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg1).getProgramInfoLog(getObject(arg2));
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_getProgramParameter_5b1a40917aa850f8 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).getProgramParameter(getObject(arg1), arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getShaderInfoLog_915d0e8506c11159 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg1).getShaderInfoLog(getObject(arg2));
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_getShaderParameter_f9240892c9e7a0a3 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).getShaderParameter(getObject(arg1), arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getSupportedExtensions_7af8f7bbdd4d7b2c = function(arg0) {
+        const ret = getObject(arg0).getSupportedExtensions();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getUniformLocation_c6caabb349b43da7 = function(arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).getUniformLocation(getObject(arg1), getStringFromWasm0(arg2, arg3));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_linkProgram_2d5cc584654696b8 = function(arg0, arg1) {
+        getObject(arg0).linkProgram(getObject(arg1));
+    };
+    imports.wbg.__wbg_pixelStorei_a0b83efc92cd29fe = function(arg0, arg1, arg2) {
+        getObject(arg0).pixelStorei(arg1 >>> 0, arg2);
+    };
+    imports.wbg.__wbg_scissor_2b084e0dc81d67f4 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).scissor(arg1, arg2, arg3, arg4);
+    };
+    imports.wbg.__wbg_shaderSource_57883245cdfb0dca = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).shaderSource(getObject(arg1), getStringFromWasm0(arg2, arg3));
+    };
+    imports.wbg.__wbg_texParameteri_e0ce3810261e0864 = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
+    };
+    imports.wbg.__wbg_uniform1f_dcc6951bde745417 = function(arg0, arg1, arg2) {
+        getObject(arg0).uniform1f(getObject(arg1), arg2);
+    };
+    imports.wbg.__wbg_uniform1i_4fdc6d6740375d22 = function(arg0, arg1, arg2) {
+        getObject(arg0).uniform1i(getObject(arg1), arg2);
+    };
+    imports.wbg.__wbg_uniform2f_663052537be1f7ea = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).uniform2f(getObject(arg1), arg2, arg3);
+    };
+    imports.wbg.__wbg_useProgram_2f4094faf45ecba1 = function(arg0, arg1) {
+        getObject(arg0).useProgram(getObject(arg1));
+    };
+    imports.wbg.__wbg_vertexAttribPointer_ad370785358334f4 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+        getObject(arg0).vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
+    };
+    imports.wbg.__wbg_viewport_cc41e28a71c23915 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).viewport(arg1, arg2, arg3, arg4);
+    };
+    imports.wbg.__wbg_instanceof_Window_e266f02eee43b570 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Window;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_document_950215a728589a2d = function(arg0) {
+        const ret = getObject(arg0).document;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_location_797a1856892cc2de = function(arg0) {
+        const ret = getObject(arg0).location;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_navigator_b18e629f7f0b75fa = function(arg0) {
+        const ret = getObject(arg0).navigator;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_innerHeight_3ef25a30618357e0 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).innerHeight;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_devicePixelRatio_5f8f5cab76864090 = function(arg0) {
+        const ret = getObject(arg0).devicePixelRatio;
+        return ret;
+    };
+    imports.wbg.__wbg_performance_8629f414811abc46 = function(arg0) {
+        const ret = getObject(arg0).performance;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_speechSynthesis_5ece6f537763b24d = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).speechSynthesis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_localStorage_42608208af988a02 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).localStorage;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_matchMedia_967e50e4289050fa = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).matchMedia(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_open_caf5dfe2d159a600 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_requestAnimationFrame_afe426b568f84138 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).requestAnimationFrame(getObject(arg1));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_clearInterval_3f324662ce039e9a = function(arg0, arg1) {
+        getObject(arg0).clearInterval(arg1);
+    };
+    imports.wbg.__wbg_fetch_465e8cb61a0f43ea = function(arg0, arg1) {
+        const ret = getObject(arg0).fetch(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_setTimeout_6609c9aa64f32bfc = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_width_f0cbf7dcbbe056da = function(arg0) {
+        const ret = getObject(arg0).width;
+        return ret;
+    };
+    imports.wbg.__wbg_height_e46975153da440ae = function(arg0) {
+        const ret = getObject(arg0).height;
+        return ret;
+    };
+    imports.wbg.__wbg_length_e330009c21d43b27 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_get_460ba3644fab1c42 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_a5d34c36a1a4ebd1 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments) };
+    imports.wbg.__wbg_error_814b3584db987163 = function(arg0) {
+        const ret = getObject(arg0).error;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_setvoice_695efd93ad7d0643 = function(arg0, arg1) {
+        getObject(arg0).voice = getObject(arg1);
+    };
+    imports.wbg.__wbg_setvolume_28e40245acc7d589 = function(arg0, arg1) {
+        getObject(arg0).volume = arg1;
+    };
+    imports.wbg.__wbg_setrate_a2fe853fe7ef2e80 = function(arg0, arg1) {
+        getObject(arg0).rate = arg1;
+    };
+    imports.wbg.__wbg_setpitch_3ae35717a01f1395 = function(arg0, arg1) {
+        getObject(arg0).pitch = arg1;
+    };
+    imports.wbg.__wbg_setonstart_a1325a9d8876aa24 = function(arg0, arg1) {
+        getObject(arg0).onstart = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonend_2919d272043608f6 = function(arg0, arg1) {
+        getObject(arg0).onend = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonerror_24fddefdb512a73c = function(arg0, arg1) {
+        getObject(arg0).onerror = getObject(arg1);
+    };
+    imports.wbg.__wbg_newwithtext_bd73c697edeb8512 = function() { return handleError(function (arg0, arg1) {
+        const ret = new SpeechSynthesisUtterance(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_length_2c7ef1d09c0b4b3e = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_item_a04b92df1cf554e3 = function(arg0, arg1) {
+        const ret = getObject(arg0).item(arg1 >>> 0);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_9b7ef79ee8f9567e = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_instanceof_HtmlInputElement_5c9d54338207f061 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof HTMLInputElement;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_setautofocus_46ee4bac294813ab = function(arg0, arg1) {
+        getObject(arg0).autofocus = arg1 !== 0;
+    };
+    imports.wbg.__wbg_setsize_16996b11841d4db7 = function(arg0, arg1) {
+        getObject(arg0).size = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_value_1f2c9e357d18d3ea = function(arg0, arg1) {
+        const ret = getObject(arg1).value;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_setvalue_a706abe70dab1b65 = function(arg0, arg1, arg2) {
+        getObject(arg0).value = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_type_b08889892f8d8d81 = function(arg0, arg1) {
+        const ret = getObject(arg1).type;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_clientX_35f23f953e04ec0e = function(arg0) {
+        const ret = getObject(arg0).clientX;
+        return ret;
+    };
+    imports.wbg.__wbg_clientY_8104e462abc0b3ec = function(arg0) {
+        const ret = getObject(arg0).clientY;
+        return ret;
+    };
+    imports.wbg.__wbg_ctrlKey_e1b8f1de1eb24d5d = function(arg0) {
+        const ret = getObject(arg0).ctrlKey;
+        return ret;
+    };
+    imports.wbg.__wbg_shiftKey_fdd99b6df96e25c5 = function(arg0) {
+        const ret = getObject(arg0).shiftKey;
+        return ret;
+    };
+    imports.wbg.__wbg_metaKey_934772989e28020c = function(arg0) {
+        const ret = getObject(arg0).metaKey;
+        return ret;
+    };
+    imports.wbg.__wbg_button_a1c470d5e4c997f2 = function(arg0) {
+        const ret = getObject(arg0).button;
+        return ret;
+    };
+    imports.wbg.__wbg_bindVertexArrayOES_688eba003a98a0bb = function(arg0, arg1) {
+        getObject(arg0).bindVertexArrayOES(getObject(arg1));
+    };
+    imports.wbg.__wbg_createVertexArrayOES_02cfe655604046eb = function(arg0) {
+        const ret = getObject(arg0).createVertexArrayOES();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_deleteVertexArrayOES_ba22911f739464a7 = function(arg0, arg1) {
+        getObject(arg0).deleteVertexArrayOES(getObject(arg1));
+    };
+    imports.wbg.__wbg_instanceof_Response_fb3a4df648c1859b = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Response;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_url_8ec2534cdfacb103 = function(arg0, arg1) {
+        const ret = getObject(arg1).url;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_status_d483a4ac847f380a = function(arg0) {
+        const ret = getObject(arg0).status;
+        return ret;
+    };
+    imports.wbg.__wbg_ok_1cd4c5ee1ccf4e0f = function(arg0) {
+        const ret = getObject(arg0).ok;
+        return ret;
+    };
+    imports.wbg.__wbg_statusText_9674693c2eb731fa = function(arg0, arg1) {
+        const ret = getObject(arg1).statusText;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_headers_6093927dc359903e = function(arg0) {
+        const ret = getObject(arg0).headers;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_arrayBuffer_cb886e06a9e36e4d = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).arrayBuffer();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_deltaX_b7d127c94d6265c0 = function(arg0) {
+        const ret = getObject(arg0).deltaX;
+        return ret;
+    };
+    imports.wbg.__wbg_deltaY_b32fa858e16edcc0 = function(arg0) {
+        const ret = getObject(arg0).deltaY;
+        return ret;
+    };
+    imports.wbg.__wbg_deltaMode_11f7b19e64d9a515 = function(arg0) {
+        const ret = getObject(arg0).deltaMode;
+        return ret;
+    };
+    imports.wbg.__wbg_matches_7b5ad9e6bb56f1f3 = function(arg0) {
+        const ret = getObject(arg0).matches;
+        return ret;
+    };
+    imports.wbg.__wbg_voiceURI_50a1a7f3e73df7b5 = function(arg0, arg1) {
+        const ret = getObject(arg1).voiceURI;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_name_2a973b1bf8f76bc4 = function(arg0, arg1) {
+        const ret = getObject(arg1).name;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_lang_546b1c00b3233425 = function(arg0, arg1) {
+        const ret = getObject(arg1).lang;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_default_ce5fc1bb8281e2f3 = function(arg0) {
+        const ret = getObject(arg0).default;
+        return ret;
+    };
+    imports.wbg.__wbg_addEventListener_615d4590d38da1c9 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+    }, arguments) };
+    imports.wbg.__wbg_removeEventListener_86fd19ed073cd1ed = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+    }, arguments) };
+    imports.wbg.__wbg_now_c644db5194be8437 = function(arg0) {
+        const ret = getObject(arg0).now();
+        return ret;
+    };
+    imports.wbg.__wbg_writeText_eb90459f8e0f70d4 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).writeText(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_items_6415b6b2cd06ac5f = function(arg0) {
+        const ret = getObject(arg0).items;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_files_d001bc03bc88c2b4 = function(arg0) {
+        const ret = getObject(arg0).files;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getData_cee6ca6a7b023460 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg1).getData(getStringFromWasm0(arg2, arg3));
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_dataTransfer_445ade328cdd17c8 = function(arg0) {
+        const ret = getObject(arg0).dataTransfer;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_instanceof_HtmlCanvasElement_f5f69dab93281ebe = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof HTMLCanvasElement;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_width_a40e21a22129b197 = function(arg0) {
+        const ret = getObject(arg0).width;
+        return ret;
+    };
+    imports.wbg.__wbg_setwidth_81c62bc806e0a727 = function(arg0, arg1) {
+        getObject(arg0).width = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_height_98d51321254345a5 = function(arg0) {
+        const ret = getObject(arg0).height;
+        return ret;
+    };
+    imports.wbg.__wbg_setheight_98cf0db22c40ef07 = function(arg0, arg1) {
+        getObject(arg0).height = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_getContext_3ae404b649cf9287 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_headers_ab5251d2727ac41e = function(arg0) {
+        const ret = getObject(arg0).headers;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithstrandinit_c45f0dc6da26fd03 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_speaking_d3643e1a85c1fe5c = function(arg0) {
+        const ret = getObject(arg0).speaking;
+        return ret;
+    };
+    imports.wbg.__wbg_cancel_b44993f4172cdd72 = function(arg0) {
+        getObject(arg0).cancel();
+    };
+    imports.wbg.__wbg_getVoices_2c3cde6ab65c37fe = function(arg0) {
+        const ret = getObject(arg0).getVoices();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_speak_fbccfbc0d3610d0b = function(arg0, arg1) {
+        getObject(arg0).speak(getObject(arg1));
+    };
+    imports.wbg.__wbg_body_be46234bb33edd63 = function(arg0) {
+        const ret = getObject(arg0).body;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createElement_e2a0e21263eb5416 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getElementById_eb93a47327bb5585 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_setid_3ffcf3ad6af1d07c = function(arg0, arg1, arg2) {
+        getObject(arg0).id = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_scrollLeft_7d962ecb3da16acc = function(arg0) {
+        const ret = getObject(arg0).scrollLeft;
+        return ret;
+    };
+    imports.wbg.__wbg_scrollWidth_9e314e378104f5e7 = function(arg0) {
+        const ret = getObject(arg0).scrollWidth;
+        return ret;
+    };
+    imports.wbg.__wbg_scrollHeight_713c7ba485141495 = function(arg0) {
+        const ret = getObject(arg0).scrollHeight;
+        return ret;
+    };
+    imports.wbg.__wbg_clientWidth_1fa51f20a3bebbbf = function(arg0) {
+        const ret = getObject(arg0).clientWidth;
+        return ret;
+    };
+    imports.wbg.__wbg_clientHeight_0fe149fdad1fe046 = function(arg0) {
+        const ret = getObject(arg0).clientHeight;
+        return ret;
+    };
+    imports.wbg.__wbg_getBoundingClientRect_aaa701cbcb448965 = function(arg0) {
+        const ret = getObject(arg0).getBoundingClientRect();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_scrollTop_99ac74051927ce93 = function(arg0) {
+        const ret = getObject(arg0).scrollTop;
+        return ret;
+    };
+    imports.wbg.__wbg_hidden_fb6a31a778a81f54 = function(arg0) {
+        const ret = getObject(arg0).hidden;
+        return ret;
+    };
+    imports.wbg.__wbg_sethidden_033fb33dfd8d075f = function(arg0, arg1) {
+        getObject(arg0).hidden = arg1 !== 0;
+    };
+    imports.wbg.__wbg_style_2141664e428fef46 = function(arg0) {
+        const ret = getObject(arg0).style;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_offsetTop_17972c95c5a34103 = function(arg0) {
+        const ret = getObject(arg0).offsetTop;
+        return ret;
+    };
+    imports.wbg.__wbg_offsetLeft_0ef17ef919c0a196 = function(arg0) {
+        const ret = getObject(arg0).offsetLeft;
+        return ret;
+    };
+    imports.wbg.__wbg_offsetWidth_56caa7d0f7e171a2 = function(arg0) {
+        const ret = getObject(arg0).offsetWidth;
+        return ret;
+    };
+    imports.wbg.__wbg_blur_b94a30ed202c3612 = function() { return handleError(function (arg0) {
+        getObject(arg0).blur();
+    }, arguments) };
+    imports.wbg.__wbg_focus_6497e1b44dabfb24 = function() { return handleError(function (arg0) {
+        getObject(arg0).focus();
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_WebGlRenderingContext_1f34d107adf90e57 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof WebGLRenderingContext;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_bufferData_023700b2ed207c43 = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).bufferData(arg1 >>> 0, getObject(arg2), arg3 >>> 0);
+    };
+    imports.wbg.__wbg_texImage2D_40b43ed3876db607 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        getObject(arg0).texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, getObject(arg9));
+    }, arguments) };
+    imports.wbg.__wbg_texSubImage2D_57792696288b0a61 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        getObject(arg0).texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, getObject(arg9));
+    }, arguments) };
+    imports.wbg.__wbg_activeTexture_01d5469eb22c10e7 = function(arg0, arg1) {
+        getObject(arg0).activeTexture(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_attachShader_14fb12e2ae589dc3 = function(arg0, arg1, arg2) {
+        getObject(arg0).attachShader(getObject(arg1), getObject(arg2));
+    };
+    imports.wbg.__wbg_bindBuffer_b7c382dcd70e33f6 = function(arg0, arg1, arg2) {
+        getObject(arg0).bindBuffer(arg1 >>> 0, getObject(arg2));
+    };
+    imports.wbg.__wbg_bindTexture_c1c0e00507424f8e = function(arg0, arg1, arg2) {
+        getObject(arg0).bindTexture(arg1 >>> 0, getObject(arg2));
+    };
+    imports.wbg.__wbg_blendEquationSeparate_48b95e78f7224be4 = function(arg0, arg1, arg2) {
+        getObject(arg0).blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
+    };
+    imports.wbg.__wbg_blendFuncSeparate_b508053691b6ebbe = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+    };
+    imports.wbg.__wbg_clear_edebb12717625e22 = function(arg0, arg1) {
+        getObject(arg0).clear(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_clearColor_8758a0aef2ed52e4 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).clearColor(arg1, arg2, arg3, arg4);
+    };
+    imports.wbg.__wbg_colorMask_99120a2c8caf1298 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
+    };
+    imports.wbg.__wbg_compileShader_4e9130ccbd4a0238 = function(arg0, arg1) {
+        getObject(arg0).compileShader(getObject(arg1));
+    };
+    imports.wbg.__wbg_createBuffer_8c64250e5283611c = function(arg0) {
+        const ret = getObject(arg0).createBuffer();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createProgram_28db0ff3cee5f71a = function(arg0) {
+        const ret = getObject(arg0).createProgram();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createShader_c5fcd8592f47b510 = function(arg0, arg1) {
+        const ret = getObject(arg0).createShader(arg1 >>> 0);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createTexture_81fd93af28301e0e = function(arg0) {
+        const ret = getObject(arg0).createTexture();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_deleteBuffer_17feed38f3a70ec9 = function(arg0, arg1) {
+        getObject(arg0).deleteBuffer(getObject(arg1));
+    };
+    imports.wbg.__wbg_deleteProgram_dd5f0e2bc555e270 = function(arg0, arg1) {
+        getObject(arg0).deleteProgram(getObject(arg1));
+    };
+    imports.wbg.__wbg_deleteShader_fac9fb3cdefdf6ec = function(arg0, arg1) {
+        getObject(arg0).deleteShader(getObject(arg1));
+    };
+    imports.wbg.__wbg_deleteTexture_605a36a7e380df5f = function(arg0, arg1) {
+        getObject(arg0).deleteTexture(getObject(arg1));
+    };
+    imports.wbg.__wbg_detachShader_925c73dc92b1f7ac = function(arg0, arg1, arg2) {
+        getObject(arg0).detachShader(getObject(arg1), getObject(arg2));
+    };
+    imports.wbg.__wbg_disable_65425605098b79cf = function(arg0, arg1) {
+        getObject(arg0).disable(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_disableVertexAttribArray_cf25f8beb5872364 = function(arg0, arg1) {
+        getObject(arg0).disableVertexAttribArray(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_drawArrays_e5fa3cfc2b5d7c6d = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).drawArrays(arg1 >>> 0, arg2, arg3);
+    };
+    imports.wbg.__wbg_drawElements_a388832eba137ef0 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).drawElements(arg1 >>> 0, arg2, arg3 >>> 0, arg4);
+    };
+    imports.wbg.__wbg_enable_2c3b6a4692af9b1b = function(arg0, arg1) {
+        getObject(arg0).enable(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_enableVertexAttribArray_6dd3d0668209ae19 = function(arg0, arg1) {
+        getObject(arg0).enableVertexAttribArray(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_getAttribLocation_65a128b3e856d81e = function(arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).getAttribLocation(getObject(arg1), getStringFromWasm0(arg2, arg3));
+        return ret;
+    };
+    imports.wbg.__wbg_getError_c96479731e168333 = function(arg0) {
+        const ret = getObject(arg0).getError();
+        return ret;
+    };
+    imports.wbg.__wbg_getExtension_d1151f6038b08ca5 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).getExtension(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getParameter_d6cd2dd2cde656ec = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).getParameter(arg1 >>> 0);
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getProgramInfoLog_7fd2a7c6c1a280c1 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg1).getProgramInfoLog(getObject(arg2));
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_getProgramParameter_af1cfcccbbc80f71 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).getProgramParameter(getObject(arg1), arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getShaderInfoLog_d057293074e59c61 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg1).getShaderInfoLog(getObject(arg2));
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_getShaderParameter_685d7d7092c6bae6 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).getShaderParameter(getObject(arg1), arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getSupportedExtensions_4a52f9e74bd462b2 = function(arg0) {
+        const ret = getObject(arg0).getSupportedExtensions();
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getUniformLocation_b46e5db76599a918 = function(arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).getUniformLocation(getObject(arg1), getStringFromWasm0(arg2, arg3));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_linkProgram_ca9df3fba2fd4125 = function(arg0, arg1) {
+        getObject(arg0).linkProgram(getObject(arg1));
+    };
+    imports.wbg.__wbg_pixelStorei_f97b971917582269 = function(arg0, arg1, arg2) {
+        getObject(arg0).pixelStorei(arg1 >>> 0, arg2);
+    };
+    imports.wbg.__wbg_scissor_8bc2e761846f53f0 = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).scissor(arg1, arg2, arg3, arg4);
+    };
+    imports.wbg.__wbg_shaderSource_457e8bc42050401d = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).shaderSource(getObject(arg1), getStringFromWasm0(arg2, arg3));
+    };
+    imports.wbg.__wbg_texParameteri_9fbb09bbf9670af4 = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
+    };
+    imports.wbg.__wbg_uniform1f_062c683ec584f7e8 = function(arg0, arg1, arg2) {
+        getObject(arg0).uniform1f(getObject(arg1), arg2);
+    };
+    imports.wbg.__wbg_uniform1i_1f8256271b54cf41 = function(arg0, arg1, arg2) {
+        getObject(arg0).uniform1i(getObject(arg1), arg2);
+    };
+    imports.wbg.__wbg_uniform2f_8b73735c25c38ca6 = function(arg0, arg1, arg2, arg3) {
+        getObject(arg0).uniform2f(getObject(arg1), arg2, arg3);
+    };
+    imports.wbg.__wbg_useProgram_6c9019d05fb8d280 = function(arg0, arg1) {
+        getObject(arg0).useProgram(getObject(arg1));
+    };
+    imports.wbg.__wbg_vertexAttribPointer_ccabef9be68fe1c4 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+        getObject(arg0).vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
+    };
+    imports.wbg.__wbg_viewport_4bdfc4b8959593ee = function(arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).viewport(arg1, arg2, arg3, arg4);
+    };
+    imports.wbg.__wbg_length_03c61261420b999d = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_get_69ba9968c4a57a29 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_name_ccf3024ae4e3ac54 = function(arg0, arg1) {
+        const ret = getObject(arg1).name;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_lastModified_32c6de706a583a54 = function(arg0) {
+        const ret = getObject(arg0).lastModified;
+        return ret;
+    };
+    imports.wbg.__wbg_keyCode_b33194be2ceec53b = function(arg0) {
+        const ret = getObject(arg0).keyCode;
+        return ret;
+    };
+    imports.wbg.__wbg_altKey_dff2a075455ac01b = function(arg0) {
+        const ret = getObject(arg0).altKey;
+        return ret;
+    };
+    imports.wbg.__wbg_ctrlKey_993b558f853d64ce = function(arg0) {
+        const ret = getObject(arg0).ctrlKey;
+        return ret;
+    };
+    imports.wbg.__wbg_shiftKey_31e62e9d172b26f0 = function(arg0) {
+        const ret = getObject(arg0).shiftKey;
+        return ret;
+    };
+    imports.wbg.__wbg_metaKey_9f0f19692d0498bd = function(arg0) {
+        const ret = getObject(arg0).metaKey;
+        return ret;
+    };
+    imports.wbg.__wbg_isComposing_ce52afdb1bf63db2 = function(arg0) {
+        const ret = getObject(arg0).isComposing;
+        return ret;
+    };
+    imports.wbg.__wbg_key_f0decac219aa904b = function(arg0, arg1) {
+        const ret = getObject(arg1).key;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_clipboard_72ae7717d527a067 = function(arg0) {
+        const ret = getObject(arg0).clipboard;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_userAgent_d158c64a4e5b651d = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).userAgent;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_identifier_3e06c0d82cde247d = function(arg0) {
+        const ret = getObject(arg0).identifier;
+        return ret;
+    };
+    imports.wbg.__wbg_pageX_cf558d792570ac5a = function(arg0) {
+        const ret = getObject(arg0).pageX;
+        return ret;
+    };
+    imports.wbg.__wbg_pageY_5baceda2289af162 = function(arg0) {
+        const ret = getObject(arg0).pageY;
+        return ret;
+    };
+    imports.wbg.__wbg_force_6c7c8dc911c4087e = function(arg0) {
+        const ret = getObject(arg0).force;
+        return ret;
+    };
+    imports.wbg.__wbg_clipboardData_ac331f6733f5f16f = function(arg0) {
+        const ret = getObject(arg0).clipboardData;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_preventDefault_16b2170b12f56317 = function(arg0) {
+        getObject(arg0).preventDefault();
+    };
+    imports.wbg.__wbg_stopPropagation_7647c9985222f9b0 = function(arg0) {
+        getObject(arg0).stopPropagation();
+    };
+    imports.wbg.__wbg_href_bb86bb94d1c6861b = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).href;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_origin_4361a18d29b70c77 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).origin;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_protocol_3767aa51aa3121ca = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).protocol;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_host_ab37f7d1be2315a7 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).host;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_hostname_be66b7761940ef8a = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).hostname;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_port_38f022852f38e981 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).port;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_search_23418f9752ba7ba6 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).search;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_hash_03f283be75af7a56 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).hash;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_parentElement_0e8c9afce5cb9d6e = function(arg0) {
+        const ret = getObject(arg0).parentElement;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_appendChild_b8199dc1655c852d = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).appendChild(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_touches_0014fdd3c869de3b = function(arg0) {
+        const ret = getObject(arg0).touches;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_changedTouches_41490ec78db4414d = function(arg0) {
+        const ret = getObject(arg0).changedTouches;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_size_88fc46d83abb907c = function(arg0) {
+        const ret = getObject(arg0).size;
+        return ret;
+    };
+    imports.wbg.__wbg_arrayBuffer_a767ad7c28b781f8 = function(arg0) {
+        const ret = getObject(arg0).arrayBuffer();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_data_70b505c651722930 = function(arg0, arg1) {
+        const ret = getObject(arg1).data;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_setProperty_21e2e7868b86a93e = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).setProperty(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments) };
+    imports.wbg.__wbg_top_98bc5382de3ec5d2 = function(arg0) {
+        const ret = getObject(arg0).top;
+        return ret;
+    };
+    imports.wbg.__wbg_left_09342c290d46b4a6 = function(arg0) {
+        const ret = getObject(arg0).left;
+        return ret;
+    };
+    imports.wbg.__wbg_getItem_f0d43fc4e780b652 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg1).getItem(getStringFromWasm0(arg2, arg3));
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    }, arguments) };
+    imports.wbg.__wbg_setItem_f645824d6eface62 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments) };
+    imports.wbg.__wbg_get_27fe3dac1c4d0224 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_length_e498fbc24f9c1d4f = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_2b8b6bd7753c76ba = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = getObject(arg0);
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbg_next_b7d530c04fd8b217 = function(arg0) {
+        const ret = getObject(arg0).next;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_next_88560ec06a094dea = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).next();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_done_1ebec03bbd919843 = function(arg0) {
+        const ret = getObject(arg0).done;
+        return ret;
+    };
+    imports.wbg.__wbg_value_6ac8da5cc5b3efda = function(arg0) {
+        const ret = getObject(arg0).value;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_iterator_55f114446221aa5a = function() {
+        const ret = Symbol.iterator;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_baf4855f9a986186 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_95d1ea488d03e4e8 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_f9876326328f45ed = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_self_e7c1f827057f6584 = function() { return handleError(function () {
+        const ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_a09ec664e14b1b81 = function() { return handleError(function () {
+        const ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_87cbb8506fecf3a9 = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_c85a9259e621f3db = function() { return handleError(function () {
+        const ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg_call_9495de66fdbe016b = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getTime_7c59072d1651a3cf = function(arg0) {
+        const ret = getObject(arg0).getTime();
+        return ret;
+    };
+    imports.wbg.__wbg_getTimezoneOffset_2a6b27fb18493a56 = function(arg0) {
+        const ret = getObject(arg0).getTimezoneOffset();
+        return ret;
+    };
+    imports.wbg.__wbg_new0_25059e40b1c02766 = function() {
+        const ret = new Date();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_9d3a9ce4282a18a8 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_579(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_resolve_fd40f858d9db1a04 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_ec5db6d509eb475f = function(arg0, arg1) {
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_f753623316e2873a = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_buffer_cf65c07de34b9a08 = function(arg0) {
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_55f9ffb569d9fa74 = function(arg0, arg1, arg2) {
+        const ret = new Int8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_f477e654086cbbb6 = function(arg0, arg1, arg2) {
+        const ret = new Int16Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_b57a602974d4b1cd = function(arg0, arg1, arg2) {
+        const ret = new Int32Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5 = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_537b7341ce90bb31 = function(arg0) {
+        const ret = new Uint8Array(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_17499e8aa4003ebd = function(arg0, arg1, arg2) {
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+    };
+    imports.wbg.__wbg_length_27a2afe8ab42b09f = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_9241d9d251418ebf = function(arg0, arg1, arg2) {
+        const ret = new Uint16Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_5c5a6e21987c3bee = function(arg0, arg1, arg2) {
+        const ret = new Uint32Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_4078d56428eb2926 = function(arg0, arg1, arg2) {
+        const ret = new Float32Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_6aa458a4ebdb65cb = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper3268 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 1156, __wbg_adapter_28);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper3269 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 1156, __wbg_adapter_31);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper3410 = function(arg0, arg1, arg2) {
+        const ret = makeClosure(arg0, arg1, 1236, __wbg_adapter_34);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper3412 = function(arg0, arg1, arg2) {
+        const ret = makeClosure(arg0, arg1, 1236, __wbg_adapter_34);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper3460 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 1262, __wbg_adapter_39);
+        return addHeapObject(ret);
+    };
+
+    return imports;
+}
+
+function initMemory(imports, maybe_memory) {
+
+}
+
+function finalizeInit(instance, module) {
+    wasm = instance.exports;
+    init.__wbindgen_wasm_module = module;
+    cachedFloat64Memory0 = null;
+    cachedInt32Memory0 = null;
+    cachedUint8Memory0 = null;
+
+
+    return wasm;
+}
+
+function initSync(module) {
+    const imports = getImports();
+
+    initMemory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return finalizeInit(instance, module);
+}
+
+async function init(input) {
+    if (typeof input === 'undefined') {
+        input = script_src.replace(/\.js$/, '_bg.wasm');
+    }
+    const imports = getImports();
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+    initMemory(imports);
+
+    const { instance, module } = await load(await input, imports);
+
+    return finalizeInit(instance, module);
+}
+
+wasm_bindgen = Object.assign(init, { initSync }, __exports);
+
+})();
diff --git a/egui/docs/egui_demo_app_bg.wasm b/egui/docs/egui_demo_app_bg.wasm
new file mode 100644
index 0000000..4b0b365
Binary files /dev/null and b/egui/docs/egui_demo_app_bg.wasm differ
diff --git a/egui/docs/example.html b/egui/docs/example.html
new file mode 100644
index 0000000..9caf23d
--- /dev/null
+++ b/egui/docs/example.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+<head>
+    <meta http-equiv="refresh" content="0; url = https://www.egui.rs/#http" />
+</head>
+
+<body>
+</body>
+
+</html>
diff --git a/egui/docs/favicon.ico b/egui/docs/favicon.ico
new file mode 100755
index 0000000..61ad031
Binary files /dev/null and b/egui/docs/favicon.ico differ
diff --git a/egui/docs/index.html b/egui/docs/index.html
new file mode 100644
index 0000000..e228ed3
--- /dev/null
+++ b/egui/docs/index.html
@@ -0,0 +1,164 @@
+<!DOCTYPE html>
+<html>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+<!-- Disable zooming: -->
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+
+<head>
+    <title>egui – An immediate mode GUI written in Rust</title>
+    <style>
+        html {
+            /* Remove touch delay: */
+            touch-action: manipulation;
+        }
+
+        body {
+            /* Light mode background color for what is not covered by the egui canvas,
+            or where the egui canvas is translucent. */
+            background: #909090;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            body {
+                /* Dark mode background color for what is not covered by the egui canvas,
+                or where the egui canvas is translucent. */
+                background: #404040;
+            }
+        }
+
+        /* Allow canvas to fill entire web page: */
+        html,
+        body {
+            overflow: hidden;
+            margin: 0 !important;
+            padding: 0 !important;
+            height: 100%;
+            width: 100%;
+        }
+
+        /* Position canvas in center-top: */
+        canvas {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 0%;
+            left: 50%;
+            transform: translate(-50%, 0%);
+        }
+
+        .centered {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            color: #f0f0f0;
+            font-size: 24px;
+            font-family: Ubuntu-Light, Helvetica, sans-serif;
+            text-align: center;
+        }
+
+        /* ---------------------------------------------- */
+        /* Loading animation from https://loading.io/css/ */
+        .lds-dual-ring {
+            display: inline-block;
+            width: 24px;
+            height: 24px;
+        }
+
+        .lds-dual-ring:after {
+            content: " ";
+            display: block;
+            width: 24px;
+            height: 24px;
+            margin: 0px;
+            border-radius: 50%;
+            border: 3px solid #fff;
+            border-color: #fff transparent #fff transparent;
+            animation: lds-dual-ring 1.2s linear infinite;
+        }
+
+        @keyframes lds-dual-ring {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <!-- The WASM code will resize the canvas dynamically -->
+    <canvas id="the_canvas_id"></canvas>
+    <div class="centered" id="center_text">
+        <p style="font-size:16px">
+            Loading…
+        </p>
+        <div class="lds-dual-ring"></div>
+    </div>
+
+    <script>
+        // The `--no-modules`-generated JS from `wasm-bindgen` attempts to use
+        // `WebAssembly.instantiateStreaming` to instantiate the wasm module,
+        // but this doesn't work with `file://` urls. This example is frequently
+        // viewed by simply opening `index.html` in a browser (with a `file://`
+        // url), so it would fail if we were to call this function!
+        //
+        // Work around this for now by deleting the function to ensure that the
+        // `no_modules.js` script doesn't have access to it. You won't need this
+        // hack when deploying over HTTP.
+        delete WebAssembly.instantiateStreaming;
+    </script>
+
+    <!-- this is the JS generated by the `wasm-bindgen` CLI tool -->
+    <script src="egui_demo_app.js"></script>
+
+    <script>
+        // We'll defer our execution until the wasm is ready to go.
+        // Here we tell bindgen the path to the wasm file so it can start
+        // initialization and return to us a promise when it's done.
+        console.debug("loading wasm…");
+        wasm_bindgen("./egui_demo_app_bg.wasm")
+            .then(on_wasm_loaded)
+            .catch(on_wasm_error);
+
+        function on_wasm_loaded() {
+            console.debug("wasm loaded. starting app…");
+
+            // This call installs a bunch of callbacks and then returns:
+            const handle = wasm_bindgen.start("the_canvas_id");
+
+            // call `handle.stop_web()` to stop
+            // uncomment to quick result
+            // setTimeout(() => {handle.stop_web(); handle.free())}, 2000)
+
+            console.debug("app started.");
+            document.getElementById("center_text").remove();
+        }
+
+        function on_wasm_error(error) {
+            console.error("Failed to start: " + error);
+            document.getElementById("center_text").innerHTML = `
+                <p>
+                    An error occurred during loading:
+                </p>
+                <p style="font-family:Courier New">
+                    ${error}
+                </p>
+                <p style="font-size:14px">
+                    Make sure you use a modern browser with WebGL and WASM enabled.
+                </p>`;
+        }
+    </script>
+</body>
+
+</html>
+
+<!-- Powered by egui: https://github.com/emilk/egui/ -->
diff --git a/egui/docs/multiple_apps.html b/egui/docs/multiple_apps.html
new file mode 100644
index 0000000..e08659c
--- /dev/null
+++ b/egui/docs/multiple_apps.html
@@ -0,0 +1,200 @@
+<!DOCTYPE html>
+<html>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+<!-- Disable zooming: -->
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+
+<head>
+    <title>egui – An immediate mode GUI written in Rust</title>
+    <style>
+        html {
+            /* Remove touch delay: */
+            touch-action: manipulation;
+        }
+
+        body {
+            /* Light mode background color for what is not covered by the egui canvas,
+            or where the egui canvas is translucent. */
+            background: #909090;
+            display:flex;
+        }
+
+        .canvas_wrap{
+            /* height: 200px; */
+            width: 400px;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            body {
+                /* Dark mode background color for what is not covered by the egui canvas,
+                or where the egui canvas is translucent. */
+                background: #404040;
+            }
+        }
+
+        /* Allow canvas to fill entire web page: */
+        html,
+        body {
+            overflow: hidden;
+            margin: 0 !important;
+            padding: 0 !important;
+            height: 100%;
+            width: 100%;
+        }
+
+        /* Position canvas in center-top: */
+        canvas {
+            /* margin-right: auto;
+            margin-left: auto; */
+            /* display: block;
+            position: absolute;
+            top: 0%;
+            left: 50%;
+            transform: translate(-50%, 0%); */
+            width:90%;
+            height:90%;
+        }
+
+        .centered {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            color: #f0f0f0;
+            font-size: 24px;
+            font-family: Ubuntu-Light, Helvetica, sans-serif;
+            text-align: center;
+        }
+
+        /* ---------------------------------------------- */
+        /* Loading animation from https://loading.io/css/ */
+        .lds-dual-ring {
+            display: inline-block;
+            width: 24px;
+            height: 24px;
+        }
+
+        .lds-dual-ring:after {
+            content: " ";
+            display: block;
+            width: 24px;
+            height: 24px;
+            margin: 0px;
+            border-radius: 50%;
+            border: 3px solid #fff;
+            border-color: #fff transparent #fff transparent;
+            animation: lds-dual-ring 1.2s linear infinite;
+        }
+
+        @keyframes lds-dual-ring {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <!-- The WASM code will resize the canvas dynamically -->
+
+    <div>controls</div>
+
+    <button class="stop_one">
+    stop    
+    </button>
+
+    <div class="canvas_wrap one">
+        <canvas id="the_canvas_id_one"></canvas>
+    </div>
+
+    <div  class="canvas_wrap two">
+        <canvas id="the_canvas_id_two"></canvas>
+    </div>
+
+
+
+    <div class="centered" id="center_text">
+        <p style="font-size:16px">
+            Loading…
+        </p>
+        <div class="lds-dual-ring"></div>
+    </div>
+
+    <script>
+        // The `--no-modules`-generated JS from `wasm-bindgen` attempts to use
+        // `WebAssembly.instantiateStreaming` to instantiate the wasm module,
+        // but this doesn't work with `file://` urls. This example is frequently
+        // viewed by simply opening `index.html` in a browser (with a `file://`
+        // url), so it would fail if we were to call this function!
+        //
+        // Work around this for now by deleting the function to ensure that the
+        // `no_modules.js` script doesn't have access to it. You won't need this
+        // hack when deploying over HTTP.
+        delete WebAssembly.instantiateStreaming;
+    </script>
+
+    <!-- this is the JS generated by the `wasm-bindgen` CLI tool -->
+    <script src="egui_demo_app.js"></script>
+
+    <script>
+        // We'll defer our execution until the wasm is ready to go.
+        // Here we tell bindgen the path to the wasm file so it can start
+        // initialization and return to us a promise when it's done.
+        console.debug("loading wasm…");
+        wasm_bindgen("./egui_demo_app_bg.wasm")
+            .then(on_wasm_loaded)
+            .catch(on_wasm_error);
+
+        function on_wasm_loaded() {
+            console.debug("wasm loaded. starting app…");
+
+            // This call installs a bunch of callbacks and then returns:
+
+            wasm_bindgen.init_wasm_hooks()
+
+            const handle_one = wasm_bindgen.start_separate("the_canvas_id_one");
+            const handle_two = wasm_bindgen.start_separate("the_canvas_id_two");
+
+            const button = document.getElementsByClassName("stop_one")[0]
+
+            button.addEventListener("click", ()=>{
+                handle_one.stop_web()
+                handle_one.free()
+            });
+    
+
+            // call `handle.stop_web()` to stop
+            // uncomment to quick result
+            // setTimeout(() => {handle.stop_web()}, 2000)
+
+            console.debug("app started.");
+            document.getElementById("center_text").remove();
+        }
+
+        function on_wasm_error(error) {
+            console.error("Failed to start: " + error);
+            document.getElementById("center_text").innerHTML = `
+                <p>
+                    An error occurred during loading:
+                </p>
+                <p style="font-family:Courier New">
+                    ${error}
+                </p>
+                <p style="font-size:14px">
+                    Make sure you use a modern browser with WebGL and WASM enabled.
+                </p>`;
+        }
+    </script>
+</body>
+
+</html>
+
+<!-- Powered by egui: https://github.com/emilk/egui/ -->
diff --git a/egui/examples/README.md b/egui/examples/README.md
new file mode 100644
index 0000000..43bf63f
--- /dev/null
+++ b/egui/examples/README.md
@@ -0,0 +1,10 @@
+# `egui` and `eframe` examples
+All the examples in this folder uses [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) to set up a window for [`egui`](https://github.com/emilk/egui/). Some examples are specific to `eframe`, but many are applicable to any `egui` integration.
+
+There are a lot more examples at <https://www.egui.rs>, and it has links to the source code of each example.
+
+Also check out the official docs at <https://docs.rs/egui> and <https://docs.rs/eframe>.
+
+Note that all the examples on `master` are for the latest `master` version of `egui`.
+
+If you want to look for examples for a specific version of egui, go to that tag, e.g. <https://github.com/emilk/egui/tree/latest/examples>.
diff --git a/egui/examples/confirm_exit/Cargo.toml b/egui/examples/confirm_exit/Cargo.toml
new file mode 100644
index 0000000..d2c9865
--- /dev/null
+++ b/egui/examples/confirm_exit/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "confirm_exit"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
diff --git a/egui/examples/confirm_exit/README.md b/egui/examples/confirm_exit/README.md
new file mode 100644
index 0000000..846d0ba
--- /dev/null
+++ b/egui/examples/confirm_exit/README.md
@@ -0,0 +1,7 @@
+Example how to show a confirm dialog before exiting an application.
+
+```sh
+cargo run -p confirm_exit
+```
+
+![](screenshot.png)
diff --git a/egui/examples/confirm_exit/screenshot.png b/egui/examples/confirm_exit/screenshot.png
new file mode 100644
index 0000000..062cd88
Binary files /dev/null and b/egui/examples/confirm_exit/screenshot.png differ
diff --git a/egui/examples/confirm_exit/src/main.rs b/egui/examples/confirm_exit/src/main.rs
new file mode 100644
index 0000000..eeb25d8
--- /dev/null
+++ b/egui/examples/confirm_exit/src/main.rs
@@ -0,0 +1,53 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(320.0, 240.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Confirm exit",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+#[derive(Default)]
+struct MyApp {
+    allowed_to_close: bool,
+    show_confirmation_dialog: bool,
+}
+
+impl eframe::App for MyApp {
+    fn on_close_event(&mut self) -> bool {
+        self.show_confirmation_dialog = true;
+        self.allowed_to_close
+    }
+
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Try to close the window");
+        });
+
+        if self.show_confirmation_dialog {
+            // Show confirmation dialog:
+            egui::Window::new("Do you want to quit?")
+                .collapsible(false)
+                .resizable(false)
+                .show(ctx, |ui| {
+                    ui.horizontal(|ui| {
+                        if ui.button("Cancel").clicked() {
+                            self.show_confirmation_dialog = false;
+                        }
+
+                        if ui.button("Yes!").clicked() {
+                            self.allowed_to_close = true;
+                            frame.close();
+                        }
+                    });
+                });
+        }
+    }
+}
diff --git a/egui/examples/custom_3d_glow/Cargo.toml b/egui/examples/custom_3d_glow/Cargo.toml
new file mode 100644
index 0000000..c71c45e
--- /dev/null
+++ b/egui/examples/custom_3d_glow/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "custom_3d_glow"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+egui_glow = { path = "../../crates/egui_glow" }
+glow = "0.12"
diff --git a/egui/examples/custom_3d_glow/README.md b/egui/examples/custom_3d_glow/README.md
new file mode 100644
index 0000000..08f4636
--- /dev/null
+++ b/egui/examples/custom_3d_glow/README.md
@@ -0,0 +1,17 @@
+This demo shows how to embed 3D rendering using [`glow`](https://github.com/grovesNL/glow) in `eframe`.
+
+This is very advanced usage, and you need to be careful.
+
+If you want an easier way to show 3D graphics with egui, take a look at the `custom_3d_three-d.rs` example.
+
+If you are content of having egui sit on top of a 3D background, take a look at:
+
+* [`bevy_egui`](https://github.com/mvlabat/bevy_egui)
+* [`three-d`](https://github.com/asny/three-d)
+
+
+```sh
+cargo run -p custom_3d_glow
+```
+
+![](screenshot.png)
diff --git a/egui/examples/custom_3d_glow/screenshot.png b/egui/examples/custom_3d_glow/screenshot.png
new file mode 100644
index 0000000..cb33155
Binary files /dev/null and b/egui/examples/custom_3d_glow/screenshot.png differ
diff --git a/egui/examples/custom_3d_glow/src/main.rs b/egui/examples/custom_3d_glow/src/main.rs
new file mode 100644
index 0000000..dfca8c2
--- /dev/null
+++ b/egui/examples/custom_3d_glow/src/main.rs
@@ -0,0 +1,199 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+#![allow(unsafe_code)]
+
+use eframe::egui;
+
+use egui::mutex::Mutex;
+use std::sync::Arc;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(350.0, 380.0)),
+        multisampling: 4,
+        renderer: eframe::Renderer::Glow,
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Custom 3D painting in eframe using glow",
+        options,
+        Box::new(|cc| Box::new(MyApp::new(cc))),
+    )
+}
+
+struct MyApp {
+    /// Behind an `Arc<Mutex<…>>` so we can pass it to [`egui::PaintCallback`] and paint later.
+    rotating_triangle: Arc<Mutex<RotatingTriangle>>,
+    angle: f32,
+}
+
+impl MyApp {
+    fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        let gl = cc
+            .gl
+            .as_ref()
+            .expect("You need to run eframe with the glow backend");
+        Self {
+            rotating_triangle: Arc::new(Mutex::new(RotatingTriangle::new(gl))),
+            angle: 0.0,
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.horizontal(|ui| {
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("The triangle is being painted using ");
+                ui.hyperlink_to("glow", "https://github.com/grovesNL/glow");
+                ui.label(" (OpenGL).");
+            });
+
+            egui::Frame::canvas(ui.style()).show(ui, |ui| {
+                self.custom_painting(ui);
+            });
+            ui.label("Drag to rotate!");
+        });
+    }
+
+    fn on_exit(&mut self, gl: Option<&glow::Context>) {
+        if let Some(gl) = gl {
+            self.rotating_triangle.lock().destroy(gl);
+        }
+    }
+}
+
+impl MyApp {
+    fn custom_painting(&mut self, ui: &mut egui::Ui) {
+        let (rect, response) =
+            ui.allocate_exact_size(egui::Vec2::splat(300.0), egui::Sense::drag());
+
+        self.angle += response.drag_delta().x * 0.01;
+
+        // Clone locals so we can move them into the paint callback:
+        let angle = self.angle;
+        let rotating_triangle = self.rotating_triangle.clone();
+
+        let callback = egui::PaintCallback {
+            rect,
+            callback: std::sync::Arc::new(egui_glow::CallbackFn::new(move |_info, painter| {
+                rotating_triangle.lock().paint(painter.gl(), angle);
+            })),
+        };
+        ui.painter().add(callback);
+    }
+}
+
+struct RotatingTriangle {
+    program: glow::Program,
+    vertex_array: glow::VertexArray,
+}
+
+impl RotatingTriangle {
+    fn new(gl: &glow::Context) -> Self {
+        use glow::HasContext as _;
+
+        let shader_version = if cfg!(target_arch = "wasm32") {
+            "#version 300 es"
+        } else {
+            "#version 330"
+        };
+
+        unsafe {
+            let program = gl.create_program().expect("Cannot create program");
+
+            let (vertex_shader_source, fragment_shader_source) = (
+                r#"
+                    const vec2 verts[3] = vec2[3](
+                        vec2(0.0, 1.0),
+                        vec2(-1.0, -1.0),
+                        vec2(1.0, -1.0)
+                    );
+                    const vec4 colors[3] = vec4[3](
+                        vec4(1.0, 0.0, 0.0, 1.0),
+                        vec4(0.0, 1.0, 0.0, 1.0),
+                        vec4(0.0, 0.0, 1.0, 1.0)
+                    );
+                    out vec4 v_color;
+                    uniform float u_angle;
+                    void main() {
+                        v_color = colors[gl_VertexID];
+                        gl_Position = vec4(verts[gl_VertexID], 0.0, 1.0);
+                        gl_Position.x *= cos(u_angle);
+                    }
+                "#,
+                r#"
+                    precision mediump float;
+                    in vec4 v_color;
+                    out vec4 out_color;
+                    void main() {
+                        out_color = v_color;
+                    }
+                "#,
+            );
+
+            let shader_sources = [
+                (glow::VERTEX_SHADER, vertex_shader_source),
+                (glow::FRAGMENT_SHADER, fragment_shader_source),
+            ];
+
+            let shaders: Vec<_> = shader_sources
+                .iter()
+                .map(|(shader_type, shader_source)| {
+                    let shader = gl
+                        .create_shader(*shader_type)
+                        .expect("Cannot create shader");
+                    gl.shader_source(shader, &format!("{}\n{}", shader_version, shader_source));
+                    gl.compile_shader(shader);
+                    assert!(
+                        gl.get_shader_compile_status(shader),
+                        "Failed to compile {shader_type}: {}",
+                        gl.get_shader_info_log(shader)
+                    );
+                    gl.attach_shader(program, shader);
+                    shader
+                })
+                .collect();
+
+            gl.link_program(program);
+            if !gl.get_program_link_status(program) {
+                panic!("{}", gl.get_program_info_log(program));
+            }
+
+            for shader in shaders {
+                gl.detach_shader(program, shader);
+                gl.delete_shader(shader);
+            }
+
+            let vertex_array = gl
+                .create_vertex_array()
+                .expect("Cannot create vertex array");
+
+            Self {
+                program,
+                vertex_array,
+            }
+        }
+    }
+
+    fn destroy(&self, gl: &glow::Context) {
+        use glow::HasContext as _;
+        unsafe {
+            gl.delete_program(self.program);
+            gl.delete_vertex_array(self.vertex_array);
+        }
+    }
+
+    fn paint(&self, gl: &glow::Context, angle: f32) {
+        use glow::HasContext as _;
+        unsafe {
+            gl.use_program(Some(self.program));
+            gl.uniform_1_f32(
+                gl.get_uniform_location(self.program, "u_angle").as_ref(),
+                angle,
+            );
+            gl.bind_vertex_array(Some(self.vertex_array));
+            gl.draw_arrays(glow::TRIANGLES, 0, 3);
+        }
+    }
+}
diff --git a/egui/examples/custom_font/Cargo.toml b/egui/examples/custom_font/Cargo.toml
new file mode 100644
index 0000000..15eee8a
--- /dev/null
+++ b/egui/examples/custom_font/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "custom_font"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
diff --git a/egui/examples/custom_font/README.md b/egui/examples/custom_font/README.md
new file mode 100644
index 0000000..735098a
--- /dev/null
+++ b/egui/examples/custom_font/README.md
@@ -0,0 +1,7 @@
+Example of how to use custom fonts.
+
+```sh
+cargo run -p custom_font
+```
+
+![](screenshot.png)
diff --git a/egui/examples/custom_font/screenshot.png b/egui/examples/custom_font/screenshot.png
new file mode 100644
index 0000000..abf60ca
Binary files /dev/null and b/egui/examples/custom_font/screenshot.png differ
diff --git a/egui/examples/custom_font/src/main.rs b/egui/examples/custom_font/src/main.rs
new file mode 100644
index 0000000..409230d
--- /dev/null
+++ b/egui/examples/custom_font/src/main.rs
@@ -0,0 +1,68 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(320.0, 240.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "egui example: custom font",
+        options,
+        Box::new(|cc| Box::new(MyApp::new(cc))),
+    )
+}
+
+fn setup_custom_fonts(ctx: &egui::Context) {
+    // Start with the default fonts (we will be adding to them rather than replacing them).
+    let mut fonts = egui::FontDefinitions::default();
+
+    // Install my own font (maybe supporting non-latin characters).
+    // .ttf and .otf files supported.
+    fonts.font_data.insert(
+        "my_font".to_owned(),
+        egui::FontData::from_static(include_bytes!(
+            "../../../crates/epaint/fonts/Hack-Regular.ttf"
+        )),
+    );
+
+    // Put my font first (highest priority) for proportional text:
+    fonts
+        .families
+        .entry(egui::FontFamily::Proportional)
+        .or_default()
+        .insert(0, "my_font".to_owned());
+
+    // Put my font as last fallback for monospace:
+    fonts
+        .families
+        .entry(egui::FontFamily::Monospace)
+        .or_default()
+        .push("my_font".to_owned());
+
+    // Tell egui to use these fonts:
+    ctx.set_fonts(fonts);
+}
+
+struct MyApp {
+    text: String,
+}
+
+impl MyApp {
+    fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        setup_custom_fonts(&cc.egui_ctx);
+        Self {
+            text: "Edit this text field if you want".to_owned(),
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("egui using custom fonts");
+            ui.text_edit_multiline(&mut self.text);
+        });
+    }
+}
diff --git a/egui/examples/custom_font_style/Cargo.toml b/egui/examples/custom_font_style/Cargo.toml
new file mode 100644
index 0000000..c7a6fcd
--- /dev/null
+++ b/egui/examples/custom_font_style/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "custom_font_style"
+version = "0.1.0"
+authors = ["tami5 <kkharji@proton.me>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
diff --git a/egui/examples/custom_font_style/README.md b/egui/examples/custom_font_style/README.md
new file mode 100644
index 0000000..66fdac2
--- /dev/null
+++ b/egui/examples/custom_font_style/README.md
@@ -0,0 +1,7 @@
+Example how to define custom test styles.
+
+```sh
+cargo run -p custom_font_style
+```
+
+![](screenshot.png)
diff --git a/egui/examples/custom_font_style/screenshot.png b/egui/examples/custom_font_style/screenshot.png
new file mode 100644
index 0000000..5ab1a29
Binary files /dev/null and b/egui/examples/custom_font_style/screenshot.png differ
diff --git a/egui/examples/custom_font_style/src/main.rs b/egui/examples/custom_font_style/src/main.rs
new file mode 100644
index 0000000..b0bb559
--- /dev/null
+++ b/egui/examples/custom_font_style/src/main.rs
@@ -0,0 +1,71 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+use egui::{FontFamily, FontId, RichText, TextStyle};
+
+#[inline]
+fn heading2() -> TextStyle {
+    TextStyle::Name("Heading2".into())
+}
+
+#[inline]
+fn heading3() -> TextStyle {
+    TextStyle::Name("ContextHeading".into())
+}
+
+fn configure_text_styles(ctx: &egui::Context) {
+    use FontFamily::{Monospace, Proportional};
+
+    let mut style = (*ctx.style()).clone();
+    style.text_styles = [
+        (TextStyle::Heading, FontId::new(25.0, Proportional)),
+        (heading2(), FontId::new(22.0, Proportional)),
+        (heading3(), FontId::new(19.0, Proportional)),
+        (TextStyle::Body, FontId::new(16.0, Proportional)),
+        (TextStyle::Monospace, FontId::new(12.0, Monospace)),
+        (TextStyle::Button, FontId::new(12.0, Proportional)),
+        (TextStyle::Small, FontId::new(8.0, Proportional)),
+    ]
+    .into();
+    ctx.set_style(style);
+}
+
+fn content(ui: &mut egui::Ui) {
+    ui.heading("Top Heading");
+    ui.add_space(5.);
+    ui.label(LOREM_IPSUM);
+    ui.add_space(15.);
+    ui.label(RichText::new("Sub Heading").text_style(heading2()).strong());
+    ui.monospace(LOREM_IPSUM);
+    ui.add_space(15.);
+    ui.label(RichText::new("Context").text_style(heading3()).strong());
+    ui.add_space(5.);
+    ui.label(LOREM_IPSUM);
+}
+
+struct MyApp;
+
+impl MyApp {
+    fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        configure_text_styles(&cc.egui_ctx);
+        Self
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, content);
+    }
+}
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions::default();
+
+    eframe::run_native(
+        "egui example: global font style",
+        options,
+        Box::new(|cc| Box::new(MyApp::new(cc))),
+    )
+}
+
+pub const LOREM_IPSUM: &str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
diff --git a/egui/examples/custom_window_frame/Cargo.toml b/egui/examples/custom_window_frame/Cargo.toml
new file mode 100644
index 0000000..5c52ce8
--- /dev/null
+++ b/egui/examples/custom_window_frame/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "custom_window_frame"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
diff --git a/egui/examples/custom_window_frame/README.md b/egui/examples/custom_window_frame/README.md
new file mode 100644
index 0000000..c300f40
--- /dev/null
+++ b/egui/examples/custom_window_frame/README.md
@@ -0,0 +1,7 @@
+Example how to show a custom window frame instead of the default OS window chrome decorations.
+
+```sh
+cargo run -p custom_window_frame
+```
+
+![](screenshot.png)
diff --git a/egui/examples/custom_window_frame/screenshot.png b/egui/examples/custom_window_frame/screenshot.png
new file mode 100644
index 0000000..50b5dd2
Binary files /dev/null and b/egui/examples/custom_window_frame/screenshot.png differ
diff --git a/egui/examples/custom_window_frame/src/main.rs b/egui/examples/custom_window_frame/src/main.rs
new file mode 100644
index 0000000..4c07416
--- /dev/null
+++ b/egui/examples/custom_window_frame/src/main.rs
@@ -0,0 +1,164 @@
+//! Show a custom window frame instead of the default OS window chrome decorations.
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        // Hide the OS-specific "chrome" around the window:
+        decorated: false,
+        // To have rounded corners we need transparency:
+        transparent: true,
+        min_window_size: Some(egui::vec2(400.0, 100.0)),
+        initial_window_size: Some(egui::vec2(400.0, 240.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Custom window frame", // unused title
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+#[derive(Default)]
+struct MyApp {}
+
+impl eframe::App for MyApp {
+    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
+        egui::Rgba::TRANSPARENT.to_array() // Make sure we don't paint anything behind the rounded corners
+    }
+
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        custom_window_frame(ctx, frame, "egui with custom frame", |ui| {
+            ui.label("This is just the contents of the window.");
+            ui.horizontal(|ui| {
+                ui.label("egui theme:");
+                egui::widgets::global_dark_light_mode_buttons(ui);
+            });
+        });
+    }
+}
+
+fn custom_window_frame(
+    ctx: &egui::Context,
+    frame: &mut eframe::Frame,
+    title: &str,
+    add_contents: impl FnOnce(&mut egui::Ui),
+) {
+    use egui::*;
+
+    let panel_frame = egui::Frame {
+        fill: ctx.style().visuals.window_fill(),
+        rounding: 10.0.into(),
+        stroke: ctx.style().visuals.widgets.noninteractive.fg_stroke,
+        outer_margin: 0.5.into(), // so the stroke is within the bounds
+        ..Default::default()
+    };
+
+    CentralPanel::default().frame(panel_frame).show(ctx, |ui| {
+        let app_rect = ui.max_rect();
+
+        let title_bar_height = 32.0;
+        let title_bar_rect = {
+            let mut rect = app_rect;
+            rect.max.y = rect.min.y + title_bar_height;
+            rect
+        };
+        title_bar_ui(ui, frame, title_bar_rect, title);
+
+        // Add the contents:
+        let content_rect = {
+            let mut rect = app_rect;
+            rect.min.y = title_bar_rect.max.y;
+            rect
+        }
+        .shrink(4.0);
+        let mut content_ui = ui.child_ui(content_rect, *ui.layout());
+        add_contents(&mut content_ui);
+    });
+}
+
+fn title_bar_ui(
+    ui: &mut egui::Ui,
+    frame: &mut eframe::Frame,
+    title_bar_rect: eframe::epaint::Rect,
+    title: &str,
+) {
+    use egui::*;
+
+    let painter = ui.painter();
+
+    let title_bar_response = ui.interact(title_bar_rect, Id::new("title_bar"), Sense::click());
+
+    // Paint the title:
+    painter.text(
+        title_bar_rect.center(),
+        Align2::CENTER_CENTER,
+        title,
+        FontId::proportional(20.0),
+        ui.style().visuals.text_color(),
+    );
+
+    // Paint the line under the title:
+    painter.line_segment(
+        [
+            title_bar_rect.left_bottom() + vec2(1.0, 0.0),
+            title_bar_rect.right_bottom() + vec2(-1.0, 0.0),
+        ],
+        ui.visuals().widgets.noninteractive.bg_stroke,
+    );
+
+    // Interact with the title bar (drag to move window):
+    if title_bar_response.double_clicked() {
+        frame.set_maximized(!frame.info().window_info.maximized);
+    } else if title_bar_response.is_pointer_button_down_on() {
+        frame.drag_window();
+    }
+
+    ui.allocate_ui_at_rect(title_bar_rect, |ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            ui.spacing_mut().item_spacing.x = 0.0;
+            ui.visuals_mut().button_frame = false;
+            ui.add_space(8.0);
+            close_maximize_minimize(ui, frame);
+        });
+    });
+}
+
+/// Show some close/maximize/minimize buttons for the native window.
+fn close_maximize_minimize(ui: &mut egui::Ui, frame: &mut eframe::Frame) {
+    use egui::{Button, RichText};
+
+    let button_height = 12.0;
+
+    let close_response = ui
+        .add(Button::new(RichText::new("❌").size(button_height)))
+        .on_hover_text("Close the window");
+    if close_response.clicked() {
+        frame.close();
+    }
+
+    if frame.info().window_info.maximized {
+        let maximized_response = ui
+            .add(Button::new(RichText::new("🗗").size(button_height)))
+            .on_hover_text("Restore window");
+        if maximized_response.clicked() {
+            frame.set_maximized(false);
+        }
+    } else {
+        let maximized_response = ui
+            .add(Button::new(RichText::new("🗗").size(button_height)))
+            .on_hover_text("Maximize window");
+        if maximized_response.clicked() {
+            frame.set_maximized(true);
+        }
+    }
+
+    let minimized_response = ui
+        .add(Button::new(RichText::new("🗕").size(button_height)))
+        .on_hover_text("Minimize the window");
+    if minimized_response.clicked() {
+        frame.set_minimized(true);
+    }
+}
diff --git a/egui/examples/download_image/Cargo.toml b/egui/examples/download_image/Cargo.toml
new file mode 100644
index 0000000..f51ab7d
--- /dev/null
+++ b/egui/examples/download_image/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "download_image"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+egui_extras = { path = "../../crates/egui_extras", features = ["image"] }
+ehttp = "0.2"
+image = { version = "0.24", default-features = false, features = ["jpeg"] }
+poll-promise = "0.2"
diff --git a/egui/examples/download_image/README.md b/egui/examples/download_image/README.md
new file mode 100644
index 0000000..936e1e0
--- /dev/null
+++ b/egui/examples/download_image/README.md
@@ -0,0 +1,7 @@
+Example how to download and show an image with eframe/egui.
+
+```sh
+cargo run -p download_image
+```
+
+![](screenshot.png)
diff --git a/egui/examples/download_image/screenshot.png b/egui/examples/download_image/screenshot.png
new file mode 100644
index 0000000..919c454
Binary files /dev/null and b/egui/examples/download_image/screenshot.png differ
diff --git a/egui/examples/download_image/src/main.rs b/egui/examples/download_image/src/main.rs
new file mode 100644
index 0000000..e031cf3
--- /dev/null
+++ b/egui/examples/download_image/src/main.rs
@@ -0,0 +1,64 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+use egui_extras::RetainedImage;
+use poll_promise::Promise;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions::default();
+    eframe::run_native(
+        "Download and show an image with eframe/egui",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+#[derive(Default)]
+struct MyApp {
+    /// `None` when download hasn't started yet.
+    promise: Option<Promise<ehttp::Result<RetainedImage>>>,
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        let promise = self.promise.get_or_insert_with(|| {
+            // Begin download.
+            // We download the image using `ehttp`, a library that works both in WASM and on native.
+            // We use the `poll-promise` library to communicate with the UI thread.
+            let ctx = ctx.clone();
+            let (sender, promise) = Promise::new();
+            let request = ehttp::Request::get("https://picsum.photos/seed/1.759706314/1024");
+            ehttp::fetch(request, move |response| {
+                let image = response.and_then(parse_response);
+                sender.send(image); // send the results back to the UI thread.
+                ctx.request_repaint(); // wake up UI thread
+            });
+            promise
+        });
+
+        egui::CentralPanel::default().show(ctx, |ui| match promise.ready() {
+            None => {
+                ui.spinner(); // still loading
+            }
+            Some(Err(err)) => {
+                ui.colored_label(ui.visuals().error_fg_color, err); // something went wrong
+            }
+            Some(Ok(image)) => {
+                image.show_max_size(ui, ui.available_size());
+            }
+        });
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)]
+fn parse_response(response: ehttp::Response) -> Result<RetainedImage, String> {
+    let content_type = response.content_type().unwrap_or_default();
+    if content_type.starts_with("image/") {
+        RetainedImage::from_image_bytes(&response.url, &response.bytes)
+    } else {
+        Err(format!(
+            "Expected image, found content-type {:?}",
+            content_type
+        ))
+    }
+}
diff --git a/egui/examples/file_dialog/Cargo.toml b/egui/examples/file_dialog/Cargo.toml
new file mode 100644
index 0000000..b5414cc
--- /dev/null
+++ b/egui/examples/file_dialog/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "file_dialog"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+rfd = "0.11"
diff --git a/egui/examples/file_dialog/README.md b/egui/examples/file_dialog/README.md
new file mode 100644
index 0000000..8dff717
--- /dev/null
+++ b/egui/examples/file_dialog/README.md
@@ -0,0 +1,7 @@
+How to show a file dialog using [`rfd`](https://github.com/PolyMeilex/rfd).
+
+```sh
+cargo run -p file_dialog
+```
+
+![](screenshot.png)
diff --git a/egui/examples/file_dialog/screenshot.png b/egui/examples/file_dialog/screenshot.png
new file mode 100644
index 0000000..f2b59d1
Binary files /dev/null and b/egui/examples/file_dialog/screenshot.png differ
diff --git a/egui/examples/file_dialog/src/main.rs b/egui/examples/file_dialog/src/main.rs
new file mode 100644
index 0000000..ca2c021
--- /dev/null
+++ b/egui/examples/file_dialog/src/main.rs
@@ -0,0 +1,109 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        drag_and_drop_support: true,
+        initial_window_size: Some(egui::vec2(320.0, 240.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Native file dialogs and drag-and-drop files",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+#[derive(Default)]
+struct MyApp {
+    dropped_files: Vec<egui::DroppedFile>,
+    picked_path: Option<String>,
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.label("Drag-and-drop files onto the window!");
+
+            if ui.button("Open file…").clicked() {
+                if let Some(path) = rfd::FileDialog::new().pick_file() {
+                    self.picked_path = Some(path.display().to_string());
+                }
+            }
+
+            if let Some(picked_path) = &self.picked_path {
+                ui.horizontal(|ui| {
+                    ui.label("Picked file:");
+                    ui.monospace(picked_path);
+                });
+            }
+
+            // Show dropped files (if any):
+            if !self.dropped_files.is_empty() {
+                ui.group(|ui| {
+                    ui.label("Dropped files:");
+
+                    for file in &self.dropped_files {
+                        let mut info = if let Some(path) = &file.path {
+                            path.display().to_string()
+                        } else if !file.name.is_empty() {
+                            file.name.clone()
+                        } else {
+                            "???".to_owned()
+                        };
+                        if let Some(bytes) = &file.bytes {
+                            use std::fmt::Write as _;
+                            write!(info, " ({} bytes)", bytes.len()).ok();
+                        }
+                        ui.label(info);
+                    }
+                });
+            }
+        });
+
+        preview_files_being_dropped(ctx);
+
+        // Collect dropped files:
+        ctx.input(|i| {
+            if !i.raw.dropped_files.is_empty() {
+                self.dropped_files = i.raw.dropped_files.clone();
+            }
+        });
+    }
+}
+
+/// Preview hovering files:
+fn preview_files_being_dropped(ctx: &egui::Context) {
+    use egui::*;
+    use std::fmt::Write as _;
+
+    if !ctx.input(|i| i.raw.hovered_files.is_empty()) {
+        let text = ctx.input(|i| {
+            let mut text = "Dropping files:\n".to_owned();
+            for file in &i.raw.hovered_files {
+                if let Some(path) = &file.path {
+                    write!(text, "\n{}", path.display()).ok();
+                } else if !file.mime.is_empty() {
+                    write!(text, "\n{}", file.mime).ok();
+                } else {
+                    text += "\n???";
+                }
+            }
+            text
+        });
+
+        let painter =
+            ctx.layer_painter(LayerId::new(Order::Foreground, Id::new("file_drop_target")));
+
+        let screen_rect = ctx.screen_rect();
+        painter.rect_filled(screen_rect, 0.0, Color32::from_black_alpha(192));
+        painter.text(
+            screen_rect.center(),
+            Align2::CENTER_CENTER,
+            text,
+            TextStyle::Heading.resolve(&ctx.style()),
+            Color32::WHITE,
+        );
+    }
+}
diff --git a/egui/examples/hello_world/Cargo.toml b/egui/examples/hello_world/Cargo.toml
new file mode 100644
index 0000000..0c58572
--- /dev/null
+++ b/egui/examples/hello_world/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "hello_world"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+tracing-subscriber = "0.3"
diff --git a/egui/examples/hello_world/README.md b/egui/examples/hello_world/README.md
new file mode 100644
index 0000000..08c58a7
--- /dev/null
+++ b/egui/examples/hello_world/README.md
@@ -0,0 +1,7 @@
+Example showing some UI controls like `Label`, `TextEdit`, `Slider`, `Button`.
+
+```sh
+cargo run -p hello_world
+```
+
+![](screenshot.png)
diff --git a/egui/examples/hello_world/screenshot.png b/egui/examples/hello_world/screenshot.png
new file mode 100644
index 0000000..09c7af2
Binary files /dev/null and b/egui/examples/hello_world/screenshot.png differ
diff --git a/egui/examples/hello_world/src/main.rs b/egui/examples/hello_world/src/main.rs
new file mode 100644
index 0000000..6b0f2f0
--- /dev/null
+++ b/egui/examples/hello_world/src/main.rs
@@ -0,0 +1,50 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    // Log to stdout (if you run with `RUST_LOG=debug`).
+    tracing_subscriber::fmt::init();
+
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(320.0, 240.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "My egui App",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+struct MyApp {
+    name: String,
+    age: u32,
+}
+
+impl Default for MyApp {
+    fn default() -> Self {
+        Self {
+            name: "Arthur".to_owned(),
+            age: 42,
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("My egui Application");
+            ui.horizontal(|ui| {
+                let name_label = ui.label("Your name: ");
+                ui.text_edit_singleline(&mut self.name)
+                    .labelled_by(name_label.id);
+            });
+            ui.add(egui::Slider::new(&mut self.age, 0..=120).text("age"));
+            if ui.button("Click each year").clicked() {
+                self.age += 1;
+            }
+            ui.label(format!("Hello '{}', age {}", self.name, self.age));
+        });
+    }
+}
diff --git a/egui/examples/hello_world_par/Cargo.toml b/egui/examples/hello_world_par/Cargo.toml
new file mode 100644
index 0000000..253fda8
--- /dev/null
+++ b/egui/examples/hello_world_par/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "hello_world_par"
+version = "0.1.0"
+authors = ["Maxim Osipenko <maxim1999max@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", default-features = false, features = [
+    # accesskit struggles with threading
+    "default_fonts",
+    "wgpu",
+] }
diff --git a/egui/examples/hello_world_par/README.md b/egui/examples/hello_world_par/README.md
new file mode 100644
index 0000000..6b1a0df
--- /dev/null
+++ b/egui/examples/hello_world_par/README.md
@@ -0,0 +1,5 @@
+This example shows that you can use egui in parallel from multiple threads.
+
+```sh
+cargo run -p hello_world_par
+```
diff --git a/egui/examples/hello_world_par/src/main.rs b/egui/examples/hello_world_par/src/main.rs
new file mode 100644
index 0000000..0d3ca9b
--- /dev/null
+++ b/egui/examples/hello_world_par/src/main.rs
@@ -0,0 +1,132 @@
+//! This example shows that you can use egui in parallel from multiple threads.
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use std::sync::mpsc;
+use std::thread::JoinHandle;
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(1024.0, 768.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "My parallel egui App",
+        options,
+        Box::new(|_cc| Box::new(MyApp::new())),
+    )
+}
+
+/// State per thread.
+struct ThreadState {
+    thread_nr: usize,
+    title: String,
+    name: String,
+    age: u32,
+}
+
+impl ThreadState {
+    fn new(thread_nr: usize) -> Self {
+        let title = format!("Background thread {thread_nr}");
+        Self {
+            thread_nr,
+            title,
+            name: "Arthur".into(),
+            age: 12 + thread_nr as u32 * 10,
+        }
+    }
+
+    fn show(&mut self, ctx: &egui::Context) {
+        let pos = egui::pos2(16.0, 128.0 * (self.thread_nr as f32 + 1.0));
+        egui::Window::new(&self.title)
+            .default_pos(pos)
+            .show(ctx, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label("Your name: ");
+                    ui.text_edit_singleline(&mut self.name);
+                });
+                ui.add(egui::Slider::new(&mut self.age, 0..=120).text("age"));
+                if ui.button("Click each year").clicked() {
+                    self.age += 1;
+                }
+                ui.label(format!("Hello '{}', age {}", self.name, self.age));
+            });
+    }
+}
+
+fn new_worker(
+    thread_nr: usize,
+    on_done_tx: mpsc::SyncSender<()>,
+) -> (JoinHandle<()>, mpsc::SyncSender<egui::Context>) {
+    let (show_tx, show_rc) = mpsc::sync_channel(0);
+    let handle = std::thread::Builder::new()
+        .name(format!("EguiPanelWorker {}", thread_nr))
+        .spawn(move || {
+            let mut state = ThreadState::new(thread_nr);
+            while let Ok(ctx) = show_rc.recv() {
+                state.show(&ctx);
+                let _ = on_done_tx.send(());
+            }
+        })
+        .expect("failed to spawn thread");
+    (handle, show_tx)
+}
+
+struct MyApp {
+    threads: Vec<(JoinHandle<()>, mpsc::SyncSender<egui::Context>)>,
+    on_done_tx: mpsc::SyncSender<()>,
+    on_done_rc: mpsc::Receiver<()>,
+}
+
+impl MyApp {
+    fn new() -> Self {
+        let threads = Vec::with_capacity(3);
+        let (on_done_tx, on_done_rc) = mpsc::sync_channel(0);
+
+        let mut slf = Self {
+            threads,
+            on_done_tx,
+            on_done_rc,
+        };
+
+        slf.spawn_thread();
+        slf.spawn_thread();
+
+        slf
+    }
+
+    fn spawn_thread(&mut self) {
+        let thread_nr = self.threads.len();
+        self.threads
+            .push(new_worker(thread_nr, self.on_done_tx.clone()));
+    }
+}
+
+impl std::ops::Drop for MyApp {
+    fn drop(&mut self) {
+        for (handle, show_tx) in self.threads.drain(..) {
+            std::mem::drop(show_tx);
+            handle.join().unwrap();
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::Window::new("Main thread").show(ctx, |ui| {
+            if ui.button("Spawn another thread").clicked() {
+                self.spawn_thread();
+            }
+        });
+
+        for (_handle, show_tx) in &self.threads {
+            let _ = show_tx.send(ctx.clone());
+        }
+
+        for _ in 0..self.threads.len() {
+            let _ = self.on_done_rc.recv();
+        }
+    }
+}
diff --git a/egui/examples/hello_world_simple/Cargo.toml b/egui/examples/hello_world_simple/Cargo.toml
new file mode 100644
index 0000000..e138c82
--- /dev/null
+++ b/egui/examples/hello_world_simple/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "hello_world_simple"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+tracing-subscriber = "0.3"
diff --git a/egui/examples/hello_world_simple/README.md b/egui/examples/hello_world_simple/README.md
new file mode 100644
index 0000000..08c58a7
--- /dev/null
+++ b/egui/examples/hello_world_simple/README.md
@@ -0,0 +1,7 @@
+Example showing some UI controls like `Label`, `TextEdit`, `Slider`, `Button`.
+
+```sh
+cargo run -p hello_world
+```
+
+![](screenshot.png)
diff --git a/egui/examples/hello_world_simple/screenshot.png b/egui/examples/hello_world_simple/screenshot.png
new file mode 100644
index 0000000..765339d
Binary files /dev/null and b/egui/examples/hello_world_simple/screenshot.png differ
diff --git a/egui/examples/hello_world_simple/src/main.rs b/egui/examples/hello_world_simple/src/main.rs
new file mode 100644
index 0000000..cecc680
--- /dev/null
+++ b/egui/examples/hello_world_simple/src/main.rs
@@ -0,0 +1,33 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    // Log to stdout (if you run with `RUST_LOG=debug`).
+    tracing_subscriber::fmt::init();
+
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(320.0, 240.0)),
+        ..Default::default()
+    };
+
+    // Our application state:
+    let mut name = "Arthur".to_owned();
+    let mut age = 42;
+
+    eframe::run_simple_native("My egui App", options, move |ctx, _frame| {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("My egui Application");
+            ui.horizontal(|ui| {
+                let name_label = ui.label("Your name: ");
+                ui.text_edit_singleline(&mut name)
+                    .labelled_by(name_label.id);
+            });
+            ui.add(egui::Slider::new(&mut age, 0..=120).text("age"));
+            if ui.button("Click each year").clicked() {
+                age += 1;
+            }
+            ui.label(format!("Hello '{}', age {}", name, age));
+        });
+    })
+}
diff --git a/egui/examples/keyboard_events/Cargo.toml b/egui/examples/keyboard_events/Cargo.toml
new file mode 100644
index 0000000..df7681f
--- /dev/null
+++ b/egui/examples/keyboard_events/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "keyboard_events"
+version = "0.1.0"
+authors = ["Jose Palazon <jose@palako.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+tracing-subscriber = "0.3"
diff --git a/egui/examples/keyboard_events/README.md b/egui/examples/keyboard_events/README.md
new file mode 100644
index 0000000..6f88b6c
--- /dev/null
+++ b/egui/examples/keyboard_events/README.md
@@ -0,0 +1,5 @@
+```sh
+cargo run -p keyboard_events
+```
+
+![](screenshot.png)
diff --git a/egui/examples/keyboard_events/screenshot.png b/egui/examples/keyboard_events/screenshot.png
new file mode 100644
index 0000000..b8ab117
Binary files /dev/null and b/egui/examples/keyboard_events/screenshot.png differ
diff --git a/egui/examples/keyboard_events/src/main.rs b/egui/examples/keyboard_events/src/main.rs
new file mode 100644
index 0000000..86f3a8e
--- /dev/null
+++ b/egui/examples/keyboard_events/src/main.rs
@@ -0,0 +1,49 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+use egui::*;
+
+fn main() -> Result<(), eframe::Error> {
+    // Log to stdout (if you run with `RUST_LOG=debug`).
+    tracing_subscriber::fmt::init();
+
+    let options = eframe::NativeOptions::default();
+    eframe::run_native(
+        "Keyboard events",
+        options,
+        Box::new(|_cc| Box::new(Content::default())),
+    )
+}
+
+#[derive(Default)]
+struct Content {
+    text: String,
+}
+
+impl eframe::App for Content {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Press/Hold/Release example. Press A to test.");
+            if ui.button("Clear").clicked() {
+                self.text.clear();
+            }
+            ScrollArea::vertical()
+                .auto_shrink([false; 2])
+                .stick_to_bottom(true)
+                .show(ui, |ui| {
+                    ui.label(&self.text);
+                });
+
+            if ctx.input(|i| i.key_pressed(Key::A)) {
+                self.text.push_str("\nPressed");
+            }
+            if ctx.input(|i| i.key_down(Key::A)) {
+                self.text.push_str("\nHeld");
+                ui.ctx().request_repaint(); // make sure we note the holding.
+            }
+            if ctx.input(|i| i.key_released(Key::A)) {
+                self.text.push_str("\nReleased");
+            }
+        });
+    }
+}
diff --git a/egui/examples/puffin_profiler/Cargo.toml b/egui/examples/puffin_profiler/Cargo.toml
new file mode 100644
index 0000000..9027050
--- /dev/null
+++ b/egui/examples/puffin_profiler/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "puffin_profiler"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "puffin",
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+puffin = "0.14"
+puffin_http = "0.11"
diff --git a/egui/examples/puffin_profiler/README.md b/egui/examples/puffin_profiler/README.md
new file mode 100644
index 0000000..4a9a6e4
--- /dev/null
+++ b/egui/examples/puffin_profiler/README.md
@@ -0,0 +1,11 @@
+Example how to use the [puffin profiler](https://github.com/EmbarkStudios/puffin) with an `eframe` app.
+
+
+```sh
+cargo run -p puffin_profiler &
+
+cargo install puffin_viewer
+puffin_viewer --url 127.0.0.1:8585
+```
+
+![](screenshot.png)
diff --git a/egui/examples/puffin_profiler/screenshot.png b/egui/examples/puffin_profiler/screenshot.png
new file mode 100644
index 0000000..fe974d8
Binary files /dev/null and b/egui/examples/puffin_profiler/screenshot.png differ
diff --git a/egui/examples/puffin_profiler/src/main.rs b/egui/examples/puffin_profiler/src/main.rs
new file mode 100644
index 0000000..17d8039
--- /dev/null
+++ b/egui/examples/puffin_profiler/src/main.rs
@@ -0,0 +1,68 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    start_puffin_server(); // NOTE: you may only want to call this if the users specifies some flag or clicks a button!
+
+    let options = eframe::NativeOptions::default();
+    eframe::run_native(
+        "My egui App",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+#[derive(Default)]
+struct MyApp {}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Example of how to use the puffin profiler with egui");
+            ui.separator();
+
+            let cmd = "cargo install puffin_viewer && puffin_viewer --url 127.0.0.1:8585";
+
+            ui.label("To connect, run this:");
+            ui.horizontal(|ui| {
+                ui.monospace(cmd);
+                if ui.small_button("📋").clicked() {
+                    ui.output_mut(|o| o.copied_text = cmd.into());
+                }
+            });
+
+            ui.separator();
+
+            ui.label("Note that this app runs in 'reactive' mode, so you must interact with the app for new profile events to be sent. Waving the mouse over this window is enough.");
+
+            if ui
+                .button(
+                    "Click to sleep a bit. That should be visible as a spike in the profiler view!",
+                )
+                .clicked()
+            {
+                puffin::profile_scope!("sleep");
+                std::thread::sleep(std::time::Duration::from_millis(50));
+            }
+        });
+    }
+}
+
+fn start_puffin_server() {
+    puffin::set_scopes_on(true); // tell puffin to collect data
+
+    match puffin_http::Server::new("0.0.0.0:8585") {
+        Ok(puffin_server) => {
+            eprintln!("Run:  cargo install puffin_viewer && puffin_viewer --url 127.0.0.1:8585");
+
+            // We can store the server if we want, but in this case we just want
+            // it to keep running. Dropping it closes the server, so let's not drop it!
+            #[allow(clippy::mem_forget)]
+            std::mem::forget(puffin_server);
+        }
+        Err(err) => {
+            eprintln!("Failed to start puffin server: {}", err);
+        }
+    };
+}
diff --git a/egui/examples/retained_image/Cargo.toml b/egui/examples/retained_image/Cargo.toml
new file mode 100644
index 0000000..364df4b
--- /dev/null
+++ b/egui/examples/retained_image/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "retained_image"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+egui_extras = { path = "../../crates/egui_extras", features = ["image"] }
+image = { version = "0.24", default-features = false, features = ["png"] }
diff --git a/egui/examples/retained_image/README.md b/egui/examples/retained_image/README.md
new file mode 100644
index 0000000..122a748
--- /dev/null
+++ b/egui/examples/retained_image/README.md
@@ -0,0 +1,7 @@
+Example how to show an image with eframe/egui.
+
+```sh
+cargo run -p retained_image
+```
+
+![](screenshot.png)
diff --git a/egui/examples/retained_image/screenshot.png b/egui/examples/retained_image/screenshot.png
new file mode 100644
index 0000000..c605558
Binary files /dev/null and b/egui/examples/retained_image/screenshot.png differ
diff --git a/egui/examples/retained_image/src/main.rs b/egui/examples/retained_image/src/main.rs
new file mode 100644
index 0000000..4ccce7a
--- /dev/null
+++ b/egui/examples/retained_image/src/main.rs
@@ -0,0 +1,66 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+use egui_extras::RetainedImage;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(300.0, 900.0)),
+        ..Default::default()
+    };
+
+    eframe::run_native(
+        "Show an image with eframe/egui",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+struct MyApp {
+    image: RetainedImage,
+    tint: egui::Color32,
+}
+
+impl Default for MyApp {
+    fn default() -> Self {
+        Self {
+            image: RetainedImage::from_image_bytes(
+                "rust-logo-256x256.png",
+                include_bytes!("rust-logo-256x256.png"),
+            )
+            .unwrap(),
+            tint: egui::Color32::from_rgb(255, 0, 255),
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("This is an image:");
+            self.image.show(ui);
+
+            ui.heading("This is a rotated image with a tint:");
+            ui.add(
+                egui::Image::new(self.image.texture_id(ctx), self.image.size_vec2())
+                    .rotate(45.0_f32.to_radians(), egui::Vec2::splat(0.5))
+                    .tint(self.tint),
+            );
+
+            ui.horizontal(|ui| {
+                ui.label("Tint:");
+                egui::color_picker::color_edit_button_srgba(
+                    ui,
+                    &mut self.tint,
+                    egui::color_picker::Alpha::BlendOrAdditive,
+                );
+            });
+
+            ui.heading("This is an image you can click:");
+            ui.add(egui::ImageButton::new(
+                self.image.texture_id(ctx),
+                self.image.size_vec2(),
+            ));
+        });
+    }
+}
diff --git a/egui/examples/retained_image/src/rust-logo-256x256.png b/egui/examples/retained_image/src/rust-logo-256x256.png
new file mode 100644
index 0000000..f5ddd63
Binary files /dev/null and b/egui/examples/retained_image/src/rust-logo-256x256.png differ
diff --git a/egui/examples/retained_image/src/rust-logo-license.txt b/egui/examples/retained_image/src/rust-logo-license.txt
new file mode 100644
index 0000000..7efaf75
--- /dev/null
+++ b/egui/examples/retained_image/src/rust-logo-license.txt
@@ -0,0 +1 @@
+Rust logo by Mozilla, from https://github.com/rust-lang/rust-artwork
diff --git a/egui/examples/screenshot/Cargo.toml b/egui/examples/screenshot/Cargo.toml
new file mode 100644
index 0000000..4c921bb
--- /dev/null
+++ b/egui/examples/screenshot/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "screenshot"
+version = "0.1.0"
+authors = [
+    "René Rössler <rene@freshx.de>",
+    "Andreas Faber <andreas.mfaber@gmail.com",
+]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+    "wgpu",
+] }
+itertools = "0.10.3"
+image = { version = "0.24", default-features = false, features = ["png"] }
diff --git a/egui/examples/screenshot/README.md b/egui/examples/screenshot/README.md
new file mode 100644
index 0000000..fb08d42
--- /dev/null
+++ b/egui/examples/screenshot/README.md
@@ -0,0 +1,7 @@
+Example how to take screenshots and display them with eframe/egui.
+
+```sh
+cargo run -p screenshot
+```
+
+![](screenshot.png)
diff --git a/egui/examples/screenshot/screenshot.png b/egui/examples/screenshot/screenshot.png
new file mode 100644
index 0000000..27bf799
Binary files /dev/null and b/egui/examples/screenshot/screenshot.png differ
diff --git a/egui/examples/screenshot/src/main.rs b/egui/examples/screenshot/src/main.rs
new file mode 100644
index 0000000..d2f92e2
--- /dev/null
+++ b/egui/examples/screenshot/src/main.rs
@@ -0,0 +1,94 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui::{self, ColorImage};
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        renderer: eframe::Renderer::Wgpu,
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Take screenshots and display with eframe/egui",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+#[derive(Default)]
+struct MyApp {
+    continuously_take_screenshots: bool,
+    texture: Option<egui::TextureHandle>,
+    screenshot: Option<ColorImage>,
+    save_to_file: bool,
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            if let Some(screenshot) = self.screenshot.take() {
+                self.texture = Some(ui.ctx().load_texture(
+                    "screenshot",
+                    screenshot,
+                    Default::default(),
+                ));
+            }
+
+            ui.horizontal(|ui| {
+                ui.checkbox(
+                    &mut self.continuously_take_screenshots,
+                    "continuously take screenshots",
+                );
+
+                if ui.button("save to 'top_left.png'").clicked() {
+                    self.save_to_file = true;
+                    frame.request_screenshot();
+                }
+
+                ui.with_layout(egui::Layout::top_down(egui::Align::RIGHT), |ui| {
+                    if self.continuously_take_screenshots {
+                        if ui
+                            .add(egui::Label::new("hover me!").sense(egui::Sense::hover()))
+                            .hovered()
+                        {
+                            ctx.set_visuals(egui::Visuals::dark());
+                        } else {
+                            ctx.set_visuals(egui::Visuals::light());
+                        };
+                        frame.request_screenshot();
+                    } else if ui.button("take screenshot!").clicked() {
+                        frame.request_screenshot();
+                    }
+                });
+            });
+
+            if let Some(texture) = self.texture.as_ref() {
+                ui.image(texture, ui.available_size());
+            } else {
+                ui.spinner();
+            }
+
+            ctx.request_repaint();
+        });
+    }
+
+    fn post_rendering(&mut self, _window_size: [u32; 2], frame: &eframe::Frame) {
+        if let Some(screenshot) = frame.screenshot() {
+            if self.save_to_file {
+                let pixels_per_point = frame.info().native_pixels_per_point;
+                let region =
+                    egui::Rect::from_two_pos(egui::Pos2::ZERO, egui::Pos2 { x: 100., y: 100. });
+                let top_left_corner = screenshot.region(&region, pixels_per_point);
+                image::save_buffer(
+                    "top_left.png",
+                    top_left_corner.as_raw(),
+                    top_left_corner.width() as u32,
+                    top_left_corner.height() as u32,
+                    image::ColorType::Rgba8,
+                )
+                .unwrap();
+                self.save_to_file = false;
+            }
+            self.screenshot = Some(screenshot);
+        }
+    }
+}
diff --git a/egui/examples/serial_windows/Cargo.toml b/egui/examples/serial_windows/Cargo.toml
new file mode 100644
index 0000000..95c57f1
--- /dev/null
+++ b/egui/examples/serial_windows/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "serial_windows"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
diff --git a/egui/examples/serial_windows/README.md b/egui/examples/serial_windows/README.md
new file mode 100644
index 0000000..7543f95
--- /dev/null
+++ b/egui/examples/serial_windows/README.md
@@ -0,0 +1,17 @@
+Demonstrates how to open several windows after each other.
+
+Expected order of execution:
+
+- When the example runs a first window will be shown.
+- Once the first window is closed after a delay a second window will be shown.
+- Similarly, when the second window is closed after a delay a third will be shown.
+- Once the third is closed the program will stop.
+
+NOTE: this doesn't work on Mac due to <https://github.com/rust-windowing/winit/issues/2431>.
+See also <https://github.com/emilk/egui/issues/1918>.
+
+```sh
+cargo run -p serial_windows
+```
+
+![](screenshot.png)
diff --git a/egui/examples/serial_windows/screenshot.png b/egui/examples/serial_windows/screenshot.png
new file mode 100644
index 0000000..1f7732c
Binary files /dev/null and b/egui/examples/serial_windows/screenshot.png differ
diff --git a/egui/examples/serial_windows/src/main.rs b/egui/examples/serial_windows/src/main.rs
new file mode 100644
index 0000000..e456551
--- /dev/null
+++ b/egui/examples/serial_windows/src/main.rs
@@ -0,0 +1,61 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    if cfg!(target_os = "macos") {
+        eprintln!("WARNING: this example does not work on Mac! See https://github.com/emilk/egui/issues/1918");
+    }
+
+    let options = eframe::NativeOptions {
+        run_and_return: true,
+        initial_window_size: Some(egui::vec2(320.0, 240.0)),
+        ..Default::default()
+    };
+
+    eprintln!("Starting first window…");
+    eframe::run_native(
+        "First Window",
+        options.clone(),
+        Box::new(|_cc| Box::new(MyApp { has_next: true })),
+    )?;
+
+    std::thread::sleep(std::time::Duration::from_secs(2));
+
+    eprintln!("Starting second window…");
+    eframe::run_native(
+        "Second Window",
+        options.clone(),
+        Box::new(|_cc| Box::new(MyApp { has_next: true })),
+    )?;
+
+    std::thread::sleep(std::time::Duration::from_secs(2));
+
+    eprintln!("Starting third window…");
+    eframe::run_native(
+        "Third Window",
+        options,
+        Box::new(|_cc| Box::new(MyApp { has_next: false })),
+    )
+}
+
+struct MyApp {
+    pub(crate) has_next: bool,
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            let label_text = if self.has_next {
+                "When this window is closed the next will be opened after a short delay"
+            } else {
+                "This is the last window. Program will end when closed"
+            };
+            ui.label(label_text);
+            if ui.button("Close").clicked() {
+                eprintln!("Pressed Close button");
+                frame.close();
+            }
+        });
+    }
+}
diff --git a/egui/examples/svg/Cargo.toml b/egui/examples/svg/Cargo.toml
new file mode 100644
index 0000000..66b2fc8
--- /dev/null
+++ b/egui/examples/svg/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "svg"
+version = "0.1.0"
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+
+
+[dependencies]
+eframe = { path = "../../crates/eframe", features = [
+    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+egui_extras = { path = "../../crates/egui_extras", features = ["svg"] }
diff --git a/egui/examples/svg/README.md b/egui/examples/svg/README.md
new file mode 100644
index 0000000..c171c17
--- /dev/null
+++ b/egui/examples/svg/README.md
@@ -0,0 +1,7 @@
+Example how to show an SVG image.
+
+```sh
+cargo run -p svg
+```
+
+![](screenshot.png)
diff --git a/egui/examples/svg/screenshot.png b/egui/examples/svg/screenshot.png
new file mode 100644
index 0000000..7b3d622
Binary files /dev/null and b/egui/examples/svg/screenshot.png differ
diff --git a/egui/examples/svg/src/main.rs b/egui/examples/svg/src/main.rs
new file mode 100644
index 0000000..526a68c
--- /dev/null
+++ b/egui/examples/svg/src/main.rs
@@ -0,0 +1,50 @@
+//! A good way of displaying an SVG image in egui.
+//!
+//! Requires the dependency `egui_extras` with the `svg` feature.
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::egui;
+
+fn main() -> Result<(), eframe::Error> {
+    let options = eframe::NativeOptions {
+        initial_window_size: Some(egui::vec2(1000.0, 700.0)),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "svg example",
+        options,
+        Box::new(|_cc| Box::new(MyApp::default())),
+    )
+}
+
+struct MyApp {
+    svg_image: egui_extras::RetainedImage,
+}
+
+impl Default for MyApp {
+    fn default() -> Self {
+        Self {
+            svg_image: egui_extras::RetainedImage::from_svg_bytes_with_size(
+                "rustacean-flat-happy.svg",
+                include_bytes!("rustacean-flat-happy.svg"),
+                egui_extras::image::FitTo::Original,
+            )
+            .unwrap(),
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("SVG example");
+            ui.label("The SVG is rasterized and displayed as a texture.");
+
+            ui.separator();
+
+            let max_size = ui.available_size();
+            self.svg_image.show_size(ui, max_size);
+        });
+    }
+}
diff --git a/egui/examples/svg/src/rust-logo-license.txt b/egui/examples/svg/src/rust-logo-license.txt
new file mode 100644
index 0000000..7efaf75
--- /dev/null
+++ b/egui/examples/svg/src/rust-logo-license.txt
@@ -0,0 +1 @@
+Rust logo by Mozilla, from https://github.com/rust-lang/rust-artwork
diff --git a/egui/examples/svg/src/rustacean-flat-happy.svg b/egui/examples/svg/src/rustacean-flat-happy.svg
new file mode 100644
index 0000000..c7f240d
--- /dev/null
+++ b/egui/examples/svg/src/rustacean-flat-happy.svg
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 1200 800" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:1.41421;">
+    <g id="Layer-1" serif:id="Layer 1">
+        <g transform="matrix(1,0,0,1,1009.4,506.362)">
+            <path d="M0,-7.203L-12.072,-32.209C-12.009,-33.156 -11.961,-34.107 -11.961,-35.062C-11.961,-63.408 -41.439,-89.533 -91.03,-110.451L-91.03,-93.058C-95.866,-94.977 -100.901,-96.845 -106.147,-98.651L-106.147,-106.759C-177.021,-132.319 -282.53,-148.537 -400.388,-148.537C-503.361,-148.537 -596.917,-136.157 -666.179,-115.983L-666.179,-87.737L-666.181,-87.737L-666.181,-121.925C-737.141,-99.375 -781.135,-68.048 -781.135,-33.41C-781.135,-27.95 -780.034,-22.572 -777.918,-17.297L-785.146,-4.43C-785.146,-4.43 -790.938,3.082 -780.74,18.932C-771.746,32.909 -726.692,87.617 -702.913,116.267C-692.699,130.954 -685.772,140.001 -685.167,139.126C-684.212,137.74 -691.518,110.165 -711.802,78.703C-721.268,61.808 -732.57,39.42 -739.356,22.884C-720.414,34.874 -609.126,90.913 -382.124,90.685C-150.13,90.453 -47.009,17.834 -35.691,7.948C-39.646,23.837 -53.159,55.981 -63.936,78.586C-81.642,110.917 -88.056,139.064 -87.232,140.456C-86.708,141.334 -80.667,132.015 -71.756,116.913C-51.025,87.37 -11.739,30.974 -3.889,16.608C5.007,0.323 0,-7.203 0,-7.203" style="fill:rgb(165,43,0);fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,1079.49,294.885)">
+            <path d="M0,204.135L-79.343,145.689C-80.088,143.089 -80.833,140.488 -81.603,137.908L-55.541,100.154C-52.881,96.314 -52.345,91.322 -54.072,86.943C-55.803,82.585 -59.587,79.461 -64.062,78.696L-108.128,71.217C-109.837,67.732 -111.626,64.301 -113.422,60.898L-94.907,18.51C-93.004,14.193 -93.402,9.175 -95.929,5.256C-98.446,1.319 -102.715,-0.981 -107.267,-0.802L-151.991,0.823C-154.306,-2.193 -156.658,-5.18 -159.058,-8.114L-148.78,-53.546C-147.738,-58.158 -149.054,-62.989 -152.267,-66.34C-155.462,-69.679 -160.105,-71.062 -164.52,-69.979L-208.082,-59.27C-210.902,-61.763 -213.77,-64.223 -216.67,-66.635L-215.103,-113.276C-214.935,-117.997 -217.136,-122.484 -220.915,-125.105C-224.692,-127.741 -229.485,-128.137 -233.616,-126.179L-274.254,-106.858C-277.527,-108.736 -280.819,-110.595 -284.146,-112.395L-291.327,-158.356C-292.056,-163.012 -295.051,-166.968 -299.246,-168.774C-303.431,-170.591 -308.222,-170.002 -311.894,-167.238L-348.126,-140.053C-351.695,-141.238 -355.279,-142.373 -358.905,-143.46L-374.522,-187.045C-376.11,-191.488 -379.772,-194.751 -384.238,-195.669C-388.688,-196.578 -393.266,-195.037 -396.352,-191.589L-426.851,-157.47C-430.536,-157.893 -434.228,-158.28 -437.927,-158.601L-461.476,-198.277C-463.86,-202.295 -468.073,-204.741 -472.615,-204.741C-477.144,-204.741 -481.365,-202.295 -483.733,-198.277L-507.288,-158.601C-510.989,-158.28 -514.696,-157.893 -518.376,-157.47L-548.875,-191.589C-551.965,-195.037 -556.559,-196.578 -560.997,-195.669C-565.457,-194.739 -569.125,-191.488 -570.704,-187.045L-586.333,-143.46C-589.954,-142.373 -593.538,-141.23 -597.113,-140.053L-633.333,-167.238C-637.016,-170.012 -641.811,-170.599 -646.001,-168.774C-650.182,-166.968 -653.189,-163.012 -653.914,-158.356L-661.1,-112.395C-664.422,-110.595 -667.714,-108.746 -670.995,-106.858L-711.629,-126.179C-715.756,-128.145 -720.574,-127.741 -724.333,-125.105C-728.106,-122.484 -730.313,-117.997 -730.143,-113.276L-728.581,-66.635C-731.475,-64.223 -734.337,-61.763 -737.172,-59.27L-780.726,-69.979C-785.149,-71.053 -789.788,-69.679 -792.991,-66.34C-796.212,-62.989 -797.517,-58.158 -796.482,-53.546L-786.225,-8.114C-788.603,-5.169 -790.958,-2.193 -793.267,0.823L-837.991,-0.802C-842.504,-0.937 -846.812,1.319 -849.334,5.256C-851.861,9.175 -852.244,14.193 -850.363,18.51L-831.835,60.898C-833.634,64.301 -835.421,67.732 -837.144,71.217L-881.207,78.696C-885.686,79.45 -889.459,82.572 -891.201,86.943C-892.929,91.322 -892.368,96.314 -889.727,100.154L-863.661,137.908C-863.862,138.575 -864.048,139.247 -864.248,139.916L-937.944,218.201C-937.944,218.201 -949.24,227.052 -932.797,247.855C-918.297,266.206 -843.846,338.951 -804.526,377.06C-787.92,396.408 -776.542,408.389 -775.354,407.353C-773.478,405.708 -783.326,370.506 -816.036,329.204C-841.252,292.148 -873.977,235.155 -866.303,228.586C-866.303,228.586 -857.574,217.505 -840.061,209.529C-839.42,210.041 -840.723,209.022 -840.061,209.529C-840.061,209.529 -470.466,380.02 -127.632,212.413C-88.468,205.388 -64.759,226.368 -64.759,226.368C-56.583,231.108 -77.755,289.712 -95.166,328.505C-118.845,372.555 -122.317,406.927 -120.31,408.119C-119.042,408.876 -110.427,395.766 -98.138,374.902C-67.814,332.649 -10.492,252.1 0,232.534C11.895,210.352 0,204.135 0,204.135" style="fill:rgb(247,76,0);fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,917.896,244.679)">
+            <path d="M0,232.466C0,232.466 53.179,230 123.032,159.004L132.93,137.025C132.93,137.025 24.513,29.177 193.048,-45.266C193.048,-45.266 178.293,-21.154 182.622,72.006C182.622,72.006 233.437,54.357 248.336,-27.934C248.336,-27.934 322.456,69.79 167.834,161.443C167.834,161.443 95.294,277.732 -6.971,266.593L0,232.466Z" style="fill:rgb(247,76,0);fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,676.997,488.361)">
+            <path d="M0,-78.192C0,-78.192 36.935,-118.635 73.871,-78.192C73.871,-78.192 102.893,-24.265 73.871,2.695C73.871,2.695 26.384,40.443 0,2.695C0,2.695 -31.658,-26.964 0,-78.192" style="fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,719.761,425.169)">
+            <path d="M0,0.004C0,15.75 -9.282,28.518 -20.732,28.518C-32.18,28.518 -41.462,15.75 -41.462,0.004C-41.462,-15.746 -32.18,-28.514 -20.732,-28.514C-9.282,-28.514 0,-15.746 0,0.004" style="fill:white;fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,512.148,482.736)">
+            <path d="M0,-83.609C0,-83.609 63.355,-111.661 80.648,-49.047C80.648,-49.047 98.762,23.933 28.618,28.052C28.618,28.052 -60.826,10.824 0,-83.609" style="fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,543.968,426.204)">
+            <path d="M0,0.002C0,16.241 -9.572,29.411 -21.381,29.411C-33.185,29.411 -42.76,16.241 -42.76,0.002C-42.76,-16.242 -33.185,-29.409 -21.381,-29.409C-9.572,-29.409 0,-16.242 0,0.002" style="fill:white;fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,593.317,576.574)">
+            <path d="M0,-40.271L80.796,-46.755C80.796,-46.755 78.058,-33.749 67.517,-23.986C67.517,-23.986 39.727,6.484 7.844,-26.519C7.844,-26.519 2.627,-32.148 0,-40.271" style="fill-rule:nonzero;"/>
+        </g>
+        <g transform="matrix(1,0,0,1,269.796,270.778)">
+            <path d="M0,190.741C-0.667,190.741 -1.321,190.79 -1.973,190.842C-28.207,184.871 -101.946,165.657 -121.437,134.479C-121.437,134.479 -22.21,21.607 -177.297,-50.54L-159.24,74.338C-159.24,74.338 -207.049,42.389 -217.366,-27.008C-217.366,-27.008 -333.789,57.486 -165.982,138.466C-165.982,138.466 -150.762,195.653 -4.633,241.281L-4.526,240.846C-3.055,241.118 -1.549,241.281 0,241.281C13.808,241.281 25.003,229.969 25.003,216.01C25.003,202.054 13.808,190.741 0,190.741" style="fill:rgb(247,76,0);fill-rule:nonzero;"/>
+        </g>
+    </g>
+</svg>
diff --git a/egui/rust-toolchain b/egui/rust-toolchain
new file mode 100644
index 0000000..0e33403
--- /dev/null
+++ b/egui/rust-toolchain
@@ -0,0 +1,10 @@
+# If you see this, run "rustup self update" to get rustup 1.23 or newer.
+
+# NOTE: above comment is for older `rustup` (before TOML support was added),
+# which will treat the first line as the toolchain name, and therefore show it
+# to the user in the error, instead of "error: invalid channel name '[toolchain]'".
+
+[toolchain]
+channel = "1.65.0"
+components = [ "rustfmt", "clippy" ]
+targets = [ "wasm32-unknown-unknown" ]
diff --git a/egui/scripts/build_demo_web.sh b/egui/scripts/build_demo_web.sh
new file mode 100755
index 0000000..35ec1f7
--- /dev/null
+++ b/egui/scripts/build_demo_web.sh
@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+CRATE_NAME="egui_demo_app"
+ # NOTE: persistence use up about 400kB (10%) of the WASM!
+FEATURES="glow,http,persistence,web_screen_reader"
+
+OPEN=false
+OPTIMIZE=false
+
+while test $# -gt 0; do
+  case "$1" in
+    -h|--help)
+      echo "build_demo_web.sh [--optimize] [--open]"
+      echo ""
+      echo "  --optimize: Enable optimization step"
+      echo "              Runs wasm-opt."
+      echo "              NOTE: --optimize also removes debug symbols which are otherwise useful for in-browser profiling."
+      echo ""
+      echo "  --open:     Open the result in a browser"
+      exit 0
+      ;;
+
+    -O|--optimize)
+      shift
+      OPTIMIZE=true
+      ;;
+
+    --open)
+      shift
+      OPEN=true
+      ;;
+
+    *)
+      break
+      ;;
+  esac
+done
+
+./scripts/setup_web.sh
+
+# This is required to enable the web_sys clipboard API which eframe web uses
+# https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Clipboard.html
+# https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html
+export RUSTFLAGS=--cfg=web_sys_unstable_apis
+
+# Clear output from old stuff:
+rm -f "docs/${CRATE_NAME}_bg.wasm"
+
+echo "Building rust…"
+BUILD=release
+
+(cd crates/$CRATE_NAME &&
+  cargo build \
+    --release \
+    --lib \
+    --target wasm32-unknown-unknown \
+    --no-default-features \
+    --features ${FEATURES}
+)
+
+# Get the output directory (in the workspace it is in another location)
+TARGET=`cargo metadata --format-version=1 | jq --raw-output .target_directory`
+
+echo "Generating JS bindings for wasm…"
+TARGET_NAME="${CRATE_NAME}.wasm"
+WASM_PATH="${TARGET}/wasm32-unknown-unknown/$BUILD/$TARGET_NAME"
+wasm-bindgen "${WASM_PATH}" --out-dir docs --no-modules --no-typescript
+
+# if this fails with "error: cannot import from modules (`env`) with `--no-modules`", you can use:
+# wasm2wat target/wasm32-unknown-unknown/release/egui_demo_app.wasm | rg env
+# wasm2wat target/wasm32-unknown-unknown/release/egui_demo_app.wasm | rg "call .now\b" -B 20 # What calls `$now` (often a culprit)
+
+# to get wasm-strip:  apt/brew/dnf install wabt
+# wasm-strip docs/${CRATE_NAME}_bg.wasm
+
+if [[ "${OPTIMIZE}" = true ]]; then
+  echo "Optimizing wasm…"
+  # to get wasm-opt:  apt/brew/dnf install binaryen
+  wasm-opt "docs/${CRATE_NAME}_bg.wasm" -O2 --fast-math -o "docs/${CRATE_NAME}_bg.wasm" # add -g to get debug symbols
+fi
+
+echo "Finished docs/${CRATE_NAME}_bg.wasm"
+
+if [[ "${OPEN}" == true ]]; then
+  if [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    # Linux, ex: Fedora
+    xdg-open http://localhost:8888/index.html
+  elif [[ "$OSTYPE" == "msys" ]]; then
+    # Windows
+    start http://localhost:8888/index.html
+  else
+    # Darwin/MacOS, or something else
+    open http://localhost:8888/index.html
+  fi
+fi
diff --git a/egui/scripts/cargo-deny.sh b/egui/scripts/cargo-deny.sh
new file mode 100755
index 0000000..41b65fc
--- /dev/null
+++ b/egui/scripts/cargo-deny.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+set -x
+
+# cargo install cargo-deny
+cargo deny --all-features --log-level error --target aarch64-apple-darwin check
+cargo deny --all-features --log-level error --target i686-pc-windows-gnu check
+cargo deny --all-features --log-level error --target i686-pc-windows-msvc check
+cargo deny --all-features --log-level error --target i686-unknown-linux-gnu check
+cargo deny --all-features --log-level error --target wasm32-unknown-unknown check
+cargo deny --all-features --log-level error --target x86_64-apple-darwin check
+cargo deny --all-features --log-level error --target x86_64-pc-windows-gnu check
+cargo deny --all-features --log-level error --target x86_64-pc-windows-msvc check
+cargo deny --all-features --log-level error --target x86_64-unknown-linux-gnu check
+cargo deny --all-features --log-level error --target x86_64-unknown-linux-musl check
+cargo deny --all-features --log-level error --target x86_64-unknown-redox check
diff --git a/egui/scripts/check.sh b/egui/scripts/check.sh
new file mode 100755
index 0000000..f0491f0
--- /dev/null
+++ b/egui/scripts/check.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# This scripts runs various CI-like checks in a convenient way.
+
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+set -x
+
+# Checks all tests, lints etc.
+# Basically does what the CI does.
+
+cargo install cargo-cranky # Uses lints defined in Cranky.toml. See https://github.com/ericseppanen/cargo-cranky
+
+# web_sys_unstable_apis is required to enable the web_sys clipboard API which eframe web uses,
+# as well as by the wasm32-backend of the wgpu crate.
+export RUSTFLAGS="--cfg=web_sys_unstable_apis -D warnings"
+export RUSTDOCFLAGS="-D warnings" # https://github.com/emilk/egui/pull/1454
+
+cargo check --all-targets
+cargo check --all-targets --all-features
+cargo check -p egui_demo_app --lib --target wasm32-unknown-unknown
+cargo check -p egui_demo_app --lib --target wasm32-unknown-unknown --all-features
+cargo cranky --all-targets --all-features -- -D warnings
+cargo test --all-targets --all-features
+cargo test --doc # slow - checks all doc-tests
+cargo fmt --all -- --check
+
+cargo doc --lib --no-deps --all-features
+cargo doc --document-private-items --no-deps --all-features
+
+(cd crates/eframe && cargo check --no-default-features --features "glow")
+(cd crates/eframe && cargo check --no-default-features --features "wgpu")
+(cd crates/egui && cargo check --no-default-features --features "serde")
+(cd crates/egui_demo_app && cargo check --no-default-features --features "glow")
+(cd crates/egui_demo_app && cargo check --no-default-features --features "wgpu")
+(cd crates/egui_demo_lib && cargo check --no-default-features)
+(cd crates/egui_extras && cargo check --no-default-features)
+(cd crates/egui_glow && cargo check --no-default-features)
+(cd crates/egui-winit && cargo check --no-default-features --features "wayland")
+(cd crates/egui-winit && cargo check --no-default-features --features "winit/x11")
+(cd crates/emath && cargo check --no-default-features)
+(cd crates/epaint && cargo check --no-default-features --release)
+(cd crates/epaint && cargo check --no-default-features)
+
+(cd crates/eframe && cargo check --all-features)
+(cd crates/egui && cargo check --all-features)
+(cd crates/egui_demo_app && cargo check --all-features)
+(cd crates/egui_extras && cargo check --all-features)
+(cd crates/egui_glow && cargo check --all-features)
+(cd crates/egui-winit && cargo check --all-features)
+(cd crates/emath && cargo check --all-features)
+(cd crates/epaint && cargo check --all-features)
+
+./scripts/wasm_bindgen_check.sh
+
+cargo cranky --target wasm32-unknown-unknown --all-features -p egui_demo_app --lib -- -D warnings
+
+./scripts/cargo_deny.sh
+
+# TODO(emilk): consider using https://github.com/taiki-e/cargo-hack or https://github.com/frewsxcv/cargo-all-features
+
+# ------------------------------------------------------------
+#
+
+# For finding bloat:
+# cargo bloat --release --bin egui_demo_app -n 200 | rg egui
+# Also try https://github.com/google/bloaty
+
+# what compiles slowly?
+# cargo clean && time cargo build -p eframe --timings
+# https://fasterthanli.me/articles/why-is-my-rust-build-so-slow
+
+# what compiles slowly?
+# cargo llvm-lines --lib -p egui | head -20
+
+echo "All checks passed."
diff --git a/egui/scripts/docs.sh b/egui/scripts/docs.sh
new file mode 100755
index 0000000..ee8f863
--- /dev/null
+++ b/egui/scripts/docs.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+cargo doc -p eframe --target wasm32-unknown-unknown --lib --no-deps
+cargo doc -p emath -p epaint -p egui -p eframe -p egui-winit -p egui_extras -p egui_glow --lib --no-deps --all-features --open
+
+# cargo watch -c -x 'doc -p emath -p epaint -p egui --lib --no-deps --all-features'
diff --git a/egui/scripts/find_bloat.sh b/egui/scripts/find_bloat.sh
new file mode 100755
index 0000000..9e9a9bc
--- /dev/null
+++ b/egui/scripts/find_bloat.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+cargo bloat --release --bin egui_demo_app -n 200 | rg "egui "
+
+cargo llvm-lines -p egui_demo_lib | rg egui | head -30
diff --git a/egui/scripts/generate_example_screenshots.sh b/egui/scripts/generate_example_screenshots.sh
new file mode 100755
index 0000000..39550a0
--- /dev/null
+++ b/egui/scripts/generate_example_screenshots.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# This script generates screenshots for all the examples in examples/
+
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+cd examples
+for EXAMPLE_NAME in $(ls -1d */ | sed 's/\/$//'); do
+    if [ ${EXAMPLE_NAME} != "hello_world_par" ]; then
+        EFRAME_SCREENSHOT_TO="$EXAMPLE_NAME/screenshot.png" cargo run -p $EXAMPLE_NAME
+    fi
+done
diff --git a/egui/scripts/setup_web.sh b/egui/scripts/setup_web.sh
new file mode 100755
index 0000000..11c579a
--- /dev/null
+++ b/egui/scripts/setup_web.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+# Pre-requisites:
+rustup target add wasm32-unknown-unknown
+cargo install wasm-bindgen-cli --version 0.2.84
diff --git a/egui/scripts/start_server.sh b/egui/scripts/start_server.sh
new file mode 100755
index 0000000..3382c1b
--- /dev/null
+++ b/egui/scripts/start_server.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+# Starts a local web-server that serves the contents of the `doc/` folder,
+# i.e. the web-version of `egui_demo_app`.
+
+PORT=8888
+
+echo "ensuring basic-http-server is installed…"
+cargo install basic-http-server
+
+echo "starting server…"
+echo "serving at http://localhost:${PORT}"
+
+(cd docs && basic-http-server --addr 127.0.0.1:${PORT} .)
+# (cd docs && python3 -m http.server ${PORT} --bind 127.0.0.1)
diff --git a/egui/scripts/wasm_bindgen_check.sh b/egui/scripts/wasm_bindgen_check.sh
new file mode 100755
index 0000000..18c2462
--- /dev/null
+++ b/egui/scripts/wasm_bindgen_check.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path/.."
+
+if [[ $* == --skip-setup ]]
+then
+  echo "Skipping setup_web.sh"
+else
+  echo "Running setup_web.sh"
+  ./scripts/setup_web.sh
+fi
+
+CRATE_NAME="egui_demo_app"
+FEATURES="glow,http,persistence,web_screen_reader"
+
+# This is required to enable the web_sys clipboard API which eframe web uses
+# https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Clipboard.html
+# https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html
+export RUSTFLAGS=--cfg=web_sys_unstable_apis
+
+echo "Building rust…"
+BUILD=debug # debug builds are faster
+
+(cd crates/$CRATE_NAME &&
+  cargo build \
+    --lib \
+    --target wasm32-unknown-unknown \
+    --no-default-features \
+    --features ${FEATURES}
+)
+
+TARGET="target"
+
+echo "Generating JS bindings for wasm…"
+
+rm -f "${CRATE_NAME}_bg.wasm" # Remove old output (if any)
+
+TARGET_NAME="${CRATE_NAME}.wasm"
+wasm-bindgen "${TARGET}/wasm32-unknown-unknown/$BUILD/$TARGET_NAME" \
+  --out-dir . --no-modules --no-typescript
+
+# Remove output:
+rm -f "${CRATE_NAME}_bg.wasm"
+rm -f "${CRATE_NAME}.js"
diff --git a/egui/scripts/wasm_size.sh b/egui/scripts/wasm_size.sh
new file mode 100755
index 0000000..80971b4
--- /dev/null
+++ b/egui/scripts/wasm_size.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -eu
+script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+cd "$script_path"
+
+./build_demo_web.sh && ls -lh ../docs/*.wasm
diff --git a/egui_inspect/Cargo.toml b/egui_inspect/Cargo.toml
index a3e0afc..e498abf 100644
--- a/egui_inspect/Cargo.toml
+++ b/egui_inspect/Cargo.toml
@@ -10,7 +10,7 @@ derive = ["egui-inspect-derive"]
 default = ["derive"]
 
 [dependencies]
-egui = "0.21.0"
+egui = { path = "../egui/crates/egui" }
 egui-inspect-derive = { path = "egui-inspect-derive", optional = true}
 
 [workspace]
diff --git a/src/main.rs b/src/main.rs
index 93f91a4..f2b0e2c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -21,9 +21,6 @@ impl ::core::fmt::Debug for WorldPos {
         Ok(())
     }
 }
-impl ::egui_inspect::Inspect for WorldPos {
-    fn inspect_mut(&mut self, ui: &mut ::egui::Ui) {}
-}
 
 #[derive(Inspect)]
 pub(crate) struct GameState {