diff --git a/.gitattributes b/.gitattributes
index b5348bf23..8abb5d87b 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,6 +1,7 @@
 * text=auto eol=lf
 Cargo.lock linguist-generated=false
 *.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
 
 # Exclude some small files from LFS:
 crates/eframe/data/* !filter !diff !merge text=auto eol=lf
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 66c17862f..e7c1d6bc3 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -10,13 +10,13 @@ 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:
+Please also check if the bug is still present in latest main! Do so by adding the following lines to your Cargo.toml:
 
 
 [patch.crates-io]
-egui = { git = "https://github.com/emilk/egui", branch = "master" }
+egui = { git = "https://github.com/emilk/egui", branch = "main" }
 # if you're using eframe:
-eframe = { git = "https://github.com/emilk/egui", branch = "master" }
+eframe = { git = "https://github.com/emilk/egui", branch = "main" }
 -->
 
 **Describe the bug**
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 58fcd32ad..fb9926e3a 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,5 +1,5 @@
 <!--
-Please read the "Making a PR" section of [`CONTRIBUTING.md`](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md) before opening a Pull Request!
+Please read the "Making a PR" section of [`CONTRIBUTING.md`](https://github.com/emilk/egui/blob/main/CONTRIBUTING.md) before opening a Pull Request!
 
 * Keep your PR:s small and focused.
 * The PR title is what ends up in the changelog, so make it descriptive!
diff --git a/.github/workflows/cargo_machete.yml b/.github/workflows/cargo_machete.yml
index 2b06dfdef..7e5747800 100644
--- a/.github/workflows/cargo_machete.yml
+++ b/.github/workflows/cargo_machete.yml
@@ -5,8 +5,15 @@ on: [push, pull_request]
 jobs:
   cargo-machete:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     steps:
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: 1.88
+      - name: Machete install
+        ## The official cargo-machete action
+        uses: bnjbvr/cargo-machete@v0.9.1
       - name: Checkout
-        uses: actions/checkout@v3
-      - name: Machete
-        run: cargo install cargo-machete --locked && cargo machete
+        uses: actions/checkout@v4
+      - name: Machete Check
+        run: cargo machete
diff --git a/.github/workflows/deploy_web_demo.yml b/.github/workflows/deploy_web_demo.yml
index 6c9d80962..21cfb159e 100644
--- a/.github/workflows/deploy_web_demo.yml
+++ b/.github/workflows/deploy_web_demo.yml
@@ -1,9 +1,9 @@
 name: Deploy web demo
 
 on:
-  # We only run this on merges to master
+  # We only run this on merges to main
   push:
-    branches: ["master"]
+    branches: ["main"]
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 # to only run when you do a new github release, comment out above part and uncomment the below trigger.
@@ -11,7 +11,6 @@ on:
 #   release:
 #     types: ["published"]
 
-
 permissions:
   contents: write # for committing to gh-pages branch
 
@@ -29,8 +28,8 @@ jobs:
   # Single deploy job since we're just deploying
   deploy:
     name: Deploy web demo
-
     runs-on: ubuntu-latest
+    timeout-minutes: 60
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -39,16 +38,19 @@ jobs:
         with:
           profile: minimal
           target: wasm32-unknown-unknown
-          toolchain: 1.81.0
+          toolchain: 1.88.0
           override: true
 
       - uses: Swatinem/rust-cache@v2
         with:
           prefix-key: "web-demo-"
 
-      - name: "Install wasmopt / binaryen"
-        run: |
-          sudo apt-get update && sudo apt-get install binaryen
+      - name: Install wasm-opt
+        uses: sigoden/install-binary@v1
+        with:
+          repo: WebAssembly/binaryen
+          tag: version_123
+          name: wasm-opt
 
       - run: |
           scripts/build_demo_web.sh --release
diff --git a/.github/workflows/enforce_branch_name.yml b/.github/workflows/enforce_branch_name.yml
new file mode 100644
index 000000000..8c2b28d37
--- /dev/null
+++ b/.github/workflows/enforce_branch_name.yml
@@ -0,0 +1,35 @@
+name: PR Branch Name Check
+
+on:
+  pull_request_target:
+    types: [opened, reopened, synchronize]
+
+jobs:
+  check-source-branch:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Check PR source branch
+        run: |
+          # Check if PR is from a fork
+          if [[ "${{ github.event.pull_request.head.repo.fork }}" == "true" ]]; then
+            # Check if PR is from the master/main branch of a fork
+            if [[ "${{ github.event.pull_request.head.ref }}" == "master" || "${{ github.event.pull_request.head.ref }}" == "main" ]]; then
+              echo "ERROR: Pull requests from the master/main branch of forks are not allowed, because it prevents maintainers from contributing to your PR"
+              echo "Please create a feature branch in your fork and submit the PR from that branch instead."
+              exit 1
+            fi
+          fi
+
+      - name: Leave comment if PR is from master/main branch of fork d
+        if: ${{ failure() }}
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: '⚠️ **ERROR:** Pull requests from the `master`/`main` branch of forks are not allowed, because it prevents maintainers from contributing to your PR. Please create a feature branch in your fork and submit the PR from that branch instead.'
+            })
diff --git a/.github/workflows/labels.yml b/.github/workflows/labels.yml
index b83040667..cac2f879c 100644
--- a/.github/workflows/labels.yml
+++ b/.github/workflows/labels.yml
@@ -16,6 +16,7 @@ on:
 jobs:
   label:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     steps:
       - name: Check for a "do-not-merge" label
         uses: mheap/github-action-required-labels@v3
@@ -29,4 +30,4 @@ jobs:
         with:
           mode: minimum
           count: 1
-          labels: "CI, dependencies, docs and examples, ecolor, eframe, egui_extras, egui_glow, egui_kittest, egui-wgpu, egui-winit, egui, epaint, epaint_default_fonts, exclude from changelog, typo"
+          labels: "CI, dependencies, docs and examples, ecolor, eframe, egui_extras, egui_glow, egui_kittest, egui-wgpu, egui-winit, egui, emath, epaint, epaint_default_fonts, exclude from changelog, typo"
diff --git a/.github/workflows/png_only_on_lfs.yml b/.github/workflows/png_only_on_lfs.yml
index 624a7f450..0b7c122fe 100644
--- a/.github/workflows/png_only_on_lfs.yml
+++ b/.github/workflows/png_only_on_lfs.yml
@@ -5,6 +5,7 @@ on: [push, pull_request]
 jobs:
   check-binary-files:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
 
     steps:
     - name: Checkout repository
@@ -25,7 +26,7 @@ jobs:
           exclude_pattern=$(printf "|^%s" "${exclude_paths[@]}" | sed 's/^|//')
 
           if comm -23 <(git ls-files | grep -Ev "$exclude_pattern" | sort) <(git lfs ls-files -n | sort) | grep "\.${ext}$"; then
-            echo "Error: Found binary file with extension .$ext not tracked by git LFS. See CONTRIBUTING.md"
+            echo "Error: Found binary file with extension .$ext not tracked by git LFS. See https://github.com/emilk/egui/blob/main/CONTRIBUTING.md#working-with-git-lfs"
             exit 1
           fi
         done
diff --git a/.github/workflows/preview_build.yml b/.github/workflows/preview_build.yml
index c44c10f0c..fe37eb8cb 100644
--- a/.github/workflows/preview_build.yml
+++ b/.github/workflows/preview_build.yml
@@ -15,16 +15,23 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v2
-      - run: rustup toolchain install stable --profile minimal --target wasm32-unknown-unknown
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: 1.88.0
+          targets: wasm32-unknown-unknown
       - uses: Swatinem/rust-cache@v2
         with:
           prefix-key: "pr-preview-"
 
-      - name: "Install wasmopt / binaryen"
-        run: |
-          sudo apt-get update && sudo apt-get install binaryen
+      - name: Install wasm-opt
+        uses: sigoden/install-binary@v1
+        with:
+          repo: WebAssembly/binaryen
+          tag: version_123
+          name: wasm-opt
 
       - run: |
           scripts/build_demo_web.sh --release
diff --git a/.github/workflows/preview_cleanup.yml b/.github/workflows/preview_cleanup.yml
index 6e2b94b83..b2ef1e3b3 100644
--- a/.github/workflows/preview_cleanup.yml
+++ b/.github/workflows/preview_cleanup.yml
@@ -11,6 +11,7 @@ on:
 jobs:
   cleanup:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
diff --git a/.github/workflows/preview_comment.yml b/.github/workflows/preview_comment.yml
new file mode 100644
index 000000000..0334e0c21
--- /dev/null
+++ b/.github/workflows/preview_comment.yml
@@ -0,0 +1,23 @@
+name: preview_comment.yml
+on:
+  pull_request_target:
+    types: [opened]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Comment PR
+        uses: thollander/actions-comment-pull-request@v2
+        env:
+          URL_SLUG: ${{ github.event.number }}-${{ github.head_ref }}
+        with:
+          message: |
+            Preview is being built...
+            
+            Preview will be available at https://egui-pr-preview.github.io/pr/${{ env.URL_SLUG }}
+            
+            View snapshot changes at [kitdiff](https://rerun-io.github.io/kitdiff/?url=${{ github.event.pull_request.html_url }})
+          comment_tag: 'egui-preview'
+
diff --git a/.github/workflows/preview_deploy.yml b/.github/workflows/preview_deploy.yml
index f98f96da1..d29e7f4b0 100644
--- a/.github/workflows/preview_deploy.yml
+++ b/.github/workflows/preview_deploy.yml
@@ -20,6 +20,7 @@ concurrency:
 jobs:
   deploy:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -60,5 +61,7 @@ jobs:
           message: |
             Preview available at https://egui-pr-preview.github.io/pr/${{ env.URL_SLUG }}
             Note that it might take a couple seconds for the update to show up after the preview_build workflow has completed.
+            
+            View snapshot changes at [kitdiff](https://rerun-io.github.io/kitdiff/?url=https://github.com/emilk/egui/pull/${{ env.PR_NUMBER }})
           pr_number: ${{ env.PR_NUMBER }}
           comment_tag: 'egui-preview'
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index eadce83be..5d30d7e31 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -5,20 +5,21 @@ name: Rust
 env:
   RUSTFLAGS: -D warnings
   RUSTDOCFLAGS: -D warnings
-  NIGHTLY_VERSION: nightly-2024-09-11
+  NIGHTLY_VERSION: nightly-2025-09-16
 
 jobs:
   fmt-crank-check-test:
     name: Format + check
     runs-on: ubuntu-22.04
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
         with:
           lfs: true
 
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.81.0
+          toolchain: 1.88.0
 
       - name: Install packages (Linux)
         if: runner.os == 'Linux'
@@ -37,39 +38,28 @@ jobs:
       - name: Lint vertical spacing
         run: ./scripts/lint.py
 
-      - name: check --all-features
-        run: cargo check --locked --all-features --all-targets
+      - run: cargo clippy --locked --all-features --all-targets
 
-      - name: check egui_extras --all-features
-        run: cargo check --locked --all-features -p egui_extras
+      - run: cargo clippy --locked --all-features -p egui_extras
 
-      - name: check default features
-        run: cargo check --locked --all-targets
+      - run: cargo clippy --locked --all-targets
 
-      - name: check --no-default-features
-        run: cargo check --locked --no-default-features --lib --all-targets
+      - run: cargo clippy --locked --no-default-features --lib --all-targets
 
-      - name: check eframe --no-default-features
-        run: cargo check --locked --no-default-features --features x11 --lib -p eframe
+      - run: cargo clippy --locked --no-default-features --lib -p eframe --features x11
 
-      - name: check egui_extras --no-default-features
-        run: cargo check --locked --no-default-features --lib -p egui_extras
+      - run: cargo clippy --locked --no-default-features --lib -p eframe --features x11,wgpu_no_default_features
 
-      - name: check epaint --no-default-features
-        run: cargo check --locked --no-default-features --lib -p epaint
+      - run: cargo clippy --locked --no-default-features --lib -p egui_extras
+
+      - run: cargo clippy --locked --no-default-features --lib -p epaint
 
       # Regression test for https://github.com/emilk/egui/issues/4771
-      - name: cargo check -p test_egui_extras_compilation
-        run: cargo check -p test_egui_extras_compilation
+      - run: cargo clippy -p test_egui_extras_compilation
 
-      - name: cargo doc --lib
-        run: cargo doc --lib --no-deps --all-features
+      - run: cargo doc --lib --no-deps --all-features
 
-      - name: cargo doc --document-private-items
-        run: cargo doc --document-private-items --no-deps --all-features
-
-      - name: clippy
-        run: cargo clippy --all-targets --all-features -- -D warnings
+      - run: cargo doc --document-private-items --no-deps --all-features
 
       - name: clippy release
         run: cargo clippy --all-targets --all-features --release -- -D warnings
@@ -79,11 +69,12 @@ jobs:
   check_wasm:
     name: Check wasm32 + wasm-bindgen
     runs-on: ubuntu-22.04
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.81.0
+          toolchain: 1.88.0
           targets: wasm32-unknown-unknown
 
       - run: sudo apt-get update && sudo apt-get install libgtk-3-dev libatk1.0-dev
@@ -91,19 +82,19 @@ jobs:
       - name: Set up cargo cache
         uses: Swatinem/rust-cache@v2
 
-      - name: Check wasm32 egui_demo_app
-        run: cargo check -p egui_demo_app --lib --target wasm32-unknown-unknown
+      - name: clippy wasm32 egui_demo_app
+        run: cargo clippy -p egui_demo_app --lib --target wasm32-unknown-unknown
 
-      - name: Check wasm32 egui_demo_app --all-features
-        run: cargo check -p egui_demo_app --lib --target wasm32-unknown-unknown --all-features
+      - name: clippy wasm32 egui_demo_app --all-features
+        run: cargo clippy -p egui_demo_app --lib --target wasm32-unknown-unknown --all-features
 
-      - name: Check wasm32 eframe
-        run: cargo check -p eframe --lib --no-default-features --features glow,persistence --target wasm32-unknown-unknown
+      - name: clippy wasm32 eframe
+        run: cargo clippy -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.97"
+          version: "0.2.100" # Keep wasm-bindgen version in sync in: setup_web.sh, Cargo.toml, Cargo.lock, rust.yml
 
       - run: ./scripts/wasm_bindgen_check.sh --skip-setup
 
@@ -114,20 +105,21 @@ jobs:
   check_wasm_atomics:
     name: Check wasm32+atomics
     runs-on: ubuntu-22.04
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
       - run: sudo apt-get update && sudo apt-get install libgtk-3-dev libatk1.0-dev
 
       - name: Set up cargo cache
         uses: Swatinem/rust-cache@v2
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{env.NIGHTLY_VERSION}}
           targets: wasm32-unknown-unknown
           components: rust-src
 
       - name: Check wasm32+atomics eframe with wgpu
-        run: RUSTFLAGS='-C target-feature=+atomics' cargo +${{env.NIGHTLY_VERSION}} check -p eframe --lib --no-default-features --features wgpu --target wasm32-unknown-unknown -Z build-std=std,panic_abort
+        run: RUSTFLAGS='-C target-feature=+atomics' cargo +${{env.NIGHTLY_VERSION}} check -p eframe --lib --no-default-features --features wgpu,wgpu/webgpu --target wasm32-unknown-unknown -Z build-std=std,panic_abort
 
   # ---------------------------------------------------------------------------
 
@@ -151,11 +143,12 @@ jobs:
 
     name: cargo-deny ${{ matrix.target }}
     runs-on: ubuntu-22.04
+    timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
       - uses: EmbarkStudios/cargo-deny-action@v2
         with:
-          rust-version: "1.81.0"
+          rust-version: "1.88.0"
           log-level: error
           command: check
           arguments: --target  ${{ matrix.target }}
@@ -165,18 +158,21 @@ jobs:
   android:
     name: android
     runs-on: ubuntu-22.04
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
 
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.81.0
+          toolchain: 1.88.0
           targets: aarch64-linux-android
 
       - name: Set up cargo cache
         uses: Swatinem/rust-cache@v2
 
-      - run: cargo check --features wgpu,android-native-activity --target aarch64-linux-android
+        # Default features disabled to turn off accesskit, which does not work
+        # with NativeActivity.
+      - run: cargo check --features wgpu,android-native-activity --target aarch64-linux-android --no-default-features
         working-directory: crates/eframe
 
   # ---------------------------------------------------------------------------
@@ -184,12 +180,13 @@ jobs:
   ios:
     name: ios
     runs-on: ubuntu-22.04
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
 
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.81.0
+          toolchain: 1.88.0
           targets: aarch64-apple-ios
 
       - name: Set up cargo cache
@@ -204,20 +201,19 @@ jobs:
   windows:
     name: Check Windows
     runs-on: windows-latest
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.81.0
+          toolchain: 1.88.0
 
       - name: Set up cargo cache
         uses: Swatinem/rust-cache@v2
 
-      - name: Check all
-        run: cargo check --all-targets --all-features
+      - run: cargo clippy --all-targets --all-features
 
-      - name: Check hello_world
-        run: cargo check -p hello_world
+      - run: cargo clippy -p hello_world
 
   # ---------------------------------------------------------------------------
 
@@ -225,14 +221,14 @@ jobs:
     name: Run tests
     # We run the tests on macOS because it will run with an actual GPU
     runs-on: macos-latest
-
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
         with:
           lfs: true
-      - uses: dtolnay/rust-toolchain@master
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.81.0
+          toolchain: 1.88.0
 
       - name: Set up cargo cache
         uses: Swatinem/rust-cache@v2
diff --git a/.github/workflows/spelling_and_links.yml b/.github/workflows/spelling_and_links.yml
index d7b32b007..e09e01562 100644
--- a/.github/workflows/spelling_and_links.yml
+++ b/.github/workflows/spelling_and_links.yml
@@ -8,23 +8,29 @@ jobs:
     # install and run locally: cargo install typos-cli && typos
     name: typos
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     steps:
       - name: Checkout Actions Repository
         uses: actions/checkout@v4
 
       - name: Check spelling of entire workspace
-        uses: crate-ci/typos@master
+        uses: crate-ci/typos@v1.38.0
 
-  linkinator:
-    name: linkinator
+  lychee:
+    name: lychee
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - uses: jprochazk/linkinator-action@main
-        with:
-          linksToSkip: "https://crates.io/crates/.*, http://localhost:.*" # Avoid crates.io rate-limiting
-          retry: true
-          retryErrors: true
-          retryErrorsCount: 5
-          retryErrorsJitter: 2000
+      - name: Don't check CHANGELOG.md files
+        # This is really stupid but lychee doesn't have a way of excluding files via GLOB:
+        # https://github.com/lycheeverse/lychee/issues/1608
+
+        # We need to exclude CHANGELOG.md since we don't want to have a CI failure everytime some contributor decides
+        # to change their username.
+        run: rm -r  */**/CHANGELOG.md CHANGELOG.md
+      - name: Link Checker
+        uses: lycheeverse/lychee-action@v2
+        with:
+          args: "'**/*.md' '**/*.toml' --exclude localhost --exclude reddit.com" # I guess reddit doesn't like github action IPs
 
diff --git a/.github/workflows/update_kittest_snapshots.yml b/.github/workflows/update_kittest_snapshots.yml
new file mode 100644
index 000000000..9c67c52a9
--- /dev/null
+++ b/.github/workflows/update_kittest_snapshots.yml
@@ -0,0 +1,42 @@
+on:
+  workflow_dispatch:
+    inputs:
+      run_id:
+        description: 'The run ID that produced the artifact'
+        required: true
+        type: string
+
+permissions:
+  actions: read
+
+name: Update kittest snapshots
+jobs:
+  update-snapshots:
+    name: Update snapshots from artifact
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+          # We can't use the workflow token since that would prevent our commit to cause further workflows.
+          # See https://github.com/stefanzweifel/git-auto-commit-action#commits-made-by-this-action-do-not-trigger-new-workflow-runs
+          # This token should be a personal access token with at least Read and write permission to `Contents`.
+          # The commit action below will use the token this the code was checked out with.
+          token: '${{ secrets.SNAPSHOT_COMMIT_GITHUB_TOKEN }}'
+
+      - name: Accept snapshots
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RUN_ID: ${{ github.event.inputs.run_id }}
+        run: ./scripts/update_snapshots_from_ci.sh
+
+      - name: Git status
+        run: git status
+
+      - uses: stefanzweifel/git-auto-commit-action@v6
+        with:
+          commit_message: 'Update snapshot images'
+
diff --git a/.typos.toml b/.typos.toml
index db5bf48b4..3ae860ad9 100644
--- a/.typos.toml
+++ b/.typos.toml
@@ -3,9 +3,12 @@
 # run:      typos
 
 [default.extend-words]
-ime = "ime"       # Input Method Editor
+ime = "ime" # Input Method Editor
 nknown = "nknown" # part of @55nknown username
-ro = "ro"         # read-only, also part of the username @Phen-Ro
+isse = "isse"     # part of @IsseW username
+tye = "tye"       # part of @tye-exe username
+ro = "ro" # read-only, also part of the username @Phen-Ro
+typ = "typ" # Often used because `type` is a keyword in Rust
 
 # I mistype these so often
 tesalator = "tessellator"
@@ -17,5 +20,133 @@ teselation = "tessellation"
 tessalation = "tessellation"
 tesselation = "tessellation"
 
+
+# Use the more common spelling
+adaptor = "adapter"
+adaptors = "adapters"
+
+# For consistency we prefer American English:
+aeroplane = "airplane"
+analogue = "analog"
+analyse = "analyze"
+appetiser = "appetizer"
+arbour = "arbor"
+ardour = "arbor"
+armour = "armor"
+artefact = "artifact"
+authorise = "authorize"
+behaviour = "behavior"
+behavioural = "behavioral"
+British = "American"
+calibre = "caliber"
+# cancelled = "canceled" # winit uses this :(
+candour = "candor"
+capitalise = "capitalize"
+catalogue = "catalog"
+centre = "center"
+characterise = "characterize"
+chequerboard = "checkerboard"
+chequered = "checkered"
+civilise = "civilize"
+clamour = "clamor"
+colonise = "colonize"
+colour = "color"
+coloured = "colored"
+cosy = "cozy"
+criticise = "criticize"
+defence = "defense"
+demeanour = "demeanor"
+dialogue = "dialog"
+distil = "distill"
+doughnut = "donut"
+dramatise = "dramatize"
+draught = "draft"
+emphasise = "emphasize"
+endeavour = "endeavor"
+enrol = "enroll"
+epilogue = "epilog"
+equalise = "equalize"
+favour = "favor"
+favourite = "favorite"
+fibre = "fiber"
+flavour = "flavor"
+fulfil = "fufill"
+gaol = "jail"
+grey = "gray"
+greys = "grays"
+greyscale = "grayscale"
+harbour = "habor"
+honour = "honor"
+humour = "humor"
+instalment = "installment"
+instil = "instill"
+jewellery = "jewelry"
+kerb = "curb"
+labour = "labor"
+litre = "liter"
+lustre = "luster"
+meagre = "meager"
+metre = "meter"
+mobilise = "mobilize"
+monologue = "monolog"
+naturalise = "naturalize"
+neighbour = "neighbor"
+neighbourhood = "neighborhood"
+normalise = "normalize"
+normalised = "normalized"
+odour = "odor"
+offence = "offense"
+organise = "organize"
+parlour = "parlor"
+plough = "plow"
+popularise = "popularize"
+pretence = "pretense"
+programme = "program"
+prologue = "prolog"
+rancour = "rancor"
+realise = "realize"
+recognise = "recognize"
+recognised = "recognized"
+rigour = "rigor"
+rumour = "rumor"
+sabre = "saber"
+satirise = "satirize"
+saviour = "savior"
+savour = "savor"
+sceptical = "skeptical"
+sceptre = "scepter"
+sepulchre = "sepulcher"
+serialisation = "serialization"
+serialise = "serialize"
+serialised = "serialized"
+skilful = "skillful"
+sombre = "somber"
+specialisation = "specialization"
+specialise = "specialize"
+specialised = "specialized"
+splendour = "splendor"
+standardise = "standardize"
+sulphur = "sulfur"
+symbolise = "symbolize"
+theatre = "theater"
+tonne = "ton"
+travelogue = "travelog"
+tumour = "tumor"
+valour = "valor"
+vaporise = "vaporize"
+vigour = "vigor"
+
+# null-terminated is the name of the wikipedia article!
+# https://en.wikipedia.org/wiki/Null-terminated_string
+nullterminated = "null-terminated"
+zeroterminated = "null-terminated"
+zero-terminated = "null-terminated"
+
+
 [files]
 extend-exclude = ["web_demo/egui_demo_app.js"] # auto-generated
+
+[default]
+extend-ignore-re = [
+  "#\\[doc\\(alias = .*", # We suggest "grey" in some doc
+]
diff --git a/.vscode/settings.json b/.vscode/settings.json
index d4794e033..21d4bb4b0 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -12,28 +12,14 @@
         "target_wasm/**": true,
         "target/**": true,
     },
-    // Tell Rust Analyzer to use its own target directory, so we don't need to wait for it to finish wen we want to `cargo run`
-    "rust-analyzer.check.overrideCommand": [
-        "cargo",
-        "clippy",
-        "--target-dir=target_ra",
-        "--workspace",
-        "--message-format=json",
-        "--all-targets",
-        "--all-features",
-    ],
-    "rust-analyzer.cargo.buildScripts.overrideCommand": [
-        "cargo",
-        "clippy",
-        "--quiet",
-        "--target-dir=target_ra",
-        "--workspace",
-        "--message-format=json",
-        "--all-targets",
-        "--all-features",
-    ],
+    "rust-analyzer.check.command": "clippy",
+    // Whether `--workspace` should be passed to `cargo clippy`. If false, `-p <package>` will be passed instead.
+    "rust-analyzer.check.workspace": false,
+    "rust-analyzer.cargo.allTargets": true,
+    "rust-analyzer.cargo.features": "all",
+    // Use a separate target directory for Rust Analyzer so it doesn't prevent cargo/clippy from doing things.
+    "rust-analyzer.cargo.targetDir": "target_ra",
     "rust-analyzer.showUnlinkedFileNotification": false,
-
     // Uncomment the following options and restart rust-analyzer to get it to check code behind `cfg(target_arch=wasm32)`.
     // Don't forget to put it in a comment again before committing.
     // "rust-analyzer.cargo.target": "wasm32-unknown-unknown",
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 000f2b7ac..51d6d41d1 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -51,7 +51,7 @@ Thin wrapper around `egui_demo_lib` so we can compile it to a web site or a nati
 Depends on `egui_demo_lib` + `eframe`.
 
 ### `egui_kittest`
-A test harness for egui based on [kittest](https://github.com/rerun/kittest) and [AccessKit](https://github.com/AccessKit/accesskit/).
+A test harness for egui based on [kittest](https://github.com/rerun-io/kittest) and [AccessKit](https://github.com/AccessKit/accesskit/).
 
 ### Other integrations
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b61c6398d..856fe09da 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,394 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+### ⭐ Added
+* Add `Plugin::on_widget_under_pointer` to support widget inspector [#7652](https://github.com/emilk/egui/pull/7652) by [@juancampa](https://github.com/juancampa)
+* Add `Response::total_drag_delta` and `PointerState::total_drag_delta` [#7708](https://github.com/emilk/egui/pull/7708) by [@emilk](https://github.com/emilk)
+
+### 🔧 Changed
+* Improve accessibility and testability of `ComboBox` [#7658](https://github.com/emilk/egui/pull/7658) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🐛 Fixed
+* Fix `profiling::scope` compile error when profiling using `tracing` backend [#7646](https://github.com/emilk/egui/pull/7646) by [@PPakalns](https://github.com/PPakalns)
+* Fix edge cases in "smart aiming" in sliders [#7680](https://github.com/emilk/egui/pull/7680) by [@emilk](https://github.com/emilk)
+* Hide scroll bars when dragging other things [#7689](https://github.com/emilk/egui/pull/7689) by [@emilk](https://github.com/emilk)
+* Prevent widgets sometimes appearing to move relative to each other [#7710](https://github.com/emilk/egui/pull/7710) by [@emilk](https://github.com/emilk)
+* Fix `ui.response().interact(Sense::click())` being flakey [#7713](https://github.com/emilk/egui/pull/7713) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.33.0 - 2025-10-09 - `egui::Plugin`, better kerning, kitdiff viewer
+Highlights from this release:
+- `egui::Plugin` a improved way to create and access egui plugins
+- [kitdiff](https://github.com/rerun-io/kitdiff), a viewer for egui_kittest image snapshots (and a general image diff tool)
+- better kerning
+
+
+### Improved kerning
+As a step towards using [parley](https://github.com/linebender/parley) for font rendering, @valadaptive has refactored the font loading and rendering code. A result of this (next to the font rendering code being much nicer now) is improved kerning.
+Notice how the c moved away from the k:
+
+![Oct-09-2025 16-21-58](https://github.com/user-attachments/assets/d4a17e87-5e98-40db-a85a-fa77fa77aceb)
+
+
+### `egui::Plugin` trait
+We've added a new trait-based plugin api, meant to replace `Context::on_begin_pass` and `Context::on_end_pass`.
+This makes it a lot easier to handle state in your plugins. Instead of having to write to egui memory it can live right on your plugin struct.
+The trait based api also makes easier to add new hooks that plugins can use. In addition to `on_begin_pass` and `on_end_pass`, the `Plugin` trait now has a `input_hook` and `output_hook` which you can use to inspect / modify the `RawInput` / `FullOutput`.
+
+### kitdiff, a image diff viewer
+At rerun we have a ton of snapshots. Some PRs will change most of them (e.g. [the](https://github.com/rerun-io/rerun/pull/11253/files) [one](https://rerun-io.github.io/kitdiff/?url=https://github.com/rerun-io/rerun/pull/11253/files) that updated egui and introduced the kerning improvements, ~500 snapshots changed!).
+If you really want to look at every changed snapshot it better be as efficient as possible, and the experience on github, fiddeling with the sliders, is kind of frustrating.
+In order to fix this, we've made [kitdiff](https://rerun-io.github.io/kitdiff/).
+You can use it locally via
+- `kitdiff files .` will search for .new.png and .diff.png files
+- `kitdiff git` will compare the current files to the default branch (main/master)
+  Or in the browser via
+- going to https://rerun-io.github.io/kitdiff/ and pasting a PR or github artifact url
+- linking to kitdiff via e.g. a github workflow `https://rerun-io.github.io/kitdiff/?url=<link_to_pr_or_artifact>`
+
+To install kitdiff run `cargo install --git https://github.com/rerun-io/kitdiff`
+
+Here is a video showing the kerning changes in kitdiff ([try it yourself](https://rerun-io.github.io/kitdiff/?url=https://github.com/rerun-io/rerun/pull/11253/files)):
+
+https://github.com/user-attachments/assets/74640af1-09ba-435a-9d0c-2cbeee140c8f
+
+###  Migration guide
+- `egui::Mutex` now has a timeout as a simple deadlock detection
+    - If you use a `egui::Mutex` in some place where it's held for longer than a single frame, you should switch to the std mutex or parking_lot instead (egui mutexes are wrappers around parking lot)
+- `screen_rect` is deprecated
+    - In order to support safe areas, egui now has `viewport_rect` and `content_rect`.
+    - Update all usages of `screen_rect` to `content_rect`, unless you are sure that you want to draw outside the `safe area` (which would mean your Ui may be covered by notches, system ui, etc.)
+
+
+### ⭐ Added
+* New Plugin trait [#7385](https://github.com/emilk/egui/pull/7385) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `Ui::take_available_space()` helper function, which sets the Ui's minimum size to the available space [#7573](https://github.com/emilk/egui/pull/7573) by [@IsseW](https://github.com/IsseW)
+* Add support for the safe area on iOS [#7578](https://github.com/emilk/egui/pull/7578) by [@irh](https://github.com/irh)
+* Add `UiBuilder::global_scope` and `UiBuilder::id` [#7372](https://github.com/emilk/egui/pull/7372) by [@Icekey](https://github.com/Icekey)
+* Add `emath::fast_midpoint` [#7435](https://github.com/emilk/egui/pull/7435) by [@emilk](https://github.com/emilk)
+* Make the `hex_color` macro `const` [#7444](https://github.com/emilk/egui/pull/7444) by [@YgorSouza](https://github.com/YgorSouza)
+* Add `SurrenderFocusOn` option [#7471](https://github.com/emilk/egui/pull/7471) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `Memory::move_focus` [#7476](https://github.com/emilk/egui/pull/7476) by [@darkwater](https://github.com/darkwater)
+* Support on hover tooltip that is noninteractable even with interactable content [#5543](https://github.com/emilk/egui/pull/5543) by [@PPakalns](https://github.com/PPakalns)
+* Add rotation gesture support for trackpad sources [#7453](https://github.com/emilk/egui/pull/7453) by [@thatcomputerguy0101](https://github.com/thatcomputerguy0101)
+
+### 🔧 Changed
+* Document platform compatibility on `viewport::WindowLevel` and dependents [#7432](https://github.com/emilk/egui/pull/7432) by [@lkdm](https://github.com/lkdm)
+* Deprecated `ImageButton` and removed `WidgetType::ImageButton` [#7483](https://github.com/emilk/egui/pull/7483) by [@Stelios-Kourlis](https://github.com/Stelios-Kourlis)
+* More even text kerning [#7431](https://github.com/emilk/egui/pull/7431) by [@valadaptive](https://github.com/valadaptive)
+* Increase default text size from 12.5 to 13.0 [#7521](https://github.com/emilk/egui/pull/7521) by [@emilk](https://github.com/emilk)
+* Update accesskit to 0.21.0 [#7550](https://github.com/emilk/egui/pull/7550) by [@fundon](https://github.com/fundon)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+* Group AccessKit nodes by `Ui` [#7386](https://github.com/emilk/egui/pull/7386) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🔥 Removed
+* Remove the `deadlock_detection` feature [#7497](https://github.com/emilk/egui/pull/7497) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Remove deprecated fields from `PlatformOutput` [#7523](https://github.com/emilk/egui/pull/7523) by [@emilk](https://github.com/emilk)
+* Remove `log` feature [#7583](https://github.com/emilk/egui/pull/7583) by [@emilk](https://github.com/emilk)
+
+### 🐛 Fixed
+* Enable `clippy::iter_over_hash_type` lint [#7421](https://github.com/emilk/egui/pull/7421) by [@emilk](https://github.com/emilk)
+* Fixes sense issues in TextEdit when vertical alignment is used [#7436](https://github.com/emilk/egui/pull/7436) by [@RndUsr123](https://github.com/RndUsr123)
+* Fix stuck menu when submenu vanishes [#7589](https://github.com/emilk/egui/pull/7589) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Change Spinner widget to account for width as well as height [#7560](https://github.com/emilk/egui/pull/7560) by [@bryceberger](https://github.com/bryceberger)
+
+
+## 0.32.3 - 2025-09-12
+* Preserve text format in truncated label tooltip [#7514](https://github.com/emilk/egui/pull/7514) [#7535](https://github.com/emilk/egui/pull/7535) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix `TextEdit`'s in RTL layouts [#5547](https://github.com/emilk/egui/pull/5547) by [@zakarumych](https://github.com/zakarumych)
+
+
+## 0.32.2 - 2025-09-04
+* Fix: `SubMenu` should not display when ui is disabled [#7428](https://github.com/emilk/egui/pull/7428) by [@ozwaldorf](https://github.com/ozwaldorf)
+* Remove line breaks when pasting into single line TextEdit [#7441](https://github.com/emilk/egui/pull/7441) by [@YgorSouza](https://github.com/YgorSouza)
+* Panic mutexes that can't lock for 30 seconds, in debug builds [#7468](https://github.com/emilk/egui/pull/7468) by [@emilk](https://github.com/emilk)
+* Add `Ui::place`, to place widgets without changing the cursor [#7359](https://github.com/emilk/egui/pull/7359) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix: prevent calendar popup from closing on dropdown change [#7409](https://github.com/emilk/egui/pull/7409) by [@AStrizh](https://github.com/AStrizh)
+
+
+## 0.32.1 - 2025-08-15 - Misc bug fixes
+### ⭐ Added
+* Add `ComboBox::popup_style` [#7360](https://github.com/emilk/egui/pull/7360) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🐛 Fixed
+* Fix glyph rendering: clamp coverage to [0, 1] [#7415](https://github.com/emilk/egui/pull/7415) by [@emilk](https://github.com/emilk)
+* Fix manual `Popup` not closing [#7383](https://github.com/emilk/egui/pull/7383) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix `WidgetText::Text` ignoring fallback font and overrides [#7361](https://github.com/emilk/egui/pull/7361) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix `override_text_color` priority [#7439](https://github.com/emilk/egui/pull/7439) by [@YgorSouza](https://github.com/YgorSouza)
+* Fix debug-panic in ScrollArea if contents fit without scrolling [#7440](https://github.com/emilk/egui/pull/7440) by [@YgorSouza](https://github.com/YgorSouza)
+
+
+## 0.32.0 - 2025-07-10 - Atoms, popups, and better SVG support
+This is a big egui release, with several exciting new features!
+
+* _Atoms_ are new layout primitives in egui, for text and images
+* Popups, tooltips and menus have undergone a complete rewrite
+* Much improved SVG support
+* Crisper graphics (especially text!)
+
+Let's dive in!
+
+### ⚛️ Atoms
+
+`egui::Atom` is the new, indivisible building blocks of egui (hence their name).
+An `Atom` is an `enum` that can be either `WidgetText`, `Image`, or `Custom`.
+
+The new `AtomLayout` can be used within widgets to do basic layout.
+The initial implementation is as minimal as possible, doing just enough to implement what `Button` could do before.
+There is a new `IntoAtoms` trait that works with tuples of `Atom`s. Each atom can be customized with the `AtomExt` trait
+which works on everything that implements `Into<Atom>`, so e.g. `RichText` or `Image`.
+So to create a `Button` with text and image you can now do:
+```rs
+let image = include_image!("my_icon.png").atom_size(Vec2::splat(12.0));
+ui.button((image, "Click me!"));
+```
+
+Anywhere you see `impl IntoAtoms` you can add any number of images and text, in any order.
+
+As of 0.32, we have ported the `Button`, `Checkbox`, `RadioButton` to use atoms
+(meaning they support adding Atoms and are built on top of `AtomLayout`).
+The `Button` implementation is not only more powerful now, but also much simpler, removing ~130 lines of layout math.
+
+In combination with `ui.read_response`, custom widgets are really simple now, here is a minimal button implementation:
+
+```rs
+pub struct ALButton<'a> {
+    al: AtomLayout<'a>,
+}
+
+impl<'a> ALButton<'a> {
+    pub fn new(content: impl IntoAtoms<'a>) -> Self {
+        Self {
+            al: AtomLayout::new(content.into_atoms()).sense(Sense::click()),
+        }
+    }
+}
+
+impl<'a> Widget for ALButton<'a> {
+    fn ui(mut self, ui: &mut Ui) -> Response {
+        let Self { al } = self;
+        let response = ui.ctx().read_response(ui.next_auto_id());
+
+        let visuals = response.map_or(&ui.style().visuals.widgets.inactive, |response| {
+            ui.style().interact(&response)
+        });
+
+        let al = al.frame(
+            Frame::new()
+                .inner_margin(ui.style().spacing.button_padding)
+                .fill(visuals.bg_fill)
+                .stroke(visuals.bg_stroke)
+                .corner_radius(visuals.corner_radius),
+        );
+
+        al.show(ui).response
+    }
+}
+```
+
+You can even use `Atom::custom` to add custom content to Widgets. Here is a button in a button:
+
+https://github.com/user-attachments/assets/8c649784-dcc5-4979-85f8-e735b9cdd090
+
+```rs
+let custom_button_id = Id::new("custom_button");
+let response = Button::new((
+    Atom::custom(custom_button_id, Vec2::splat(18.0)),
+    "Look at my mini button!",
+))
+.atom_ui(ui);
+if let Some(rect) = response.rect(custom_button_id) {
+    ui.put(rect, Button::new("🔎").frame_when_inactive(false));
+}
+```
+Currently, you need to use `atom_ui` to get a `AtomResponse` which will have the `Rect` to use, but in the future
+this could be streamlined, e.g. by adding a `AtomKind::Callback` or by passing the Rects back with `egui::Response`.
+
+Basing our widgets on `AtomLayout` also allowed us to improve `Response::intrinsic_size`, which will now report the
+correct size even if widgets are truncated. `intrinsic_size` is the size that a non-wrapped, non-truncated,
+non-justified version of the widget would have, and can be useful in advanced layout
+calculations like [egui_flex](https://github.com/lucasmerlin/hello_egui/tree/main/crates/egui_flex).
+
+##### Details
+* Add `AtomLayout`, abstracting layouting within widgets [#5830](https://github.com/emilk/egui/pull/5830) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `Galley::intrinsic_size` and use it in `AtomLayout` [#7146](https://github.com/emilk/egui/pull/7146) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+### ❕ Improved popups, tooltips, and menus
+
+Introduces a new `egui::Popup` api. Checkout the new demo on https://egui.rs:
+
+https://github.com/user-attachments/assets/74e45243-7d05-4fc3-b446-2387e1412c05
+
+We introduced a new `RectAlign` helper to align a rect relative to an other rect. The `Popup` will by default try to find the best `RectAlign` based on the source widgets position (previously submenus would annoyingly overlap if at the edge of the window):
+
+https://github.com/user-attachments/assets/0c5adb6b-8310-4e0a-b936-646bb4ec02f7
+
+`Tooltip` and `menu` have been rewritten based on the new `Popup` api. They are now compatible with each other, meaning you can just show a `ui.menu_button()` in any `Popup` to get a sub menu. There are now customizable `MenuButton` and `SubMenuButton` structs, to help with customizing your menu buttons. This means menus now also support `PopupCloseBehavior` so you can remove your `close_menu` calls from your click handlers!
+
+The old tooltip and popup apis have been ported to the new api so there should be very little breaking changes. The old menu is still around but deprecated. `ui.menu_button` etc now open the new menu, if you can't update to the new one immediately you can use the old buttons from the deprecated `egui::menu` menu.
+
+We also introduced `ui.close()` which closes the nearest container. So you can now conveniently close `Window`s, `Collapsible`s, `Modal`s and `Popup`s from within. To use this for your own containers, call `UiBuilder::closable` and then check for closing within that ui via `ui.should_close()`.
+
+##### Details
+* Add `Popup` and `Tooltip`, unifying the previous behaviours [#5713](https://github.com/emilk/egui/pull/5713) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `Ui::close` and `Response::should_close` [#5729](https://github.com/emilk/egui/pull/5729) by [@lucasmerlin](https://github.com/lucasmerlin)
+* ⚠️ Improved menu based on `egui::Popup` [#5716](https://github.com/emilk/egui/pull/5716) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add a toggle for the compact menu style [#5777](https://github.com/emilk/egui/pull/5777) by [@s-nie](https://github.com/s-nie)
+* Use the new `Popup` API for the color picker button [#7137](https://github.com/emilk/egui/pull/7137) by [@lucasmerlin](https://github.com/lucasmerlin)
+* ⚠️ Close popup if `Memory::keep_popup_open` isn't called [#5814](https://github.com/emilk/egui/pull/5814) by [@juancampa](https://github.com/juancampa)
+* Fix tooltips sometimes changing position each frame [#7304](https://github.com/emilk/egui/pull/7304) by [@emilk](https://github.com/emilk)
+* Change popup memory to be per-viewport [#6753](https://github.com/emilk/egui/pull/6753) by [@mkalte666](https://github.com/mkalte666)
+* Deprecate `Memory::popup` API in favor of new `Popup` API [#7317](https://github.com/emilk/egui/pull/7317) by [@emilk](https://github.com/emilk)
+
+
+### ▲ Improved SVG support
+You can render SVG in egui with
+
+```rs
+ui.add(egui::Image::new(egui::include_image!("icon.svg"));
+```
+
+(Requires the use of `egui_extras`, with the `svg` feature enabled and a call to [`install_image_loaders`](https://docs.rs/egui_extras/latest/egui_extras/fn.install_image_loaders.html)).
+
+Previously this would sometimes result in a blurry SVG, epecially if the `Image` was set to be dynamically scale based on the size of the `Ui` that contained it. Now SVG:s are always pixel-perfect, for truly scalable graphics.
+
+![svg-scaling](https://github.com/user-attachments/assets/faf63f0c-0ff7-47a0-a4cb-7210efeccb72)
+
+##### Details
+* Support text in SVGs [#5979](https://github.com/emilk/egui/pull/5979) by [@cernec1999](https://github.com/cernec1999)
+* Fix sometimes blurry SVGs [#7071](https://github.com/emilk/egui/pull/7071) by [@emilk](https://github.com/emilk)
+* Fix incorrect color fringe colors on SVG:s [#7069](https://github.com/emilk/egui/pull/7069) by [@emilk](https://github.com/emilk)
+* Make `Image::paint_at` pixel-perfect crisp for SVG images [#7078](https://github.com/emilk/egui/pull/7078) by [@emilk](https://github.com/emilk)
+
+
+### ✨ Crisper graphics
+Non-SVG icons are also rendered better, and text sharpness has been improved, especially in light mode.
+
+![image](https://github.com/user-attachments/assets/7f370aaf-886a-423c-8391-c378849b63ca)
+
+##### Details
+* Improve text sharpness [#5838](https://github.com/emilk/egui/pull/5838) by [@emilk](https://github.com/emilk)
+* Improve text rendering in light mode [#7290](https://github.com/emilk/egui/pull/7290) by [@emilk](https://github.com/emilk)
+* Improve texture filtering by doing it in gamma space [#7311](https://github.com/emilk/egui/pull/7311) by [@emilk](https://github.com/emilk)
+* Make text underline and strikethrough pixel perfect crisp [#5857](https://github.com/emilk/egui/pull/5857) by [@emilk](https://github.com/emilk)
+
+### Migration guide
+We have some silently breaking changes (code compiles fine but behavior changed) that require special care:
+
+#### Menus close on click by default
+- previously menus would only close on click outside
+- either
+    - remove the `ui.close_menu()` calls from button click handlers since they are obsolete
+    - if the menu should stay open on clicks, change the `PopupCloseBehavior`:
+      ```rs
+          // Change this
+        ui.menu_button("Text", |ui| { /* Menu Content */ });
+          // To this:
+        MenuButton::new("Text").config(
+            MenuConfig::default().close_behavior(PopupCloseBehavior::CloseOnClickOutside),
+        ).ui(ui, |ui| { /* Menu Content */ });
+        ```
+      You can also change the behavior only for a single SubMenu by using `SubMenuButton`, but by default it should be passed to any submenus when using `MenuButton`.
+
+#### `Memory::is_popup_open` api now requires calls to `Memory::keep_popup_open`
+- The popup will immediately close if `keep_popup_open` is not called.
+- It's recommended to use the new `Popup` api which handles this for you.
+- If you can't switch to the new api for some reason, update the code to call `keep_popup_open`:
+  ```rs
+      if ui.memory(|mem| mem.is_popup_open(popup_id)) {
+        ui.memory_mut(|mem| mem.keep_popup_open(popup_id)); // <- add this line
+        let area_response = Area::new(popup_id).show(...)
+      }
+  ```
+
+### ⭐ Other improvements
+* Add `Label::show_tooltip_when_elided` [#5710](https://github.com/emilk/egui/pull/5710) by [@bryceberger](https://github.com/bryceberger)
+* Deprecate `Ui::allocate_new_ui` in favor of `Ui::scope_builder` [#5764](https://github.com/emilk/egui/pull/5764) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `expand_bg` to customize size of text background [#5365](https://github.com/emilk/egui/pull/5365) by [@MeGaGiGaGon](https://github.com/MeGaGiGaGon)
+* Add assert messages and print bad argument values in asserts [#5216](https://github.com/emilk/egui/pull/5216) by [@bircni](https://github.com/bircni)
+* Use `TextBuffer` for `layouter` in `TextEdit` instead of `&str` [#5712](https://github.com/emilk/egui/pull/5712) by [@kernelkind](https://github.com/kernelkind)
+* Add a `Slider::update_while_editing(bool)` API [#5978](https://github.com/emilk/egui/pull/5978) by [@mbernat](https://github.com/mbernat)
+* Add `Scene::drag_pan_buttons` option. Allows specifying which pointer buttons pan the scene by dragging [#5892](https://github.com/emilk/egui/pull/5892) by [@mitchmindtree](https://github.com/mitchmindtree)
+* Add `Scene::sense` to customize how `Scene` responds to user input [#5893](https://github.com/emilk/egui/pull/5893) by [@mitchmindtree](https://github.com/mitchmindtree)
+* Rework `TextEdit` arrow navigation to handle Unicode graphemes [#5812](https://github.com/emilk/egui/pull/5812) by [@MStarha](https://github.com/MStarha)
+* `ScrollArea` improvements for user configurability [#5443](https://github.com/emilk/egui/pull/5443) by [@MStarha](https://github.com/MStarha)
+* Add `Response::clicked_with_open_in_background` [#7093](https://github.com/emilk/egui/pull/7093) by [@emilk](https://github.com/emilk)
+* Add `Modifiers::matches_any` [#7123](https://github.com/emilk/egui/pull/7123) by [@emilk](https://github.com/emilk)
+* Add `Context::format_modifiers` [#7125](https://github.com/emilk/egui/pull/7125) by [@emilk](https://github.com/emilk)
+* Add `OperatingSystem::is_mac` [#7122](https://github.com/emilk/egui/pull/7122) by [@emilk](https://github.com/emilk)
+* Support vertical-only scrolling by holding down Alt [#7124](https://github.com/emilk/egui/pull/7124) by [@emilk](https://github.com/emilk)
+* Support for back-button on Android [#7073](https://github.com/emilk/egui/pull/7073) by [@ardocrat](https://github.com/ardocrat)
+* Select all text in DragValue when gaining focus via keyboard [#7107](https://github.com/emilk/egui/pull/7107) by [@Azkellas](https://github.com/Azkellas)
+* Add `Context::current_pass_index` [#7276](https://github.com/emilk/egui/pull/7276) by [@emilk](https://github.com/emilk)
+* Add `Context::cumulative_frame_nr` [#7278](https://github.com/emilk/egui/pull/7278) by [@emilk](https://github.com/emilk)
+* Add `Visuals::text_edit_bg_color` [#7283](https://github.com/emilk/egui/pull/7283) by [@emilk](https://github.com/emilk)
+* Add `Visuals::weak_text_alpha` and `weak_text_color` [#7285](https://github.com/emilk/egui/pull/7285) by [@emilk](https://github.com/emilk)
+* Add support for scrolling via accesskit / kittest [#7286](https://github.com/emilk/egui/pull/7286) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Update area struct to allow force resizing [#7114](https://github.com/emilk/egui/pull/7114) by [@blackberryfloat](https://github.com/blackberryfloat)
+* Add `egui::Sides` `shrink_left` / `shrink_right` [#7295](https://github.com/emilk/egui/pull/7295) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Set intrinsic size for Label [#7328](https://github.com/emilk/egui/pull/7328) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🔧 Changed
+* Raise MSRV to 1.85 [#6848](https://github.com/emilk/egui/pull/6848) by [@torokati44](https://github.com/torokati44), [#7279](https://github.com/emilk/egui/pull/7279) by [@emilk](https://github.com/emilk)
+* Set `hint_text` in `WidgetInfo` [#5724](https://github.com/emilk/egui/pull/5724) by [@bircni](https://github.com/bircni)
+* Implement `Default` for `ThemePreference` [#5702](https://github.com/emilk/egui/pull/5702) by [@MichaelGrupp](https://github.com/MichaelGrupp)
+* Align `available_rect` docs with the new reality after #4590 [#5701](https://github.com/emilk/egui/pull/5701) by [@podusowski](https://github.com/podusowski)
+* Clarify platform-specific details for `Viewport` positioning [#5715](https://github.com/emilk/egui/pull/5715) by [@aspiringLich](https://github.com/aspiringLich)
+* Simplify the text cursor API [#5785](https://github.com/emilk/egui/pull/5785) by [@valadaptive](https://github.com/valadaptive)
+* Bump accesskit to 0.19 [#7040](https://github.com/emilk/egui/pull/7040) by [@valadaptive](https://github.com/valadaptive)
+* Better define the meaning of `SizeHint` [#7079](https://github.com/emilk/egui/pull/7079) by [@emilk](https://github.com/emilk)
+* Move all input-related options into `InputOptions` [#7121](https://github.com/emilk/egui/pull/7121) by [@emilk](https://github.com/emilk)
+* `Button` inherits the `alt_text` of the `Image` in it, if any [#7136](https://github.com/emilk/egui/pull/7136) by [@emilk](https://github.com/emilk)
+* Change API of `Tooltip` slightly [#7151](https://github.com/emilk/egui/pull/7151) by [@emilk](https://github.com/emilk)
+* Use Rust edition 2024 [#7280](https://github.com/emilk/egui/pull/7280) by [@emilk](https://github.com/emilk)
+* Change `ui.disable()` to modify opacity [#7282](https://github.com/emilk/egui/pull/7282) by [@emilk](https://github.com/emilk)
+* Make the font atlas use a color image [#7298](https://github.com/emilk/egui/pull/7298) by [@valadaptive](https://github.com/valadaptive)
+* Implement `BitOr` and `BitOrAssign` for `Rect` [#7319](https://github.com/emilk/egui/pull/7319) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🔥 Removed
+* Remove things that have been deprecated for over a year [#7099](https://github.com/emilk/egui/pull/7099) by [@emilk](https://github.com/emilk)
+* Remove `SelectableLabel` [#7277](https://github.com/emilk/egui/pull/7277) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🐛 Fixed
+* `Scene`: make `scene_rect` full size on reset [#5801](https://github.com/emilk/egui/pull/5801) by [@graydenshand](https://github.com/graydenshand)
+* `Scene`: `TextEdit` selection when placed in a `Scene` [#5791](https://github.com/emilk/egui/pull/5791) by [@karhu](https://github.com/karhu)
+* `Scene`: Set transform layer before calling user content [#5884](https://github.com/emilk/egui/pull/5884) by [@mitchmindtree](https://github.com/mitchmindtree)
+* Fix: transform `TextShape` underline width [#5865](https://github.com/emilk/egui/pull/5865) by [@emilk](https://github.com/emilk)
+* Fix missing repaint after `consume_key` [#7134](https://github.com/emilk/egui/pull/7134) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Update `emoji-icon-font` with fix for fullwidth latin characters [#7067](https://github.com/emilk/egui/pull/7067) by [@emilk](https://github.com/emilk)
+* Mark all keys as released if the app loses focus [#5743](https://github.com/emilk/egui/pull/5743) by [@emilk](https://github.com/emilk)
+* Fix scroll handle extending outside of `ScrollArea` [#5286](https://github.com/emilk/egui/pull/5286) by [@gilbertoalexsantos](https://github.com/gilbertoalexsantos)
+* Fix `Response::clicked_elsewhere` not returning `true` sometimes [#5798](https://github.com/emilk/egui/pull/5798) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix kinetic scrolling on touch devices [#5778](https://github.com/emilk/egui/pull/5778) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix `DragValue` expansion when editing [#5809](https://github.com/emilk/egui/pull/5809) by [@MStarha](https://github.com/MStarha)
+* Fix disabled `DragValue` eating focus, causing focus to reset [#5826](https://github.com/emilk/egui/pull/5826) by [@KonaeAkira](https://github.com/KonaeAkira)
+* Fix semi-transparent colors appearing too bright [#5824](https://github.com/emilk/egui/pull/5824) by [@emilk](https://github.com/emilk)
+* Improve drag-to-select text (add margins) [#5797](https://github.com/emilk/egui/pull/5797) by [@hankjordan](https://github.com/hankjordan)
+* Fix bug in pointer movement detection [#5329](https://github.com/emilk/egui/pull/5329) by [@rustbasic](https://github.com/rustbasic)
+* Protect against NaN in hit-test code [#6851](https://github.com/emilk/egui/pull/6851) by [@Skgland](https://github.com/Skgland)
+* Fix image button panicking with tiny `available_space` [#6900](https://github.com/emilk/egui/pull/6900) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix links and text selection in horizontal_wrapped layout [#6905](https://github.com/emilk/egui/pull/6905) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Fix `leading_space` sometimes being ignored during paragraph splitting [#7031](https://github.com/emilk/egui/pull/7031) by [@afishhh](https://github.com/afishhh)
+* Fix typo in deprecation message for `ComboBox::from_id_source` [#7055](https://github.com/emilk/egui/pull/7055) by [@aelmizeb](https://github.com/aelmizeb)
+* Bug fix: make sure `end_pass` is called for all loaders [#7072](https://github.com/emilk/egui/pull/7072) by [@emilk](https://github.com/emilk)
+* Report image alt text as text if widget contains no other text [#7142](https://github.com/emilk/egui/pull/7142) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Slider: move by at least the next increment when using fixed_decimals [#7066](https://github.com/emilk/egui/pull/7066) by [@0x53A](https://github.com/0x53A)
+* Fix crash when using infinite widgets [#7296](https://github.com/emilk/egui/pull/7296) by [@emilk](https://github.com/emilk)
+* Fix `debug_assert` triggered by `menu`/`intersect_ray` [#7299](https://github.com/emilk/egui/pull/7299) by [@emilk](https://github.com/emilk)
+* Change `Rect::area` to return zero for negative rectangles [#7305](https://github.com/emilk/egui/pull/7305) by [@emilk](https://github.com/emilk)
+
+### 🚀 Performance
+* Optimize editing long text by caching each paragraph [#5411](https://github.com/emilk/egui/pull/5411) by [@afishhh](https://github.com/afishhh)
+* Make `WidgetText` smaller and faster [#6903](https://github.com/emilk/egui/pull/6903) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.31.1 - 2025-03-05
+* Fix sizing bug in `TextEdit::singleline` [#5640](https://github.com/emilk/egui/pull/5640) by [@IaVashik](https://github.com/IaVashik)
+* Fix panic when rendering thin textured rectangles [#5692](https://github.com/emilk/egui/pull/5692) by [@PPakalns](https://github.com/PPakalns)
+
+
 ## 0.31.0 - 2025-02-04 - Scene container, improved rendering quality
 
 ### Highlights ✨
@@ -103,7 +491,7 @@ In order to pave the path for more complex and customizable styling solutions, w
 * Improved support for transform layers ([#5465](https://github.com/emilk/egui/pull/5465), [#5468](https://github.com/emilk/egui/pull/5468), [#5429](https://github.com/emilk/egui/pull/5429))
 
 #### `egui_kittest`
-This release welcomes a new crate to the family: [egui_kittest](https://github.com/emilk/egui/tree/master/crates/egui_kittest).
+This release welcomes a new crate to the family: [egui_kittest](https://github.com/emilk/egui/tree/main/crates/egui_kittest).
 `egui_kittest` is a testing framework for egui, allowing you to test both automation (simulated clicks and other events),
 and also do screenshot testing (useful for regression tests).
 `egui_kittest` is built using [`kittest`](https://github.com/rerun-io/kittest), which is a general GUI testing framework that aims to work with any Rust GUI (not just egui!).
@@ -321,7 +709,7 @@ There also has been several small improvements to the look of egui:
 * The `extra_asserts` and `extra_debug_asserts` feature flags have been removed ([#4478](https://github.com/emilk/egui/pull/4478))
 * Remove `Event::Scroll` and handle it in egui. Use `Event::MouseWheel` instead ([#4524](https://github.com/emilk/egui/pull/4524))
 * `Event::Zoom` is no longer emitted on ctrl+scroll. Use `InputState::smooth_scroll_delta` instead ([#4524](https://github.com/emilk/egui/pull/4524))
-* `ui.set_enabled` and `set_visbile` have  been deprecated ([#4614](https://github.com/emilk/egui/pull/4614))
+* `ui.set_enabled` and `set_visible` have  been deprecated ([#4614](https://github.com/emilk/egui/pull/4614))
 * `DragValue::clamp_range` renamed to `range` (([#4728](https://github.com/emilk/egui/pull/4728))
 
 ### ⭐ Added
@@ -937,7 +1325,7 @@ egui_extras::install_image_loaders(egui_ctx);
 ## 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 `Shape::Callback` for backend-specific painting, [with an example](https://github.com/emilk/egui/tree/main/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)).
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 48c9e9ae5..d3140d942 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -34,14 +34,11 @@ Browse through [`ARCHITECTURE.md`](ARCHITECTURE.md) to get a sense of how all pi
 You can test your code locally by running `./scripts/check.sh`.
 There are snapshots test that might need to be updated.
 Run the tests with `UPDATE_SNAPSHOTS=true cargo test --workspace --all-features` to update all of them.
+If CI keeps complaining about snapshots (which could happen if you don't use macOS, snapshots in CI are currently
+rendered with macOS), you can instead run `./scripts/update_snapshots_from_ci.sh` to update your local snapshots from
+the last CI run of your PR (which will download the `test_results` artifact).
 For more info about the tests see [egui_kittest](./crates/egui_kittest/README.md).
-
-We use [git-lfs](https://git-lfs.com/) to store big files in the repository.
-Make sure you have it installed (running `git lfs ls-files` from the repository root should list some files).
-Don't forget to run `git lfs install` after installing the git-lfs binary.
-You need to add any .png images to `git lfs`.
-If the CI complains about this, make sure you run `git add --renormalize .`.
-
+Snapshots and other big files are stored with git lfs. See [Working with git lfs](#working-with-git-lfs) for more info.
 If you see an `InvalidSignature` error when running snapshot tests, it's probably a problem related to git-lfs.
 
 When you have something that works, open a draft PR. You may get some helpful feedback early!
@@ -51,6 +48,34 @@ Don't worry about having many small commits in the PR - they will be squashed to
 
 Please keep pull requests small and focused. The smaller it is, the more likely it is to get merged.
 
+## Working with git lfs
+
+We use [git-lfs](https://git-lfs.com/) to store big files in the repository.
+Make sure you have it installed (running `git lfs ls-files` from the repository root should list some files).
+Don't forget to run `git lfs install` in this repo after installing the git-lfs binary.
+You need to add any .png images to `git lfs` (see the .gitattributes file for rules and exclusions).
+If the CI complains about lfs, try running `git add --renormalize .`.
+
+Common git-lfs commands:
+```bash
+# Install git-lfs in the repo (installs git hooks)
+git lfs install
+
+# Move a file to git lfs
+git lfs track "path/to/file/or/pattern" # OR manually edit .gitattributes
+git add --renormalize . # Moves already added files to lfs (according to .gitattributes)
+
+# Move a file from lfs to regular git
+git lfs untrack "path/to/file/or/pattern" # OR manually edit .gitattributes
+git add --renormalize . # Moves already added files to regular git (according to .gitattributes)
+
+# Push to a contributor remote (see https://github.com/cli/cli/discussions/8794#discussioncomment-8695076)
+git push --no-verify
+
+# Push git lfs files to contributor remote:
+git push origin $(git branch --show-current) && git push --no-verify && git push origin --delete $(git branch --show-current)
+```
+
 ## PR review
 
 Most PR reviews are done by me, Emil, but I very much appreciate any help I can get reviewing PRs!
@@ -103,6 +128,7 @@ While using an immediate mode gui is simple, implementing one is a lot more tric
 * Flip `if !condition {} else {}`
 * Sets of things should be lexicographically sorted (e.g. crate dependencies in `Cargo.toml`)
 * Put each type in their own file, unless they are trivial (e.g. a `struct` with no `impl`)
+* Put most generic arguments first (e.g. `Context`), and most specific last
 * Break the above rules when it makes sense
 
 
diff --git a/Cargo.lock b/Cargo.lock
index 4956e1436..61bf459b5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,12 +1,12 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "ab_glyph"
-version = "0.2.29"
+version = "0.2.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3672c180e71eeaaac3a541fbbc5f5ad4def8b747c595ad30d674e43049f7b0"
+checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"
 dependencies = [
  "ab_glyph_rasterizer",
  "owned_ttf_parser",
@@ -20,9 +20,9 @@ checksum = "c71b1793ee61086797f5c80b6efa2b8ffa6d5dd703f118545808a7f2e27f7046"
 
 [[package]]
 name = "accesskit"
-version = "0.17.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45c97bb3cc1dacbdc6d1147040fc61309590d3e1ab5efd92a8a09c7a2e07284c"
+checksum = "cf203f9d3bd8f29f98833d1fbef628df18f759248a547e7e01cfbf63cda36a99"
 dependencies = [
  "enumn",
  "serde",
@@ -30,47 +30,47 @@ dependencies = [
 
 [[package]]
 name = "accesskit_atspi_common"
-version = "0.10.0"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03db49d2948db6875c69a1ef17816efa8e3d9f36c7cd79e467d8562a6695662b"
+checksum = "29f73a9b855b6f4af4962a94553ef0c092b80cf5e17038724d5e30945d036f69"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
  "atspi-common",
  "serde",
  "thiserror 1.0.66",
- "zvariant 4.2.0",
+ "zvariant",
 ]
 
 [[package]]
 name = "accesskit_consumer"
-version = "0.25.0"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa3a17950ce0d911f132387777b9b3d05eddafb59b773ccaa53fceefaeb0228e"
+checksum = "bdd06f5fea9819250fffd4debf926709f3593ac22f8c1541a2573e5ee0ca01cd"
 dependencies = [
  "accesskit",
- "immutable-chunkmap",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
 name = "accesskit_macos"
-version = "0.18.0"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8d94b7544775dddce398e2500a8b3cc2be3655190879071ce6a9e5610195be4"
+checksum = "93fbaf15815f39084e0cb24950c232f0e3634702c2dfbf182ae3b4919a4a1d45"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
- "once_cell",
+ "hashbrown 0.15.2",
+ "objc2 0.5.2",
+ "objc2-app-kit 0.2.2",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
 name = "accesskit_unix"
-version = "0.13.0"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a88d913b144104dd825f75db1b82c63d754b01c53c2f9b7545dcdfae63bb0ed"
+checksum = "64926a930368d52d95422b822ede15014c04536cabaa2394f99567a1f4788dc6"
 dependencies = [
  "accesskit",
  "accesskit_atspi_common",
@@ -81,42 +81,42 @@ dependencies = [
  "futures-lite",
  "futures-util",
  "serde",
- "zbus 4.4.0",
+ "zbus",
 ]
 
 [[package]]
 name = "accesskit_windows"
-version = "0.24.0"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0aaa870a5d047338f03707706141f22c98c20e79d5403bf3c9b195549e6cdeea"
+checksum = "792991159fa9ba57459de59e12e918bb90c5346fea7d40ac1a11f8632b41e63a"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
- "paste",
+ "hashbrown 0.15.2",
  "static_assertions",
- "windows",
- "windows-core 0.58.0",
+ "windows 0.61.1",
+ "windows-core 0.61.0",
 ]
 
 [[package]]
 name = "accesskit_winit"
-version = "0.23.0"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3555a67a9bb208f620cfc3746f1502d1512f0ffbdb19c6901aa90b111aa56ec5"
+checksum = "cd9db0ea66997e3f4eae4a5f2c6b6486cf206642639ee629dbbb860ace1dec87"
 dependencies = [
  "accesskit",
  "accesskit_macos",
  "accesskit_unix",
  "accesskit_windows",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "winit",
 ]
 
 [[package]]
 name = "addr2line"
-version = "0.24.2"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
  "gimli",
 ]
@@ -129,16 +129,16 @@ checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
 [[package]]
 name = "ahash"
-version = "0.8.11"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
- "getrandom",
+ "getrandom 0.3.1",
  "once_cell",
  "serde",
  "version_check",
- "zerocopy",
+ "zerocopy 0.8.27",
 ]
 
 [[package]]
@@ -150,12 +150,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "allocator-api2"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
-
 [[package]]
 name = "android-activity"
 version = "0.6.0"
@@ -163,7 +157,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef6978589202a00cd7e118380c448a08b6ed394c3a8df3a430d0898e3a42d046"
 dependencies = [
  "android-properties",
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "cc",
  "cesu8",
  "jni",
@@ -172,7 +166,7 @@ dependencies = [
  "log",
  "ndk",
  "ndk-context",
- "ndk-sys 0.6.0+11769913",
+ "ndk-sys",
  "num_enum",
  "thiserror 1.0.66",
 ]
@@ -183,23 +177,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04"
 
-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
 [[package]]
 name = "android_log-sys"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ecc8056bf6ab9892dcd53216c83d1597487d7dacac16c8df6b877d127df9937"
+checksum = "84521a3cf562bc62942e294181d9eef17eb38ceb8c68677bc49f144e4c3d4f8d"
 
 [[package]]
 name = "android_logger"
-version = "0.14.1"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b07e8e73d720a1f2e4b6014766e6039fd2e96a4fa44e2a78d0e1fa2ff49826"
+checksum = "dbb4e440d04be07da1f1bf44fb4495ebd58669372fe0cffa6e48595ac5bd88a3"
 dependencies = [
  "android_log-sys",
  "env_filter",
@@ -221,12 +209,56 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
 [[package]]
 name = "anstyle"
 version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56"
 
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+dependencies = [
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.92"
@@ -235,19 +267,21 @@ checksum = "74f37166d7d48a0284b99dd824694c26119c700b53bf0d1540cdb147dbdaaf13"
 
 [[package]]
 name = "arboard"
-version = "3.4.1"
+version = "3.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df099ccb16cd014ff054ac1bf392c67feeef57164b05c42f037cd40f5d4357f4"
+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
 dependencies = [
  "clipboard-win",
- "core-graphics",
  "image",
  "log",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
+ "objc2 0.6.3",
+ "objc2-app-kit 0.3.2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation 0.3.2",
  "parking_lot",
- "windows-sys 0.48.0",
+ "percent-encoding",
+ "windows-sys 0.60.2",
  "x11rb",
 ]
 
@@ -280,24 +314,24 @@ dependencies = [
 
 [[package]]
 name = "ashpd"
-version = "0.10.2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9c39d707614dbcc6bed00015539f488d8e3fe3e66ed60961efc0c90f4b380b3"
+checksum = "6cbdf310d77fd3aaee6ea2093db7011dc2d35d2eb3481e5607f1f8d942ed99df"
 dependencies = [
  "async-fs",
  "async-net",
  "enumflags2",
  "futures-channel",
  "futures-util",
- "rand",
- "raw-window-handle 0.6.2",
+ "rand 0.9.2",
+ "raw-window-handle",
  "serde",
  "serde_repr",
  "url",
  "wayland-backend",
  "wayland-client",
  "wayland-protocols",
- "zbus 5.1.1",
+ "zbus",
 ]
 
 [[package]]
@@ -361,7 +395,7 @@ dependencies = [
  "futures-lite",
  "parking",
  "polling",
- "rustix",
+ "rustix 0.38.38",
  "slab",
  "tracing",
  "windows-sys 0.59.0",
@@ -404,7 +438,7 @@ dependencies = [
  "cfg-if",
  "event-listener",
  "futures-lite",
- "rustix",
+ "rustix 0.38.38",
  "tracing",
 ]
 
@@ -431,7 +465,7 @@ dependencies = [
  "cfg-if",
  "futures-core",
  "futures-io",
- "rustix",
+ "rustix 0.38.38",
  "signal-hook-registry",
  "slab",
  "windows-sys 0.59.0",
@@ -462,9 +496,9 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "atspi"
-version = "0.22.0"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be534b16650e35237bb1ed189ba2aab86ce65e88cc84c66f4935ba38575cecbf"
+checksum = "c83247582e7508838caf5f316c00791eee0e15c0bf743e6880585b867e16815c"
 dependencies = [
  "atspi-common",
  "atspi-connection",
@@ -473,42 +507,41 @@ dependencies = [
 
 [[package]]
 name = "atspi-common"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1909ed2dc01d0a17505d89311d192518507e8a056a48148e3598fef5e7bb6ba7"
+checksum = "33dfc05e7cdf90988a197803bf24f5788f94f7c94a69efa95683e8ffe76cfdfb"
 dependencies = [
  "enumflags2",
  "serde",
  "static_assertions",
- "zbus 4.4.0",
+ "zbus",
  "zbus-lockstep",
  "zbus-lockstep-macros",
- "zbus_names 3.0.0",
- "zvariant 4.2.0",
+ "zbus_names",
+ "zvariant",
 ]
 
 [[package]]
 name = "atspi-connection"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "430c5960624a4baaa511c9c0fcc2218e3b58f5dbcc47e6190cafee344b873333"
+checksum = "4193d51303d8332304056ae0004714256b46b6635a5c556109b319c0d3784938"
 dependencies = [
  "atspi-common",
  "atspi-proxies",
  "futures-lite",
- "zbus 4.4.0",
+ "zbus",
 ]
 
 [[package]]
 name = "atspi-proxies"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e6c5de3e524cf967569722446bcd458d5032348554d9a17d7d72b041ab7496"
+checksum = "d2eebcb9e7e76f26d0bcfd6f0295e1cd1e6f33bedbc5698a971db8dc43d7751c"
 dependencies = [
  "atspi-common",
  "serde",
- "zbus 4.4.0",
- "zvariant 4.2.0",
+ "zbus",
 ]
 
 [[package]]
@@ -519,9 +552,9 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "backtrace"
-version = "0.3.74"
+version = "0.3.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
 dependencies = [
  "addr2line",
  "cfg-if",
@@ -529,15 +562,9 @@ dependencies = [
  "miniz_oxide",
  "object",
  "rustc-demangle",
- "windows-targets 0.52.6",
+ "windows-link 0.2.1",
 ]
 
-[[package]]
-name = "base64"
-version = "0.21.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
-
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -553,30 +580,15 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "bit-set"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
-dependencies = [
- "bit-vec 0.6.3",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
- "bit-vec 0.8.0",
+ "bit-vec",
 ]
 
-[[package]]
-name = "bit-vec"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
-
 [[package]]
 name = "bit-vec"
 version = "0.8.0"
@@ -591,9 +603,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.8.0"
+version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
+checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
 dependencies = [
  "serde",
 ]
@@ -604,22 +616,22 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
 
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "block2"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f"
 dependencies = [
- "objc2",
+ "objc2 0.5.2",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2 0.6.3",
 ]
 
 [[package]]
@@ -635,6 +647,17 @@ dependencies = [
  "piper",
 ]
 
+[[package]]
+name = "bstr"
+version = "1.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.16.0"
@@ -643,18 +666,18 @@ checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "bytemuck"
-version = "1.21.0"
+version = "1.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
+checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
 dependencies = [
  "bytemuck_derive",
 ]
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.8.0"
+version = "1.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcfcc3cd946cb52f0bbfdbbcfa2f4e24f75ebb6c0e1002f7c25904fada18b9ec"
+checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -685,10 +708,10 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "log",
  "polling",
- "rustix",
+ "rustix 0.38.38",
  "slab",
  "thiserror 1.0.66",
 ]
@@ -700,7 +723,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20"
 dependencies = [
  "calloop",
- "rustix",
+ "rustix 0.38.38",
  "wayland-backend",
  "wayland-client",
 ]
@@ -713,9 +736,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.1.31"
+version = "1.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2e7962b54006dcfcc61cb72735f4d89bb97061dd6a7ed882ec6b8ee53714c6f"
+checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
 dependencies = [
  "jobserver",
  "libc",
@@ -751,16 +774,15 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
- "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets 0.52.6",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -832,10 +854,11 @@ dependencies = [
 
 [[package]]
 name = "codespan-reporting"
-version = "0.11.1"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81"
 dependencies = [
+ "serde",
  "termcolor",
  "unicode-width",
 ]
@@ -853,13 +876,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
-name = "colored"
-version = "2.1.0"
+name = "colorchoice"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "colored"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -889,6 +918,18 @@ dependencies = [
  "env_logger",
 ]
 
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -899,6 +940,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -912,8 +963,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
- "core-graphics-types",
+ "core-foundation 0.9.4",
+ "core-graphics-types 0.1.3",
  "foreign-types",
  "libc",
 ]
@@ -925,19 +976,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
  "libc",
 ]
 
 [[package]]
-name = "cpufeatures"
-version = "0.2.14"
+name = "core-graphics-types"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
 dependencies = [
+ "bitflags 2.9.4",
+ "core-foundation 0.10.1",
  "libc",
 ]
 
+[[package]]
+name = "core_maths"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
+dependencies = [
+ "libm",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.4.2"
@@ -949,23 +1011,20 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "e1c047a62b0cc3e145fa84415a3191f628e980b194c2755aa12300a4e6cbd928"
 dependencies = [
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "is-terminal",
- "itertools",
+ "itertools 0.13.0",
  "num-traits",
- "once_cell",
  "oorandom",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -973,19 +1032,19 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "9b1bcc0dc7dfae599d84ad0b1a55f80cde8af3725da8313b528da95ef783e338"
 dependencies = [
  "cast",
- "itertools",
+ "itertools 0.13.0",
 ]
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.13"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -1021,16 +1080,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
-[[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 = "cursor-icon"
 version = "1.1.0"
@@ -1117,35 +1166,25 @@ dependencies = [
  "rayon",
 ]
 
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "crypto-common",
-]
-
 [[package]]
 name = "directories"
-version = "5.0.1"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a49173b84e034382284f27f1af4dcbbd231ffa358c0fe316541a7337f376a35"
+checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
 dependencies = [
  "dirs-sys",
 ]
 
 [[package]]
 name = "dirs-sys"
-version = "0.4.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
 dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1154,6 +1193,18 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
 
+[[package]]
+name = "dispatch2"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
+dependencies = [
+ "bitflags 2.9.4",
+ "block2 0.6.2",
+ "libc",
+ "objc2 0.6.3",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.5"
@@ -1176,9 +1227,9 @@ dependencies = [
 
 [[package]]
 name = "document-features"
-version = "0.2.10"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb6969eaabd2421f8a2775cfd2471a2b634372b4a25d41e3bd647b79912850a0"
+checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
 dependencies = [
  "litrs",
 ]
@@ -1197,7 +1248,7 @@ checksum = "f25c0e292a7ca6d6498557ff1df68f32c99850012b6ea401cf8daf771f22ff53"
 
 [[package]]
 name = "ecolor"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "bytemuck",
  "cint",
@@ -1209,7 +1260,7 @@ dependencies = [
 
 [[package]]
 name = "eframe"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "ahash",
  "bytemuck",
@@ -1226,14 +1277,14 @@ dependencies = [
  "image",
  "js-sys",
  "log",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
+ "objc2 0.5.2",
+ "objc2-app-kit 0.2.2",
+ "objc2-foundation 0.2.2",
  "parking_lot",
  "percent-encoding",
- "pollster 0.4.0",
+ "pollster",
  "profiling",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "ron",
  "serde",
  "static_assertions",
@@ -1242,19 +1293,18 @@ dependencies = [
  "web-sys",
  "web-time",
  "wgpu",
- "winapi",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
  "winit",
 ]
 
 [[package]]
 name = "egui"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "accesskit",
  "ahash",
  "backtrace",
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "document-features",
  "emath",
  "epaint",
@@ -1263,11 +1313,13 @@ dependencies = [
  "profiling",
  "ron",
  "serde",
+ "smallvec",
+ "unicode-segmentation",
 ]
 
 [[package]]
 name = "egui-wgpu"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "ahash",
  "bytemuck",
@@ -1276,7 +1328,7 @@ dependencies = [
  "epaint",
  "log",
  "profiling",
- "thiserror 1.0.66",
+ "thiserror 2.0.17",
  "type-map",
  "web-time",
  "wgpu",
@@ -1285,17 +1337,19 @@ dependencies = [
 
 [[package]]
 name = "egui-winit"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "accesskit_winit",
- "ahash",
  "arboard",
  "bytemuck",
  "document-features",
  "egui",
  "log",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
+ "objc2-ui-kit",
  "profiling",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "serde",
  "smithay-clipboard",
  "wayland-cursor",
@@ -1306,8 +1360,10 @@ dependencies = [
 
 [[package]]
 name = "egui_demo_app"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
+ "accesskit",
+ "accesskit_consumer",
  "bytemuck",
  "chrono",
  "eframe",
@@ -1319,6 +1375,7 @@ dependencies = [
  "env_logger",
  "image",
  "log",
+ "mimalloc",
  "poll-promise",
  "profiling",
  "puffin",
@@ -1333,7 +1390,7 @@ dependencies = [
 
 [[package]]
 name = "egui_demo_lib"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "chrono",
  "criterion",
@@ -1341,13 +1398,16 @@ dependencies = [
  "egui",
  "egui_extras",
  "egui_kittest",
+ "image",
+ "mimalloc",
+ "rand 0.9.2",
  "serde",
  "unicode_names2",
 ]
 
 [[package]]
 name = "egui_extras"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "ahash",
  "chrono",
@@ -1366,9 +1426,8 @@ dependencies = [
 
 [[package]]
 name = "egui_glow"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
- "ahash",
  "bytemuck",
  "document-features",
  "egui",
@@ -1386,19 +1445,32 @@ dependencies = [
 
 [[package]]
 name = "egui_kittest"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "dify",
  "document-features",
  "eframe",
  "egui",
  "egui-wgpu",
+ "egui_extras",
  "image",
  "kittest",
- "pollster 0.4.0",
+ "open",
+ "pollster",
+ "tempfile",
  "wgpu",
 ]
 
+[[package]]
+name = "egui_tests"
+version = "0.33.2"
+dependencies = [
+ "egui",
+ "egui_extras",
+ "egui_kittest",
+ "image",
+]
+
 [[package]]
 name = "ehttp"
 version = "0.5.0"
@@ -1421,7 +1493,7 @@ checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "emath"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "bytemuck",
  "document-features",
@@ -1429,6 +1501,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
 [[package]]
 name = "endi"
 version = "1.1.0"
@@ -1500,23 +1578,23 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.10.2"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
 dependencies = [
- "humantime",
- "is-terminal",
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
  "log",
- "termcolor",
 ]
 
 [[package]]
 name = "epaint"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "ab_glyph",
  "ahash",
- "backtrace",
  "bytemuck",
  "criterion",
  "document-features",
@@ -1524,16 +1602,18 @@ dependencies = [
  "emath",
  "epaint_default_fonts",
  "log",
+ "mimalloc",
  "nohash-hasher",
  "parking_lot",
  "profiling",
  "rayon",
  "serde",
+ "similar-asserts",
 ]
 
 [[package]]
 name = "epaint_default_fonts"
-version = "0.31.0"
+version = "0.33.2"
 
 [[package]]
 name = "equivalent"
@@ -1543,12 +1623,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.9"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1579,13 +1659,34 @@ dependencies = [
 ]
 
 [[package]]
-name = "fancy-regex"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2"
+name = "external_eventloop"
+version = "0.1.0"
 dependencies = [
- "bit-set 0.5.3",
- "regex",
+ "eframe",
+ "env_logger",
+ "winit",
+]
+
+[[package]]
+name = "external_eventloop_async"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "env_logger",
+ "log",
+ "tokio",
+ "winit",
+]
+
+[[package]]
+name = "fancy-regex"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "998b056554fbe42e03ae0e152895cd1a7e1002aec800fdc6635d20270260c46f"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
@@ -1614,9 +1715,9 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.0.34"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0"
+checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -1634,6 +1735,40 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "fontconfig-parser"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1fcfcd44ca6e90c921fee9fa665d530b21ef1327a4c1a6c5250ea44b776ada7"
+dependencies = [
+ "roxmltree",
+]
+
+[[package]]
+name = "fontdb"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "457e789b3d1202543297a350643cf459f836cade38934e7a4cf6a39e7cde2905"
+dependencies = [
+ "fontconfig-parser",
+ "log",
+ "slotmap",
+ "tinyvec",
+ "ttf-parser",
+]
+
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -1693,9 +1828,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-lite"
-version = "2.4.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f1fa2f9765705486b33fd2acf1577f8ec449c2ba1f318ae5447697b7c08d210"
+checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
 dependencies = [
  "fastrand",
  "futures-core",
@@ -1715,12 +1850,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "futures-sink"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
-
 [[package]]
 name = "futures-task"
 version = "0.3.31"
@@ -1736,7 +1865,6 @@ dependencies = [
  "futures-core",
  "futures-io",
  "futures-macro",
- "futures-sink",
  "futures-task",
  "memchr",
  "pin-project-lite",
@@ -1744,24 +1872,14 @@ dependencies = [
  "slab",
 ]
 
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
 [[package]]
 name = "gethostname"
-version = "0.4.3"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
+checksum = "fc257fdb4038301ce4b9cd1b3b51704509692bb3ff716a410cbd07925d9dae55"
 dependencies = [
- "libc",
- "windows-targets 0.48.5",
+ "rustix 1.0.8",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1775,13 +1893,25 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.13.3+wasi-0.2.2",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1796,9 +1926,9 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.31.1"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
 [[package]]
 name = "gl_generator"
@@ -1825,24 +1955,24 @@ dependencies = [
 
 [[package]]
 name = "glutin"
-version = "0.32.1"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec69412a0bf07ea7607e638b415447857a808846c2b685a43c8aa18bc6d5e499"
+checksum = "12124de845cacfebedff80e877bb37b5b75c34c5a4c89e47e1cdd67fb6041325"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "cfg_aliases",
  "cgl",
- "core-foundation",
- "dispatch",
+ "dispatch2",
  "glutin_egl_sys",
  "glutin_glx_sys",
  "glutin_wgl_sys",
  "libloading",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
+ "objc2 0.6.3",
+ "objc2-app-kit 0.3.2",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
  "once_cell",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "wayland-sys",
  "windows-sys 0.52.0",
  "x11-dl",
@@ -1856,15 +1986,15 @@ checksum = "85edca7075f8fc728f28cb8fbb111a96c3b89e930574369e3e9c27eb75d3788f"
 dependencies = [
  "cfg_aliases",
  "glutin",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "winit",
 ]
 
 [[package]]
 name = "glutin_egl_sys"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cae99fff4d2850dbe6fb8c1fa8e4fead5525bab715beaacfccf3fb994e01c827"
+checksum = "4c4680ba6195f424febdc3ba46e7a42a0e58743f2edb115297b86d7f8ecc02d2"
 dependencies = [
  "gl_generator",
  "windows-sys 0.52.0",
@@ -1872,9 +2002,9 @@ dependencies = [
 
 [[package]]
 name = "glutin_glx_sys"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c2b2d3918e76e18e08796b55eb64e8fe6ec67d5a6b2e2a7e2edce224ad24c63"
+checksum = "8a7bb2938045a88b612499fbcba375a77198e01306f52272e692f8c1f3751185"
 dependencies = [
  "gl_generator",
  "x11-dl",
@@ -1882,9 +2012,9 @@ dependencies = [
 
 [[package]]
 name = "glutin_wgl_sys"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a4e1951bbd9434a81aa496fe59ccc2235af3820d27b85f9314e279609211e2c"
+checksum = "2c4ee00b289aba7a9e5306d57c2d05499b2e5dc427f84ac708bd2c090212cf3e"
 dependencies = [
  "gl_generator",
 ]
@@ -1895,7 +2025,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "gpu-alloc-types",
 ]
 
@@ -1905,7 +2035,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
 ]
 
 [[package]]
@@ -1917,18 +2047,18 @@ dependencies = [
  "log",
  "presser",
  "thiserror 1.0.66",
- "windows",
+ "windows 0.58.0",
 ]
 
 [[package]]
 name = "gpu-descriptor"
-version = "0.3.0"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c08c1f623a8d0b722b8b99f821eb0ba672a1618f0d3b16ddbee1cedd2dd8557"
+checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "gpu-descriptor-types",
- "hashbrown",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
@@ -1937,34 +2067,37 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
 ]
 
 [[package]]
 name = "half"
-version = "2.4.1"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "num-traits",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.14.5"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 dependencies = [
- "ahash",
- "allocator-api2",
+ "foldhash 0.1.4",
 ]
 
 [[package]]
-name = "heck"
-version = "0.5.0"
+name = "hashbrown"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+dependencies = [
+ "foldhash 0.2.0",
+]
 
 [[package]]
 name = "hello_android"
@@ -1972,6 +2105,7 @@ version = "0.1.0"
 dependencies = [
  "android_logger",
  "eframe",
+ "egui_demo_lib",
  "egui_extras",
  "log",
  "winit",
@@ -2030,24 +2164,19 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
 [[package]]
 name = "iana-time-zone"
-version = "0.1.61"
+version = "0.1.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
- "windows-core 0.52.0",
+ "windows-core 0.61.0",
 ]
 
 [[package]]
@@ -2061,21 +2190,22 @@ dependencies = [
 
 [[package]]
 name = "icu_collections"
-version = "1.5.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
 dependencies = [
  "displaydoc",
+ "potential_utf",
  "yoke",
  "zerofrom",
  "zerovec",
 ]
 
 [[package]]
-name = "icu_locid"
-version = "1.5.0"
+name = "icu_locale_core"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -2084,31 +2214,11 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "icu_locid_transform"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
-dependencies = [
- "displaydoc",
- "icu_locid",
- "icu_locid_transform_data",
- "icu_provider",
- "tinystr",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locid_transform_data"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
-
 [[package]]
 name = "icu_normalizer"
-version = "1.5.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
 dependencies = [
  "displaydoc",
  "icu_collections",
@@ -2116,67 +2226,54 @@ dependencies = [
  "icu_properties",
  "icu_provider",
  "smallvec",
- "utf16_iter",
- "utf8_iter",
- "write16",
  "zerovec",
 ]
 
 [[package]]
 name = "icu_normalizer_data"
-version = "1.5.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
 
 [[package]]
 name = "icu_properties"
-version = "1.5.1"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
 dependencies = [
  "displaydoc",
  "icu_collections",
- "icu_locid_transform",
+ "icu_locale_core",
  "icu_properties_data",
  "icu_provider",
- "tinystr",
+ "potential_utf",
+ "zerotrie",
  "zerovec",
 ]
 
 [[package]]
 name = "icu_properties_data"
-version = "1.5.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
 
 [[package]]
 name = "icu_provider"
-version = "1.5.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
 dependencies = [
  "displaydoc",
- "icu_locid",
- "icu_provider_macros",
+ "icu_locale_core",
  "stable_deref_trait",
  "tinystr",
  "writeable",
  "yoke",
  "zerofrom",
+ "zerotrie",
  "zerovec",
 ]
 
-[[package]]
-name = "icu_provider_macros"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "idna"
 version = "1.0.3"
@@ -2190,9 +2287,9 @@ dependencies = [
 
 [[package]]
 name = "idna_adapter"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
 dependencies = [
  "icu_normalizer",
  "icu_properties",
@@ -2200,9 +2297,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.25.4"
+version = "0.25.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc144d44a31d753b02ce64093d532f55ff8dc4ebf2ffb8a63c0dda691385acae"
+checksum = "db35664ce6b9810857a38a906215e75a9c879f0696556a39f59c62829710251a"
 dependencies = [
  "bytemuck",
  "byteorder-lite",
@@ -2238,40 +2335,56 @@ dependencies = [
 
 [[package]]
 name = "imagesize"
-version = "0.12.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "029d73f573d8e8d63e6d5020011d3255b28c3ba85d6cf870a07184ed23de9284"
-
-[[package]]
-name = "immutable-chunkmap"
-version = "2.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f97096f508d54f8f8ab8957862eee2ccd628847b6217af1a335e1c44dee578"
-dependencies = [
- "arrayvec",
-]
+checksum = "edcd27d72f2f071c64249075f42e205ff93c9a4c5f6c6da53e79ed9f9832c285"
 
 [[package]]
 name = "indexmap"
-version = "2.5.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
+checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
-name = "is-terminal"
-version = "0.4.13"
+name = "io-uring"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
+checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b"
 dependencies = [
- "hermit-abi",
+ "bitflags 2.9.4",
+ "cfg-if",
  "libc",
- "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
 [[package]]
 name = "itertools"
 version = "0.10.5"
@@ -2281,12 +2394,45 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "jiff"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -2320,15 +2466,15 @@ dependencies = [
 
 [[package]]
 name = "jpeg-decoder"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"
 
 [[package]]
 name = "js-sys"
-version = "0.3.74"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a865e038f7f6ed956f788f0d7d60c541fff74c7bd74272c5d4cf15c63743e705"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -2361,9 +2507,9 @@ checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
 [[package]]
 name = "kittest"
-version = "0.1.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f659954571a3c132356bd15c25f0dcf14d270a28ec5c58797adc2f432831bed5"
+checksum = "01fd6dd2cce251a360101038acb9334e3a50cd38cd02fefddbf28aa975f043c8"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
@@ -2372,11 +2518,12 @@ dependencies = [
 
 [[package]]
 name = "kurbo"
-version = "0.9.5"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd85a5776cd9500c2e2059c8c76c3b01528566b7fcbaf8098b55a33fc298849b"
+checksum = "89234b2cc610a7dd927ebde6b41dd1a5d4214cffaef4cf1fb2195d592f92518f"
 dependencies = [
  "arrayvec",
+ "smallvec",
 ]
 
 [[package]]
@@ -2387,9 +2534,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.161"
+version = "0.2.176"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
+checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
 
 [[package]]
 name = "libloading"
@@ -2401,13 +2548,29 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "libm"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
+
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "667f4fec20f29dfc6bc7357c582d91796c169ad7e2fce709468aefeb2c099870"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "libc",
  "redox_syscall 0.5.7",
 ]
@@ -2425,10 +2588,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
 [[package]]
-name = "litemap"
-version = "0.7.4"
+name = "linux-raw-sys"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+
+[[package]]
+name = "litemap"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
 
 [[package]]
 name = "litrs"
@@ -2438,19 +2607,18 @@ checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "lz4_flex"
@@ -2493,19 +2661,28 @@ dependencies = [
 
 [[package]]
 name = "metal"
-version = "0.31.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f569fb946490b5743ad69813cb19629130ce9374034abe31614a36402d18f99e"
+checksum = "00c15a6f673ff72ddcc22394663290f870fb224c1bfce55734a75c414150e605"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "block",
- "core-graphics-types",
+ "core-graphics-types 0.2.0",
  "foreign-types",
  "log",
  "objc",
  "paste",
 ]
 
+[[package]]
+name = "mimalloc"
+version = "0.1.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1ee66a4b64c74f4ef288bcbb9192ad9c3feaad75193129ac8509af543894fd8"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -2514,19 +2691,21 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "mime_guess2"
-version = "2.0.5"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25a3333bb1609500601edc766a39b4c1772874a4ce26022f4d866854dc020c41"
+checksum = "1706dc14a2e140dec0a7a07109d9a3d5890b81e85bd6c60b906b249a77adf0ca"
 dependencies = [
  "mime",
+ "phf",
+ "phf_shared",
  "unicase",
 ]
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.0"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
  "adler2",
  "simd-adler32",
@@ -2538,6 +2717,17 @@ version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
 
+[[package]]
+name = "mio"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+dependencies = [
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "multiple_viewports"
 version = "0.1.0"
@@ -2548,24 +2738,28 @@ dependencies = [
 
 [[package]]
 name = "naga"
-version = "24.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e380993072e52eef724eddfcde0ed013b0c023c3f0417336ed041aa9f076994e"
+checksum = "12b2e757b11b47345d44e7760e45458339bc490463d9548cd8651c53ae523153"
 dependencies = [
  "arrayvec",
- "bit-set 0.8.0",
- "bitflags 2.8.0",
+ "bit-set",
+ "bitflags 2.9.4",
+ "cfg-if",
  "cfg_aliases",
  "codespan-reporting",
+ "half",
+ "hashbrown 0.16.0",
  "hexf-parse",
  "indexmap",
+ "libm",
  "log",
- "rustc-hash",
+ "num-traits",
+ "once_cell",
+ "rustc-hash 1.1.0",
  "spirv",
- "strum",
- "termcolor",
- "thiserror 2.0.11",
- "unicode-xid",
+ "thiserror 2.0.17",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -2574,12 +2768,12 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "jni-sys",
  "log",
- "ndk-sys 0.6.0+11769913",
+ "ndk-sys",
  "num_enum",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "thiserror 1.0.66",
 ]
 
@@ -2589,15 +2783,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
 
-[[package]]
-name = "ndk-sys"
-version = "0.5.0+25.2.9519653"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
-dependencies = [
- "jni-sys",
-]
-
 [[package]]
 name = "ndk-sys"
 version = "0.6.0+11769913"
@@ -2613,7 +2798,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2639,6 +2824,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
+ "libm",
 ]
 
 [[package]]
@@ -2687,33 +2873,56 @@ dependencies = [
  "objc2-encode",
 ]
 
+[[package]]
+name = "objc2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c2599ce0ec54857b29ce62166b0ed9b4f6f1a70ccc9a71165b6154caca8c05"
+dependencies = [
+ "objc2-encode",
+]
+
 [[package]]
 name = "objc2-app-kit"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
  "libc",
- "objc2",
+ "objc2 0.5.2",
  "objc2-core-data",
  "objc2-core-image",
- "objc2-foundation",
+ "objc2-foundation 0.2.2",
  "objc2-quartz-core",
 ]
 
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.9.4",
+ "block2 0.6.2",
+ "objc2 0.6.3",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation 0.3.2",
+]
+
 [[package]]
 name = "objc2-cloud-kit"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
- "objc2",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
+ "objc2 0.5.2",
  "objc2-core-location",
- "objc2-foundation",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
@@ -2722,9 +2931,9 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889"
 dependencies = [
- "block2",
- "objc2",
- "objc2-foundation",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
@@ -2733,10 +2942,34 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
- "objc2",
- "objc2-foundation",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.9.4",
+ "dispatch2",
+ "objc2 0.6.3",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.9.4",
+ "dispatch2",
+ "objc2 0.6.3",
+ "objc2-core-foundation",
+ "objc2-io-surface",
 ]
 
 [[package]]
@@ -2745,9 +2978,9 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80"
 dependencies = [
- "block2",
- "objc2",
- "objc2-foundation",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
  "objc2-metal",
 ]
 
@@ -2757,17 +2990,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781"
 dependencies = [
- "block2",
- "objc2",
+ "block2 0.5.1",
+ "objc2 0.5.2",
  "objc2-contacts",
- "objc2-foundation",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
 name = "objc2-encode"
-version = "4.0.3"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7891e71393cd1f227313c9379a26a584ff3d7e6e7159e988851f0934c993f0f8"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
 
 [[package]]
 name = "objc2-foundation"
@@ -2775,11 +3008,33 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
  "dispatch",
  "libc",
- "objc2",
+ "objc2 0.5.2",
+]
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.9.4",
+ "objc2 0.6.3",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.9.4",
+ "objc2 0.6.3",
+ "objc2-core-foundation",
 ]
 
 [[package]]
@@ -2788,10 +3043,10 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398"
 dependencies = [
- "block2",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-app-kit 0.2.2",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
@@ -2800,10 +3055,10 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
- "objc2",
- "objc2-foundation",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
@@ -2812,10 +3067,10 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
- "objc2",
- "objc2-foundation",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
  "objc2-metal",
 ]
 
@@ -2825,8 +3080,8 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc"
 dependencies = [
- "objc2",
- "objc2-foundation",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
@@ -2835,14 +3090,14 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
- "objc2",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
+ "objc2 0.5.2",
  "objc2-cloud-kit",
  "objc2-core-data",
  "objc2-core-image",
  "objc2-core-location",
- "objc2-foundation",
+ "objc2-foundation 0.2.2",
  "objc2-link-presentation",
  "objc2-quartz-core",
  "objc2-symbols",
@@ -2856,9 +3111,9 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe"
 dependencies = [
- "block2",
- "objc2",
- "objc2-foundation",
+ "block2 0.5.1",
+ "objc2 0.5.2",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
@@ -2867,27 +3122,33 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3"
 dependencies = [
- "bitflags 2.8.0",
- "block2",
- "objc2",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
+ "objc2 0.5.2",
  "objc2-core-location",
- "objc2-foundation",
+ "objc2-foundation 0.2.2",
 ]
 
 [[package]]
 name = "object"
-version = "0.36.5"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aedf0a2d09c573ed1d8d85b30c119153926a2b36dce0ab28322c09a117a4683e"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.20.2"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
 
 [[package]]
 name = "oorandom"
@@ -2895,6 +3156,17 @@ version = "11.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"
 
+[[package]]
+name = "open"
+version = "5.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2483562e62ea94312f3576a7aca397306df7990b8d89033e18766744377ef95"
+dependencies = [
+ "is-wsl",
+ "libc",
+ "pathdiff",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -2946,9 +3218,9 @@ checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -2956,15 +3228,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.10"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall 0.5.7",
  "smallvec",
- "windows-targets 0.52.6",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -2974,10 +3246,70 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
-name = "percent-encoding"
-version = "2.3.1"
+name = "pathdiff"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "unicase",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+ "unicase",
+]
 
 [[package]]
 name = "pico-args"
@@ -3040,7 +3372,7 @@ version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42cf17e9a1800f5f396bc67d193dc9411b59012a5876445ef450d449881e1016"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "indexmap",
  "quick-xml 0.32.0",
  "serde",
@@ -3080,17 +3412,11 @@ dependencies = [
  "concurrent-queue",
  "hermit-abi",
  "pin-project-lite",
- "rustix",
+ "rustix 0.38.38",
  "tracing",
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "pollster"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22686f4785f02a4fcc856d3b3bb19bf6c8160d103f7a99cc258bddd0251dc7f2"
-
 [[package]]
 name = "pollster"
 version = "0.4.0"
@@ -3099,12 +3425,36 @@ checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3"
 
 [[package]]
 name = "popups"
-version = "0.31.0"
+version = "0.33.2"
 dependencies = [
  "eframe",
  "env_logger",
 ]
 
+[[package]]
+name = "portable-atomic"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+dependencies = [
+ "zerovec",
+]
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -3117,7 +3467,7 @@ version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
@@ -3137,18 +3487,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.93"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "profiling"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
+checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773"
 dependencies = [
  "profiling-procmacros",
  "puffin",
@@ -3156,9 +3506,9 @@ dependencies = [
 
 [[package]]
 name = "profiling-procmacros"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a65f2e60fbf1063868558d69c6beacf412dc755f9fc020f514b7955fc914fe30"
+checksum = "52717f9a02b6965224f95ca2a81e2e0c5c43baacd28ca057577988930b6c3d5b"
 dependencies = [
  "quote",
  "syn",
@@ -3174,7 +3524,7 @@ dependencies = [
  "bincode",
  "byteorder",
  "cfg-if",
- "itertools",
+ "itertools 0.10.5",
  "lz4_flex",
  "once_cell",
  "parking_lot",
@@ -3212,16 +3562,6 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
-[[package]]
-name = "quick-xml"
-version = "0.30.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eff6510e86862b57b210fd8cbe8ed3f0d7d600b9c2863cd4549a2e033c66e956"
-dependencies = [
- "memchr",
- "serde",
-]
-
 [[package]]
 name = "quick-xml"
 version = "0.32.0"
@@ -3236,15 +3576,25 @@ name = "quick-xml"
 version = "0.36.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7649a7b4df05aed9ea7ec6f628c67c9953a43869b8bc50929569b2999d443fe"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
 dependencies = [
  "proc-macro2",
 ]
@@ -3256,8 +3606,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -3267,7 +3627,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -3276,7 +3646,16 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.1",
 ]
 
 [[package]]
@@ -3285,12 +3664,6 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8a99fddc9f0ba0a85884b8d14e3592853e787d581ca1816c91349b10e4eeab"
 
-[[package]]
-name = "raw-window-handle"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9"
-
 [[package]]
 name = "raw-window-handle"
 version = "0.6.2"
@@ -3299,9 +3672,9 @@ checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
 [[package]]
 name = "rayon"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
  "either",
  "rayon-core",
@@ -3309,20 +3682,14 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
 ]
 
-[[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.4.1"
@@ -3338,18 +3705,18 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.6"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.16",
  "libredox",
- "thiserror 1.0.66",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -3389,9 +3756,9 @@ checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
 
 [[package]]
 name = "resvg"
-version = "0.37.0"
+version = "0.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cadccb3d99a9efb8e5e00c16fbb732cbe400db2ec7fc004697ee7d97d86cf1f4"
+checksum = "a8928798c0a55e03c9ca6c4c6846f76377427d2c1e1f7e6de3c06ae57942df43"
 dependencies = [
  "log",
  "pico-args",
@@ -3403,24 +3770,26 @@ dependencies = [
 
 [[package]]
 name = "rfd"
-version = "0.15.1"
+version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f6f80a9b882647d9014673ca9925d30ffc9750f2eed2b4490e189eaebd01e8"
+checksum = "ef2bee61e6cffa4635c72d7d81a84294e28f0930db0ddcb0f66d10244674ebed"
 dependencies = [
  "ashpd",
- "block2",
+ "block2 0.6.2",
+ "dispatch2",
  "js-sys",
  "log",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
- "pollster 0.3.0",
- "raw-window-handle 0.6.2",
+ "objc2 0.6.3",
+ "objc2-app-kit 0.3.2",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+ "pollster",
+ "raw-window-handle",
  "urlencoding",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3434,36 +3803,36 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.17.8"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
- "getrandom",
+ "getrandom 0.2.16",
  "libc",
- "spin",
  "untrusted",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "ron"
-version = "0.8.1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
+checksum = "db09040cc89e461f1a265139777a2bde7f8d8c67c4936f700c63ce3e2904d468"
 dependencies = [
- "base64 0.21.7",
- "bitflags 2.8.0",
+ "base64",
+ "bitflags 2.9.4",
  "serde",
  "serde_derive",
+ "unicode-ident",
 ]
 
 [[package]]
 name = "roxmltree"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
+checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
 [[package]]
 name = "rustc-demangle"
@@ -3477,19 +3846,38 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "rustix"
 version = "0.38.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa260229e6538e52293eeb577aabd09945a09d6d9cc0fc550ed7529056c2e32a"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "errno",
  "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.4.14",
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rustix"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
+dependencies = [
+ "bitflags 2.9.4",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.9.4",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "rustls"
 version = "0.23.18"
@@ -3528,6 +3916,24 @@ version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
 
+[[package]]
+name = "rustybuzz"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3c7c96f8a08ee34eff8857b11b49b07d71d1c3f4e88f8a88d4c9e9f90b1702"
+dependencies = [
+ "bitflags 2.9.4",
+ "bytemuck",
+ "core_maths",
+ "log",
+ "smallvec",
+ "ttf-parser",
+ "unicode-bidi-mirroring",
+ "unicode-ccc",
+ "unicode-properties",
+ "unicode-script",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.18"
@@ -3579,18 +3985,28 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.214"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.214"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3629,17 +4045,6 @@ dependencies = [
  "log",
 ]
 
-[[package]]
-name = "sha1"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -3661,6 +4066,26 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+dependencies = [
+ "bstr",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "similar-asserts"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b441962c817e33508847a22bd82f03a30cff43642dc2fae8b050566121eb9a"
+dependencies = [
+ "console",
+ "similar",
+]
+
 [[package]]
 name = "simplecss"
 version = "0.2.1"
@@ -3672,9 +4097,9 @@ dependencies = [
 
 [[package]]
 name = "siphasher"
-version = "0.3.11"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "slab"
@@ -3696,9 +4121,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.13.2"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "smithay-client-toolkit"
@@ -3706,14 +4131,14 @@ version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "calloop",
  "calloop-wayland-source",
  "cursor-icon",
  "libc",
  "log",
  "memmap2",
- "rustix",
+ "rustix 0.38.38",
  "thiserror 1.0.66",
  "wayland-backend",
  "wayland-client",
@@ -3746,10 +4171,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "spin"
-version = "0.9.8"
+name = "socket2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
 
 [[package]]
 name = "spirv"
@@ -3757,7 +4186,7 @@ version = "0.3.0+sdk-1.3.268.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
 ]
 
 [[package]]
@@ -3781,28 +4210,6 @@ dependencies = [
  "float-cmp",
 ]
 
-[[package]]
-name = "strum"
-version = "0.26.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
-dependencies = [
- "strum_macros",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.26.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn",
-]
-
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -3811,9 +4218,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "svgtypes"
-version = "0.13.0"
+version = "0.15.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e44e288cd960318917cbd540340968b90becc8bc81f171345d706e7a89d9d70"
+checksum = "68c7541fff44b35860c1a7a47a7cadf3e4a304c457b58f9870d9706ece028afc"
 dependencies = [
  "kurbo",
  "siphasher",
@@ -3821,9 +4228,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.96"
+version = "2.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3843,12 +4250,11 @@ dependencies = [
 
 [[package]]
 name = "syntect"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874dcfa363995604333cf947ae9f751ca3af4522c60886774c4963943b4746b1"
+checksum = "656b45c05d95a5704399aeef6bd0ddec7b2b3531b7c9e900abbf7c4d2190c925"
 dependencies = [
  "bincode",
- "bitflags 1.3.2",
  "fancy-regex",
  "flate2",
  "fnv",
@@ -3858,22 +4264,22 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "thiserror 1.0.66",
+ "thiserror 2.0.17",
  "walkdir",
  "yaml-rust",
 ]
 
 [[package]]
 name = "tempfile"
-version = "3.13.0"
+version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
- "cfg-if",
  "fastrand",
+ "getrandom 0.3.1",
  "once_cell",
- "rustix",
- "windows-sys 0.59.0",
+ "rustix 1.0.8",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3937,11 +4343,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.11"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d452f284b73e6d76dd36758a0c8684b1d5be31f92b89d07fd5822175732206fc"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl 2.0.11",
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
@@ -3957,9 +4363,9 @@ dependencies = [
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.11"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26afc1baea8a989337eeb52b6e72a039780ce45c3edfcc9c5b9d112feeb173c2"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4036,9 +4442,9 @@ dependencies = [
 
 [[package]]
 name = "tinystr"
-version = "0.7.6"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
 dependencies = [
  "displaydoc",
  "zerovec",
@@ -4054,6 +4460,37 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "tinyvec"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
+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 = "tokio"
+version = "1.47.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
+dependencies = [
+ "backtrace",
+ "io-uring",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "slab",
+ "socket2",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.8"
@@ -4062,9 +4499,9 @@ checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
 
 [[package]]
 name = "toml_edit"
-version = "0.22.22"
+version = "0.22.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
+checksum = "17b4795ff5edd201c7cd6dca065ae59972ce77d1b80fa0a84d94950ece7d1474"
 dependencies = [
  "indexmap",
  "toml_datetime",
@@ -4107,21 +4544,18 @@ name = "ttf-parser"
 version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5902c5d130972a0000f60860bfbf46f7ca3db5391eddfedd1b8728bd9dc96c0e"
-
-[[package]]
-name = "type-map"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f"
 dependencies = [
- "rustc-hash",
+ "core_maths",
 ]
 
 [[package]]
-name = "typenum"
-version = "1.17.0"
+name = "type-map"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+checksum = "cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90"
+dependencies = [
+ "rustc-hash 2.1.1",
+]
 
 [[package]]
 name = "uds_windows"
@@ -4136,15 +4570,45 @@ dependencies = [
 
 [[package]]
 name = "unicase"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e51b68083f157f853b6379db119d1c1be0e6e4dec98101079dec41f6f5cf6df"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
+[[package]]
+name = "unicode-bidi-mirroring"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfa6e8c60bb66d49db113e0125ee8711b7647b5579dc7f5f19c42357ed039fe"
+
+[[package]]
+name = "unicode-ccc"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce61d488bcdc9bc8b5d1772c404828b17fc481c0a582b5581e95fb233aef503e"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
+
+[[package]]
+name = "unicode-properties"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0"
+
+[[package]]
+name = "unicode-script"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb421b350c9aff471779e262955939f565ec18b86c15364e6bdf0d662ca7c1f"
 
 [[package]]
 name = "unicode-segmentation"
@@ -4152,6 +4616,12 @@ version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
+[[package]]
+name = "unicode-vo"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1d386ff53b415b7fe27b50bb44679e2cc4660272694b7b6f3326d8480823a94"
+
 [[package]]
 name = "unicode-width"
 version = "0.1.14"
@@ -4159,16 +4629,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.6"
+name = "unicode_names2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+checksum = "d189085656ca1203291e965444e7f6a2723fbdd1dd9f34f8482e79bafd8338a0"
+dependencies = [
+ "phf",
+ "unicode_names2_generator",
+]
 
 [[package]]
-name = "unicode_names2"
-version = "0.6.0"
+name = "unicode_names2_generator"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "446c96c6dd42604779487f0a981060717156648c1706aa1f464677f03c6cc059"
+checksum = "1262662dc96937c71115228ce2e1d30f41db71a7a45d3459e98783ef94052214"
+dependencies = [
+ "phf_codegen",
+ "rand 0.8.5",
+]
 
 [[package]]
 name = "untrusted"
@@ -4182,7 +4660,7 @@ version = "2.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b74fc6b57825be3373f7054754755f03ac3a8f5d70015ccad699ba2029956f4a"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "flate2",
  "log",
  "once_cell",
@@ -4220,60 +4698,43 @@ dependencies = [
 
 [[package]]
 name = "usvg"
-version = "0.37.0"
+version = "0.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b0a51b72ab80ca511d126b77feeeb4fb1e972764653e61feac30adc161a756"
-dependencies = [
- "base64 0.21.7",
- "log",
- "pico-args",
- "usvg-parser",
- "usvg-tree",
- "xmlwriter",
-]
-
-[[package]]
-name = "usvg-parser"
-version = "0.37.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bd4e3c291f45d152929a31f0f6c819245e2921bfd01e7bd91201a9af39a2bdc"
+checksum = "80be9b06fbae3b8b303400ab20778c80bbaf338f563afe567cf3c9eea17b47ef"
 dependencies = [
+ "base64",
  "data-url",
  "flate2",
+ "fontdb",
  "imagesize",
  "kurbo",
  "log",
+ "pico-args",
  "roxmltree",
+ "rustybuzz",
  "simplecss",
  "siphasher",
- "svgtypes",
- "usvg-tree",
-]
-
-[[package]]
-name = "usvg-tree"
-version = "0.37.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee3d202ebdb97a6215604b8f5b4d6ef9024efd623cf2e373a6416ba976ec7d3"
-dependencies = [
- "rctree",
  "strict-num",
  "svgtypes",
  "tiny-skia-path",
+ "unicode-bidi",
+ "unicode-script",
+ "unicode-vo",
+ "xmlwriter",
 ]
 
-[[package]]
-name = "utf16_iter"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
-
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -4297,25 +4758,34 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.97"
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d15e63b4482863c109d70a7b8706c1e364eb6ea449b201a76c5b89cedcec2d5c"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
  "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.97"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d36ef12e3aaca16ddd3f67922bc63e48e953f126de60bd33ccc0101ef9998cd"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -4324,21 +4794,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.45"
+version = "0.4.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc7ec4f8827a71586374db3e87abdb5a2bb3a15afed140221307c3ec06b1f63b"
+checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
 dependencies = [
  "cfg-if",
  "js-sys",
+ "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.97"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "705440e08b42d3e4b36de7d66c944be628d579796b8090bfa3471478a2260051"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4346,9 +4817,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.97"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98c9ae5a76e46f4deecd0f0255cc223cfa18dc9b261213b8aa0c7b36f61b3f1d"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4359,19 +4830,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.97"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ee99da9c5ba11bd675621338ef6fa52296b76b83305e9b6e5c77d4c286d6d49"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wayland-backend"
-version = "0.3.7"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "056535ced7a150d45159d3a8dc30f91a2e2d588ca0b23f70e56033622b8016f6"
+checksum = "673a33c33048a5ade91a6b139580fa174e19fb0d23f396dca9fa15f2e1e49b35"
 dependencies = [
  "cc",
  "downcast-rs",
- "rustix",
+ "rustix 1.0.8",
  "scoped-tls",
  "smallvec",
  "wayland-sys",
@@ -4379,12 +4853,12 @@ dependencies = [
 
 [[package]]
 name = "wayland-client"
-version = "0.31.7"
+version = "0.31.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66249d3fc69f76fd74c82cc319300faa554e9d865dab1f7cd66cc20db10b280"
+checksum = "c66a47e840dc20793f2264eb4b3e4ecb4b75d91c0dd4af04b456128e0bdd449d"
 dependencies = [
- "bitflags 2.8.0",
- "rustix",
+ "bitflags 2.9.4",
+ "rustix 1.0.8",
  "wayland-backend",
  "wayland-scanner",
 ]
@@ -4395,29 +4869,29 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "cursor-icon",
  "wayland-backend",
 ]
 
 [[package]]
 name = "wayland-cursor"
-version = "0.31.7"
+version = "0.31.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b08bc3aafdb0035e7fe0fdf17ba0c09c268732707dca4ae098f60cb28c9e4c"
+checksum = "447ccc440a881271b19e9989f75726d60faa09b95b0200a9b7eb5cc47c3eeb29"
 dependencies = [
- "rustix",
+ "rustix 1.0.8",
  "wayland-client",
  "xcursor",
 ]
 
 [[package]]
 name = "wayland-protocols"
-version = "0.32.5"
+version = "0.32.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd0ade57c4e6e9a8952741325c30bf82f4246885dca8bf561898b86d0c1f58e"
+checksum = "efa790ed75fbfd71283bd2521a1cfdc022aabcc28bdcff00851f9e4ae88d9901"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "wayland-backend",
  "wayland-client",
  "wayland-scanner",
@@ -4425,11 +4899,11 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols-plasma"
-version = "0.3.5"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b31cab548ee68c7eb155517f2212049dc151f7cd7910c2b66abfd31c3ee12bd"
+checksum = "a07a14257c077ab3279987c4f8bb987851bf57081b93710381daea94f2c2c032"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "wayland-backend",
  "wayland-client",
  "wayland-protocols",
@@ -4442,7 +4916,7 @@ version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "782e12f6cd923c3c316130d56205ebab53f55d6666b7faddfad36cecaeeb4022"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "wayland-backend",
  "wayland-client",
  "wayland-protocols",
@@ -4451,20 +4925,20 @@ dependencies = [
 
 [[package]]
 name = "wayland-scanner"
-version = "0.31.5"
+version = "0.31.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597f2001b2e5fc1121e3d5b9791d3e78f05ba6bfa4641053846248e3a13661c3"
+checksum = "54cb1e9dc49da91950bdfd8b848c49330536d9d1fb03d4bfec8cae50caa50ae3"
 dependencies = [
  "proc-macro2",
- "quick-xml 0.36.2",
+ "quick-xml 0.37.5",
  "quote",
 ]
 
 [[package]]
 name = "wayland-sys"
-version = "0.31.5"
+version = "0.31.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efa8ac0d8e8ed3e3b5c9fc92c7881406a268e11555abe36493efabe649a29e09"
+checksum = "34949b42822155826b41db8e5d0c1be3a2bd296c747577a43a3e6daefc296142"
 dependencies = [
  "dlib",
  "log",
@@ -4474,9 +4948,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.74"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a98bc3c33f0fe7e59ad7cd041b89034fa82a7c2d4365ca538dda6cdaf513863c"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4494,17 +4968,16 @@ dependencies = [
 
 [[package]]
 name = "webbrowser"
-version = "1.0.0"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b6f804e41d0852e16d2eaee61c7e4f7d3e8ffdb7b8ed85886aeb0791fe9fcd"
+checksum = "aaf4f3c0ba838e82b4e5ccc4157003fb8c324ee24c058470ffb82820becbde98"
 dependencies = [
- "core-foundation",
- "home",
+ "core-foundation 0.10.1",
  "jni",
  "log",
  "ndk-context",
- "objc",
- "raw-window-handle 0.5.2",
+ "objc2 0.6.3",
+ "objc2-foundation 0.3.2",
  "url",
  "web-sys",
 ]
@@ -4520,26 +4993,29 @@ dependencies = [
 
 [[package]]
 name = "weezl"
-version = "0.1.8"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+checksum = "a751b3277700db47d3e574514de2eced5e54dc8a5436a3bf7a0b248b2cee16f3"
 
 [[package]]
 name = "wgpu"
-version = "24.0.0"
+version = "27.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e41253fc7b660735e2a2d9a58c563f2a047d3cc3445293d8f4095538c9e8afbe"
+checksum = "bfe68bac7cde125de7a731c3400723cadaaf1703795ad3f4805f187459cd7a77"
 dependencies = [
  "arrayvec",
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
+ "cfg-if",
  "cfg_aliases",
  "document-features",
+ "hashbrown 0.16.0",
  "js-sys",
  "log",
  "naga",
  "parking_lot",
+ "portable-atomic",
  "profiling",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "smallvec",
  "static_assertions",
  "wasm-bindgen",
@@ -4552,49 +5028,95 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core"
-version = "24.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82a39b8842dc9ffcbe34346e3ab6d496b32a47f6497e119d762c97fcaae3cb37"
+checksum = "893764e276cdafec946c7f394f044e283bc8f1e445ab3fea8ad3b6dbc10c0322"
 dependencies = [
  "arrayvec",
- "bit-vec 0.8.0",
- "bitflags 2.8.0",
+ "bit-set",
+ "bit-vec",
+ "bitflags 2.9.4",
+ "bytemuck",
  "cfg_aliases",
  "document-features",
+ "hashbrown 0.16.0",
  "indexmap",
  "log",
  "naga",
  "once_cell",
  "parking_lot",
+ "portable-atomic",
  "profiling",
- "raw-window-handle 0.6.2",
- "rustc-hash",
+ "raw-window-handle",
+ "rustc-hash 1.1.0",
  "smallvec",
- "thiserror 2.0.11",
+ "thiserror 2.0.17",
+ "wgpu-core-deps-apple",
+ "wgpu-core-deps-emscripten",
+ "wgpu-core-deps-wasm",
+ "wgpu-core-deps-windows-linux-android",
  "wgpu-hal",
  "wgpu-types",
 ]
 
 [[package]]
-name = "wgpu-hal"
-version = "24.0.0"
+name = "wgpu-core-deps-apple"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a782e5056b060b0b4010881d1decddd059e44f2ecd01e2db2971b48ad3627e5"
+checksum = "0772ae958e9be0c729561d5e3fd9a19679bcdfb945b8b1a1969d9bfe8056d233"
+dependencies = [
+ "wgpu-hal",
+]
+
+[[package]]
+name = "wgpu-core-deps-emscripten"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b06ac3444a95b0813ecfd81ddb2774b66220b264b3e2031152a4a29fda4da6b5"
+dependencies = [
+ "wgpu-hal",
+]
+
+[[package]]
+name = "wgpu-core-deps-wasm"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b1027dcf3b027a877e44819df7ceb0e2e98578830f8cd34cd6c3c7c2a7a50b7"
+dependencies = [
+ "wgpu-hal",
+]
+
+[[package]]
+name = "wgpu-core-deps-windows-linux-android"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71197027d61a71748e4120f05a9242b2ad142e3c01f8c1b47707945a879a03c3"
+dependencies = [
+ "wgpu-hal",
+]
+
+[[package]]
+name = "wgpu-hal"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a753c3dc95e69be3aacfe9c871c5fa2cfa9e35748cdc87de7ba5fc1735b61604"
 dependencies = [
  "android_system_properties",
  "arrayvec",
  "ash",
- "bit-set 0.8.0",
- "bitflags 2.8.0",
+ "bit-set",
+ "bitflags 2.9.4",
  "block",
  "bytemuck",
+ "cfg-if",
  "cfg_aliases",
- "core-graphics-types",
+ "core-graphics-types 0.2.0",
  "glow",
  "glutin_wgl_sys",
  "gpu-alloc",
  "gpu-allocator",
  "gpu-descriptor",
+ "hashbrown 0.16.0",
  "js-sys",
  "khronos-egl",
  "libc",
@@ -4602,34 +5124,37 @@ dependencies = [
  "log",
  "metal",
  "naga",
- "ndk-sys 0.5.0+25.2.9519653",
+ "ndk-sys",
  "objc",
  "once_cell",
  "ordered-float",
  "parking_lot",
+ "portable-atomic",
+ "portable-atomic-util",
  "profiling",
  "range-alloc",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "renderdoc-sys",
- "rustc-hash",
  "smallvec",
- "thiserror 2.0.11",
+ "thiserror 2.0.17",
  "wasm-bindgen",
  "web-sys",
  "wgpu-types",
- "windows",
+ "windows 0.58.0",
  "windows-core 0.58.0",
 ]
 
 [[package]]
 name = "wgpu-types"
-version = "24.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50ac044c0e76c03a0378e7786ac505d010a873665e2d51383dcff8dd227dc69c"
+checksum = "d67453b02f7adc33c452d17da1c2cad813448221df1547bce9dd4b02d3558538"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
+ "bytemuck",
  "js-sys",
  "log",
+ "thiserror 2.0.17",
  "web-sys",
 ]
 
@@ -4675,12 +5200,25 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-core"
-version = "0.52.0"
+name = "windows"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-collections",
+ "windows-core 0.61.0",
+ "windows-future",
+ "windows-link 0.1.3",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.0",
 ]
 
 [[package]]
@@ -4689,13 +5227,36 @@ version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
 dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-result",
- "windows-strings",
+ "windows-implement 0.58.0",
+ "windows-interface 0.58.0",
+ "windows-result 0.2.0",
+ "windows-strings 0.1.0",
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.61.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
+dependencies = [
+ "windows-implement 0.60.0",
+ "windows-interface 0.59.1",
+ "windows-link 0.1.3",
+ "windows-result 0.3.2",
+ "windows-strings 0.4.0",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a1d6bbefcb7b60acd19828e1bc965da6fcf18a7e39490c5f8be71e54a19ba32"
+dependencies = [
+ "windows-core 0.61.0",
+ "windows-link 0.1.3",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.58.0"
@@ -4707,6 +5268,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-interface"
 version = "0.58.0"
@@ -4718,6 +5290,39 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.0",
+ "windows-link 0.1.3",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.2.0"
@@ -4727,16 +5332,34 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-result"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
 [[package]]
 name = "windows-strings"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
 dependencies = [
- "windows-result",
+ "windows-result 0.2.0",
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.45.0"
@@ -4746,15 +5369,6 @@ dependencies = [
  "windows-targets 0.42.2",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -4773,6 +5387,24 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.3",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.42.2"
@@ -4788,21 +5420,6 @@ dependencies = [
  "windows_x86_64_msvc 0.42.2",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -4812,139 +5429,156 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm",
+ "windows_i686_gnullvm 0.52.6",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.53.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
+dependencies = [
+ "windows-link 0.1.3",
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
@@ -4952,21 +5586,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "winit"
-version = "0.30.7"
+name = "windows_x86_64_msvc"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dba50bc8ef4b6f1a75c9274fb95aa9a8f63fbc66c56f391bd85cf68d51e7b1a3"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "winit"
+version = "0.30.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66d4b9ed69c4009f6321f762d6e61ad8a2389cd431b97cb1e146812e9e6c732"
 dependencies = [
  "ahash",
  "android-activity",
  "atomic-waker",
- "bitflags 2.8.0",
- "block2",
+ "bitflags 2.9.4",
+ "block2 0.5.1",
  "bytemuck",
  "calloop",
  "cfg_aliases",
  "concurrent-queue",
- "core-foundation",
+ "core-foundation 0.9.4",
  "core-graphics",
  "cursor-icon",
  "dpi",
@@ -4974,16 +5614,16 @@ dependencies = [
  "libc",
  "memmap2",
  "ndk",
- "objc2",
- "objc2-app-kit",
- "objc2-foundation",
+ "objc2 0.5.2",
+ "objc2-app-kit 0.2.2",
+ "objc2-foundation 0.2.2",
  "objc2-ui-kit",
  "orbclient",
  "percent-encoding",
  "pin-project",
- "raw-window-handle 0.6.2",
+ "raw-window-handle",
  "redox_syscall 0.4.1",
- "rustix",
+ "rustix 0.38.38",
  "sctk-adwaita",
  "smithay-client-toolkit",
  "smol_str",
@@ -5005,24 +5645,27 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.6.20"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
+checksum = "0e7f4ea97f6f78012141bcdb6a216b2609f0979ada50b20ca5b52dde2eac2bb1"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "write16"
-version = "1.0.0"
+name = "wit-bindgen-rt"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+dependencies = [
+ "bitflags 2.9.4",
+]
 
 [[package]]
 name = "writeable"
-version = "0.5.5"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
 
 [[package]]
 name = "x11-dl"
@@ -5037,24 +5680,24 @@ dependencies = [
 
 [[package]]
 name = "x11rb"
-version = "0.13.1"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d91ffca73ee7f68ce055750bf9f6eca0780b8c85eff9bc046a3b0da41755e12"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
 dependencies = [
  "as-raw-xcb-connection",
  "gethostname",
  "libc",
  "libloading",
  "once_cell",
- "rustix",
+ "rustix 1.0.8",
  "x11rb-protocol",
 ]
 
 [[package]]
 name = "x11rb-protocol"
-version = "0.13.1"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
 
 [[package]]
 name = "xcursor"
@@ -5078,7 +5721,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.4",
  "dlib",
  "log",
  "once_cell",
@@ -5105,7 +5748,7 @@ checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9"
 
 [[package]]
 name = "xtask"
-version = "0.31.0"
+version = "0.33.2"
 
 [[package]]
 name = "yaml-rust"
@@ -5118,9 +5761,9 @@ dependencies = [
 
 [[package]]
 name = "yoke"
-version = "0.7.5"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
 dependencies = [
  "serde",
  "stable_deref_trait",
@@ -5130,9 +5773,9 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.7.5"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5142,9 +5785,9 @@ dependencies = [
 
 [[package]]
 name = "zbus"
-version = "4.4.0"
+version = "5.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725"
+checksum = "59c333f648ea1b647bc95dc1d34807c8e25ed7a6feff3394034dc4776054b236"
 dependencies = [
  "async-broadcast",
  "async-executor",
@@ -5159,45 +5802,7 @@ dependencies = [
  "enumflags2",
  "event-listener",
  "futures-core",
- "futures-sink",
- "futures-util",
- "hex",
- "nix",
- "ordered-stream",
- "rand",
- "serde",
- "serde_repr",
- "sha1",
- "static_assertions",
- "tracing",
- "uds_windows",
- "windows-sys 0.52.0",
- "xdg-home",
- "zbus_macros 4.4.0",
- "zbus_names 3.0.0",
- "zvariant 4.2.0",
-]
-
-[[package]]
-name = "zbus"
-version = "5.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1162094dc63b1629fcc44150bcceeaa80798cd28bcbe7fa987b65a034c258608"
-dependencies = [
- "async-broadcast",
- "async-executor",
- "async-fs",
- "async-io",
- "async-lock",
- "async-process",
- "async-recursion",
- "async-task",
- "async-trait",
- "blocking",
- "enumflags2",
- "event-listener",
- "futures-core",
- "futures-util",
+ "futures-lite",
  "hex",
  "nix",
  "ordered-stream",
@@ -5209,97 +5814,73 @@ dependencies = [
  "windows-sys 0.59.0",
  "winnow",
  "xdg-home",
- "zbus_macros 5.1.1",
- "zbus_names 4.1.0",
- "zvariant 5.1.0",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
 ]
 
 [[package]]
 name = "zbus-lockstep"
-version = "0.4.4"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca2c5dceb099bddaade154055c926bb8ae507a18756ba1d8963fd7b51d8ed1d"
+checksum = "a22426b1bc2aca91de97772506f0655fa373448e6010d79d5d5880915c388409"
 dependencies = [
  "zbus_xml",
- "zvariant 4.2.0",
+ "zvariant",
 ]
 
 [[package]]
 name = "zbus-lockstep-macros"
-version = "0.4.4"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "709ab20fc57cb22af85be7b360239563209258430bccf38d8b979c5a2ae3ecce"
+checksum = "100ffec29ed51859052f4563061abe35557acb56ba574510571f8398efc70a29"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
  "zbus-lockstep",
  "zbus_xml",
- "zvariant 4.2.0",
+ "zvariant",
 ]
 
 [[package]]
 name = "zbus_macros"
-version = "4.4.0"
+version = "5.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e"
+checksum = "f325ad10eb0d0a3eb060203494c3b7ec3162a01a59db75d2deee100339709fc0"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn",
- "zvariant_utils 2.1.0",
-]
-
-[[package]]
-name = "zbus_macros"
-version = "5.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cd2dcdce3e2727f7d74b7e33b5a89539b3cc31049562137faf7ae4eb86cd16d"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
- "zbus_names 4.1.0",
- "zvariant 5.1.0",
- "zvariant_utils 3.0.2",
+ "zbus_names",
+ "zvariant",
+ "zvariant_utils",
 ]
 
 [[package]]
 name = "zbus_names"
-version = "3.0.0"
+version = "4.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c"
-dependencies = [
- "serde",
- "static_assertions",
- "zvariant 4.2.0",
-]
-
-[[package]]
-name = "zbus_names"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "856b7a38811f71846fd47856ceee8bccaec8399ff53fb370247e66081ace647b"
+checksum = "7be68e64bf6ce8db94f63e72f0c7eb9a60d733f7e0499e628dfab0f84d6bcb97"
 dependencies = [
  "serde",
  "static_assertions",
  "winnow",
- "zvariant 5.1.0",
+ "zvariant",
 ]
 
 [[package]]
 name = "zbus_xml"
-version = "4.0.0"
+version = "5.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab3f374552b954f6abb4bd6ce979e6c9b38fb9d0cd7cc68a7d796e70c9f3a233"
+checksum = "589e9a02bfafb9754bb2340a9e3b38f389772684c63d9637e76b1870377bec29"
 dependencies = [
- "quick-xml 0.30.0",
+ "quick-xml 0.36.2",
  "serde",
  "static_assertions",
- "zbus_names 3.0.0",
- "zvariant 4.2.0",
+ "zbus_names",
+ "zvariant",
 ]
 
 [[package]]
@@ -5309,7 +5890,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
  "byteorder",
- "zerocopy-derive",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+dependencies = [
+ "zerocopy-derive 0.8.27",
 ]
 
 [[package]]
@@ -5323,6 +5913,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "zerofrom"
 version = "0.1.5"
@@ -5351,10 +5952,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
 
 [[package]]
-name = "zerovec"
-version = "0.10.4"
+name = "zerotrie"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -5363,9 +5975,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.10.3"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5380,31 +5992,18 @@ checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
 
 [[package]]
 name = "zune-jpeg"
-version = "0.4.13"
+version = "0.4.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16099418600b4d8f028622f73ff6e3deaabdff330fb9a2a131dea781ee8b0768"
+checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713"
 dependencies = [
  "zune-core",
 ]
 
 [[package]]
 name = "zvariant"
-version = "4.2.0"
+version = "5.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe"
-dependencies = [
- "endi",
- "enumflags2",
- "serde",
- "static_assertions",
- "zvariant_derive 4.2.0",
-]
-
-[[package]]
-name = "zvariant"
-version = "5.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1200ee6ac32f1e5a312e455a949a4794855515d34f9909f4a3e082d14e1a56f"
+checksum = "b2df9ee044893fcffbdc25de30546edef3e32341466811ca18421e3cd6c5a3ac"
 dependencies = [
  "endi",
  "enumflags2",
@@ -5412,52 +6011,28 @@ dependencies = [
  "static_assertions",
  "url",
  "winnow",
- "zvariant_derive 5.1.0",
- "zvariant_utils 3.0.2",
+ "zvariant_derive",
+ "zvariant_utils",
 ]
 
 [[package]]
 name = "zvariant_derive"
-version = "4.2.0"
+version = "5.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449"
+checksum = "74170caa85b8b84cc4935f2d56a57c7a15ea6185ccdd7eadb57e6edd90f94b2f"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn",
- "zvariant_utils 2.1.0",
-]
-
-[[package]]
-name = "zvariant_derive"
-version = "5.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "687e3b97fae6c9104fbbd36c73d27d149abf04fb874e2efbd84838763daa8916"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
- "zvariant_utils 3.0.2",
+ "zvariant_utils",
 ]
 
 [[package]]
 name = "zvariant_utils"
-version = "2.1.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zvariant_utils"
-version = "3.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20d1d011a38f12360e5fcccceeff5e2c42a8eb7f27f0dcba97a0862ede05c9c6"
+checksum = "e16edfee43e5d7b553b77872d99bc36afdda75c223ca7ad5e3fbecd82ca5fc34"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 3934c44b7..b33ca445c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,30 +1,30 @@
 [workspace]
 resolver = "2"
 members = [
-    "crates/ecolor",
-    "crates/egui_demo_app",
-    "crates/egui_demo_lib",
-    "crates/egui_extras",
-    "crates/egui_glow",
-    "crates/egui_kittest",
-    "crates/egui-wgpu",
-    "crates/egui-winit",
-    "crates/egui",
-    "crates/emath",
-    "crates/epaint",
-    "crates/epaint_default_fonts",
+  "crates/ecolor",
+  "crates/egui_demo_app",
+  "crates/egui_demo_lib",
+  "crates/egui_extras",
+  "crates/egui_glow",
+  "crates/egui_kittest",
+  "crates/egui-wgpu",
+  "crates/egui-winit",
+  "crates/egui",
+  "crates/emath",
+  "crates/epaint",
+  "crates/epaint_default_fonts",
 
-    "examples/*",
-    "tests/*",
+  "examples/*",
+  "tests/*",
 
-    "xtask",
+  "xtask",
 ]
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 license = "MIT OR Apache-2.0"
-rust-version = "1.81"
-version = "0.31.0"
+rust-version = "1.88"
+version = "0.33.2"
 
 
 [profile.release]
@@ -55,54 +55,95 @@ opt-level = 2
 
 
 [workspace.dependencies]
-emath = { version = "0.31.0", path = "crates/emath", default-features = false }
-ecolor = { version = "0.31.0", path = "crates/ecolor", default-features = false }
-epaint = { version = "0.31.0", path = "crates/epaint", default-features = false }
-epaint_default_fonts = { version = "0.31.0", path = "crates/epaint_default_fonts" }
-egui = { version = "0.31.0", path = "crates/egui", default-features = false }
-egui-winit = { version = "0.31.0", path = "crates/egui-winit", default-features = false }
-egui_extras = { version = "0.31.0", path = "crates/egui_extras", default-features = false }
-egui-wgpu = { version = "0.31.0", path = "crates/egui-wgpu", default-features = false }
-egui_demo_lib = { version = "0.31.0", path = "crates/egui_demo_lib", default-features = false }
-egui_glow = { version = "0.31.0", path = "crates/egui_glow", default-features = false }
-egui_kittest = { version = "0.31.0", path = "crates/egui_kittest", default-features = false }
-eframe = { version = "0.31.0", path = "crates/eframe", default-features = false }
+emath = { version = "0.33.2", path = "crates/emath", default-features = false }
+ecolor = { version = "0.33.2", path = "crates/ecolor", default-features = false }
+epaint = { version = "0.33.2", path = "crates/epaint", default-features = false }
+epaint_default_fonts = { version = "0.33.2", path = "crates/epaint_default_fonts" }
+egui = { version = "0.33.2", path = "crates/egui", default-features = false }
+egui-winit = { version = "0.33.2", path = "crates/egui-winit", default-features = false }
+egui_extras = { version = "0.33.2", path = "crates/egui_extras", default-features = false }
+egui-wgpu = { version = "0.33.2", path = "crates/egui-wgpu", default-features = false }
+egui_demo_lib = { version = "0.33.2", path = "crates/egui_demo_lib", default-features = false }
+egui_glow = { version = "0.33.2", path = "crates/egui_glow", default-features = false }
+egui_kittest = { version = "0.33.2", path = "crates/egui_kittest", default-features = false }
+eframe = { version = "0.33.2", path = "crates/eframe", default-features = false }
 
-ahash = { version = "0.8.11", default-features = false, features = [
-    "no-rng", # we don't need DOS-protection, so we let users opt-in to it instead
-    "std",
+accesskit = "0.21.1"
+accesskit_consumer = "0.30.1"
+accesskit_winit = "0.29.1"
+ab_glyph = "0.2.32"
+ahash = { version = "0.8.12", default-features = false, features = [
+  "no-rng", # we don't need DOS-protection, so we let users opt-in to it instead
+  "std",
 ] }
-backtrace = "0.3"
-bitflags = "2.6"
-bytemuck = "1.7.2"
-criterion = { version = "0.5.1", default-features = false }
-dify = { version = "0.7", default-features = false }
-document-features = "0.2.10"
-glow = "0.16"
-glutin = { version = "0.32.0", default-features = false }
+android_logger = "0.15.1"
+arboard = { version = "3.6.1", default-features = false }
+backtrace = "0.3.76"
+bitflags = "2.9.4"
+bytemuck = "1.24.0"
+chrono = { version = "0.4.42", default-features = false }
+cint = "0.3.1"
+color-hex = "0.2.0"
+criterion = { version = "0.7.0", default-features = false }
+dify = { version = "0.7.4", default-features = false }
+directories = "6.0.0"
+document-features = "0.2.11"
+ehttp = { version = "0.5.0", default-features = false }
+enum-map = "2.7.3"
+env_logger = { version = "0.11.8", default-features = false }
+glow = "0.16.0"
+glutin = { version = "0.32.3", default-features = false }
 glutin-winit = { version = "0.5.0", default-features = false }
 home = "0.5.9"
-image = { version = "0.25", default-features = false }
-kittest = { version = "0.1" }
-log = { version = "0.4", features = ["std"] }
-nohash-hasher = "0.2"
-parking_lot = "0.12"
-pollster = "0.4"
-profiling = { version = "1.0.16", default-features = false }
-puffin = "0.19"
-puffin_http = "0.16"
-raw-window-handle = "0.6.0"
-ron = "0.8"
-serde = { version = "1", features = ["derive"] }
-thiserror = "1.0.37"
-type-map = "0.5.0"
-wasm-bindgen = "0.2"
-wasm-bindgen-futures = "0.4"
-web-sys = "0.3.70"
+image = { version = "0.25.6", default-features = false }
+js-sys = "0.3.77"
+kittest = { version = "0.3.0" }
+log = { version = "0.4.28", features = ["std"] }
+memoffset = "0.9.1"
+mimalloc = "0.1.48"
+mime_guess2 = { version = "2.3.1", default-features = false }
+mint = "0.5.9"
+nohash-hasher = "0.2.0"
+objc2 = "0.5.2"
+objc2-app-kit = { version = "0.2.2", default-features = false }
+objc2-foundation = { version = "0.2.2", default-features = false }
+objc2-ui-kit = { version = "0.2.2", default-features = false }
+open = "5.3.2"
+parking_lot = "0.12.5"
+percent-encoding = "2.3.2"
+poll-promise = { version = "0.3.0", default-features = false }
+pollster = "0.4.0"
+profiling = { version = "1.0.17", default-features = false }
+puffin = "0.19.1"
+puffin_http = "0.16.1"
+rand = "0.9.2"
+raw-window-handle = "0.6.2"
+rayon = "1.11.0"
+resvg = { version = "0.45.1", default-features = false }
+rfd = "0.15.4"
+ron = "0.11.0"
+serde = { version = "1.0.228", features = ["derive"] }
+similar-asserts = "1.7.0"
+smallvec = "1.15.1"
+smithay-clipboard = "0.7.2"
+static_assertions = "1.1.0"
+syntect = { version = "5.3.0", default-features = false }
+tempfile = "3.23.0"
+thiserror = "2.0.17"
+tokio = "1.47.1"
+type-map = "0.5.1"
+unicode_names2 = { version = "2.0.0", default-features = false }
+unicode-segmentation = "1.12.0"
+wasm-bindgen = "0.2.100" # Keep wasm-bindgen version in sync in: setup_web.sh, Cargo.toml, Cargo.lock, rust.yml
+wasm-bindgen-futures = "0.4.0"
+wayland-cursor = { version = "0.31.11", default-features = false }
+web-sys = "0.3.77"
 web-time = "1.1.0" # Timekeeping for native and web
-wgpu = { version = "24.0.0", default-features = false }
-windows-sys = "0.59"
-winit = { version = "0.30.7", default-features = false }
+webbrowser = "1.0.5"
+wgpu = { version = "27.0.1", default-features = false, features = ["std"] }
+windows-sys = "0.61.2"
+winit = { version = "0.30.12", default-features = false }
+
 
 [workspace.lints.rust]
 unsafe_code = "deny"
@@ -115,7 +156,7 @@ rust_2021_prelude_collisions = "warn"
 semicolon_in_expressions_from_macros = "warn"
 trivial_numeric_casts = "warn"
 unexpected_cfgs = "warn"
-unsafe_op_in_unsafe_fn = "warn"                         # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
+unsafe_op_in_unsafe_fn = "warn" # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
 unused_extern_crates = "warn"
 unused_import_braces = "warn"
 unused_lifetimes = "warn"
@@ -130,25 +171,33 @@ broken_intra_doc_links = "warn"
 
 # See also clippy.toml
 [workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+
+allow_attributes = "warn"
 as_ptr_cast_mut = "warn"
 await_holding_lock = "warn"
 bool_to_int_with_if = "warn"
+branches_sharing_code = "warn"
 char_lit_as_u8 = "warn"
 checked_conversions = "warn"
 clear_with_drain = "warn"
 cloned_instead_of_copied = "warn"
 dbg_macro = "warn"
 debug_assert_with_mut_call = "warn"
+default_union_representation = "warn"
 derive_partial_eq_without_eq = "warn"
-disallowed_macros = "warn"                  # See clippy.toml
-disallowed_methods = "warn"                 # See clippy.toml
-disallowed_names = "warn"                   # See clippy.toml
-disallowed_script_idents = "warn"           # See clippy.toml
-disallowed_types = "warn"                   # See clippy.toml
+disallowed_macros = "warn" # See clippy.toml
+disallowed_methods = "warn" # See clippy.toml
+disallowed_names = "warn" # See clippy.toml
+disallowed_script_idents = "warn" # See clippy.toml
+disallowed_types = "warn" # See clippy.toml
+doc_comment_double_space_linebreaks = "warn"
 doc_link_with_quotes = "warn"
 doc_markdown = "warn"
+elidable_lifetime_names = "warn"
 empty_enum = "warn"
 empty_enum_variants_with_brackets = "warn"
+empty_line_after_outer_attr = "warn"
 enum_glob_use = "warn"
 equatable_if_let = "warn"
 exit = "warn"
@@ -165,9 +214,11 @@ fn_to_numeric_cast_any = "warn"
 from_iter_instead_of_collect = "warn"
 get_unwrap = "warn"
 if_let_mutex = "warn"
+ignore_without_reason = "warn"
 implicit_clone = "warn"
 implied_bounds_in_impls = "warn"
 imprecise_flops = "warn"
+inconsistent_struct_constructor = "warn"
 index_refutable_slice = "warn"
 inefficient_to_string = "warn"
 infinite_loop = "warn"
@@ -178,33 +229,37 @@ iter_filter_is_some = "warn"
 iter_not_returning_iterator = "warn"
 iter_on_empty_collections = "warn"
 iter_on_single_items = "warn"
+iter_over_hash_type = "warn"
 iter_without_into_iter = "warn"
 large_digit_groups = "warn"
+large_futures = "warn"
 large_include_file = "warn"
 large_stack_arrays = "warn"
 large_stack_frames = "warn"
 large_types_passed_by_value = "warn"
 let_unit_value = "warn"
 linkedlist = "warn"
+literal_string_with_formatting_args = "warn"
 lossy_float_literal = "warn"
 macro_use_imports = "warn"
 manual_assert = "warn"
 manual_clamp = "warn"
 manual_instant_elapsed = "warn"
+manual_is_power_of_two = "warn"
 manual_is_variant_and = "warn"
 manual_let_else = "warn"
+manual_midpoint = "warn" # NOTE `midpoint` is often a lot slower for floats, so we have our own `emath::fast_midpoint` function.
 manual_ok_or = "warn"
 manual_string_new = "warn"
 map_err_ignore = "warn"
 map_flatten = "warn"
-map_unwrap_or = "warn"
 match_bool = "warn"
-match_on_vec_items = "warn"
 match_same_arms = "warn"
 match_wild_err_arm = "warn"
 match_wildcard_for_single_variants = "warn"
 mem_forget = "warn"
 mismatching_type_param_order = "warn"
+missing_assert_message = "warn"
 missing_enforced_import_renames = "warn"
 missing_errors_doc = "warn"
 missing_safety_doc = "warn"
@@ -217,11 +272,16 @@ needless_for_each = "warn"
 needless_pass_by_ref_mut = "warn"
 needless_pass_by_value = "warn"
 negative_feature_names = "warn"
+non_std_lazy_statics = "warn"
+non_zero_suggestions = "warn"
 nonstandard_macro_braces = "warn"
 option_as_ref_cloned = "warn"
 option_option = "warn"
 path_buf_push_overwrite = "warn"
+pathbuf_init_then_push = "warn"
+precedence_bits = "warn"
 print_stderr = "warn"
+print_stdout = "warn"
 ptr_as_ptr = "warn"
 ptr_cast_constness = "warn"
 pub_underscore_fields = "warn"
@@ -233,10 +293,13 @@ ref_as_ptr = "warn"
 ref_option_ref = "warn"
 ref_patterns = "warn"
 rest_pat_in_fully_bound_structs = "warn"
+return_and_then = "warn"
 same_functions_in_if_condition = "warn"
 semicolon_if_nothing_returned = "warn"
+set_contains_or_insert = "warn"
 single_char_pattern = "warn"
 single_match_else = "warn"
+single_option_map = "warn"
 str_split_at_newline = "warn"
 str_to_string = "warn"
 string_add = "warn"
@@ -247,8 +310,10 @@ string_to_string = "warn"
 suspicious_command_arg_space = "warn"
 suspicious_xor_used_as_pow = "warn"
 todo = "warn"
+too_long_first_doc_paragraph = "warn"
 trailing_empty_array = "warn"
 trait_duplication_in_bounds = "warn"
+transmute_ptr_to_ptr = "warn"
 tuple_array_conversions = "warn"
 unchecked_duration_subtraction = "warn"
 undocumented_unsafe_blocks = "warn"
@@ -256,14 +321,22 @@ unimplemented = "warn"
 uninhabited_references = "warn"
 uninlined_format_args = "warn"
 unnecessary_box_returns = "warn"
+unnecessary_debug_formatting = "warn"
+unnecessary_literal_bound = "warn"
+unnecessary_safety_comment = "warn"
 unnecessary_safety_doc = "warn"
+unnecessary_self_imports = "warn"
+unnecessary_semicolon = "warn"
 unnecessary_struct_initialization = "warn"
 unnecessary_wraps = "warn"
 unnested_or_patterns = "warn"
+unused_async = "warn"
 unused_peekable = "warn"
 unused_rounding = "warn"
 unused_self = "warn"
+unused_trait_names = "warn"
 use_self = "warn"
+useless_let_if_seq = "warn"
 useless_transmute = "warn"
 verbose_file_reads = "warn"
 wildcard_dependencies = "warn"
@@ -271,17 +344,17 @@ zero_sized_map_values = "warn"
 
 
 # TODO(emilk): maybe enable more of these lints?
-iter_over_hash_type = "allow"
-missing_assert_message = "allow"
+comparison_chain = "allow"
 should_panic_without_expect = "allow"
 too_many_lines = "allow"
-unwrap_used = "allow"                 # TODO(emilk): We really wanna warn on this one
+unwrap_used = "allow" # TODO(emilk): We really wanna warn on this one
 
 # These are meh:
-assigning_clones = "allow"            # No please
+assigning_clones = "allow" # No please
 let_underscore_must_use = "allow"
 let_underscore_untyped = "allow"
-manual_range_contains = "allow"       # this one is just worse imho
-self_named_module_files = "allow"     # Disabled waiting on https://github.com/rust-lang/rust-clippy/issues/9602
+manual_range_contains = "allow" # this one is just worse imho
+map_unwrap_or = "allow" # so is this one
+self_named_module_files = "allow" # Disabled waiting on https://github.com/rust-lang/rust-clippy/issues/9602
 significant_drop_tightening = "allow" # Too many false positives
-wildcard_imports = "allow"            # `use crate::*` is useful to avoid merge conflicts when adding/removing imports
+wildcard_imports = "allow" # `use crate::*` is useful to avoid merge conflicts when adding/removing imports
diff --git a/README.md b/README.md
index fe2a7dbc1..c1d25f913 100644
--- a/README.md
+++ b/README.md
@@ -4,14 +4,14 @@
 [![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)
+[![Build Status](https://github.com/emilk/egui/workflows/Rust/badge.svg)](https://github.com/emilk/egui/actions/workflows/rust.yml)
+[![MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/emilk/egui/blob/main/LICENSE-MIT)
+[![Apache](https://img.shields.io/badge/license-Apache-blue.svg)](https://github.com/emilk/egui/blob/main/LICENSE-APACHE)
 [![Discord](https://img.shields.io/discord/900275882684477440?label=egui%20discord)](https://discord.gg/JFcEma9bJq)
 
 
 <div align="center">
-<a href="https://www.rerun.io/"><img src="media/rerun_io_logo.png" width="250"></a>
+<a href="https://www.rerun.io/"><img src="https://github.com/user-attachments/assets/78e79463-4357-461b-bbd1-31aa5ef5e1a2" width="250"></a>
 
 egui development is sponsored by [Rerun](https://www.rerun.io/), a startup building<br>
 an SDK for visualizing streams of multimodal data.
@@ -27,7 +27,7 @@ egui aims to be the easiest-to-use Rust GUI library, and the simplest way to mak
 
 egui can be used anywhere you can draw textured triangles, which means you can easily integrate it into your game engine of choice.
 
-[`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) is the official egui framework, which supports writing apps for Web, Linux, Mac, Windows, and Android.
+[`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe) is the official egui framework, which supports writing apps for Web, Linux, Mac, Windows, and Android.
 
 
 ## Example
@@ -46,7 +46,7 @@ ui.label(format!("Hello '{name}', age {age}"));
 ui.image(egui::include_image!("ferris.png"));
 ```
 
-<img alt="Dark mode" src="media/demo.gif"> &nbsp; &nbsp; <img alt="Light mode" src="media/demo_light_mode.png" height="278">
+<img alt="Dark mode" src="https://github.com/user-attachments/assets/3b446d29-99d8-4c82-86bb-4d8ef0516017"> &nbsp; &nbsp; <img alt="Light mode" src="https://github.com/user-attachments/assets/a5e7da93-89a8-4ba0-86b8-0fa2228a4f62" height="278">
 
 ## Sections:
 
@@ -68,19 +68,19 @@ ui.image(egui::include_image!("ferris.png"));
 
 ## 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.
+There are simple examples in [the `examples/` folder](https://github.com/emilk/egui/blob/main/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).
+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/main/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).
+[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/main/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:
+The native backend is [`egui_glow`](https://github.com/emilk/egui/tree/main/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`
 
@@ -99,7 +99,7 @@ On Fedora Rawhide you need to run:
 * Easy to integrate into any environment
 * A simple 2D graphics API for custom painting ([`epaint`](https://docs.rs/epaint)).
 * Pure immediate mode: no callbacks
-* 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)
+* Extensible: [easy to write your own widgets for egui](https://github.com/emilk/egui/blob/main/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
@@ -136,28 +136,20 @@ Still, egui can be used to create professional looking applications, like [the R
 Check out the [3rd party egui crates wiki](https://github.com/emilk/egui/wiki/3rd-party-egui-crates) for even more
 widgets and features, maintained by the community.
 
-<img src="media/widget_gallery_0.23.gif" width="50%">
+<img src="https://github.com/user-attachments/assets/13e73b76-e456-42bd-8ec9-220802834268" width="50%">
 
 Light Theme:
 
-<img src="media/widget_gallery_0.23_light.png" width="50%">
-
+<img src="https://github.com/user-attachments/assets/2e38972c-a444-4894-b32f-47a2719cf369" width="50%">
 
 ## Dependencies
-`egui` has a minimal set of default dependencies:
-
-* [`ab_glyph`](https://crates.io/crates/ab_glyph)
-* [`ahash`](https://crates.io/crates/ahash)
-* [`bitflags`](https://crates.io/crates/bitflags)
-* [`nohash-hasher`](https://crates.io/crates/nohash-hasher)
-* [`parking_lot`](https://crates.io/crates/parking_lot)
-
+`egui` has a minimal set of default dependencies.
 Heavier dependencies are kept out of `egui`, even as opt-in.
 All code in `egui` is Wasm-friendly (even outside a browser).
 
-To load images into `egui` you can use the official [`egui_extras`](https://github.com/emilk/egui/tree/master/crates/egui_extras) crate.
+To load images into `egui` you can use the official [`egui_extras`](https://github.com/emilk/egui/tree/main/crates/egui_extras) crate.
 
-[`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe) on the other hand has a lot of dependencies, including [`winit`](https://crates.io/crates/winit), [`image`](https://crates.io/crates/image), graphics crates, clipboard crates, etc,
+[`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe) on the other hand has a lot of dependencies, including [`winit`](https://crates.io/crates/winit), [`image`](https://crates.io/crates/image), graphics crates, clipboard crates, etc,
 
 ## Who is egui for?
 
@@ -178,16 +170,16 @@ An integration needs to do the following each frame:
 * **Input**: Gather input (mouse, touches, keyboard, screen size, etc) and give it to egui
 * Call into the application GUI 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))
+* **Painting**: Render the triangle mesh egui produces (see [OpenGL example](https://github.com/emilk/egui/blob/main/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)
+* [`eframe`](https://github.com/emilk/egui/tree/main/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/main/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/main/crates/egui-wgpu) for [wgpu](https://crates.io/crates/wgpu) (WebGPU API)
+* [`egui-winit`](https://github.com/emilk/egui/tree/main/crates/egui-winit) for integrating with [winit](https://github.com/rust-windowing/winit)
 
 ### 3rd party integrations
 
@@ -268,7 +260,7 @@ This is not yet as powerful as say CSS, [but this is going to improve](https://g
 
 Here is an example (from https://github.com/a-liashenko/TinyPomodoro):
 
-<img src="media/pompodoro-skin.png" width="50%">
+<img src="https://github.com/user-attachments/assets/e6107237-2547-41d6-996b-9a20ae0345ab" 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:
@@ -287,7 +279,7 @@ egui includes optional support for [AccessKit](https://accesskit.dev/), which cu
 
 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)?
+### What is the difference between [egui](https://docs.rs/egui) and [eframe](https://github.com/emilk/egui/tree/main/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.
@@ -304,15 +296,16 @@ If you want to embed 3D into an egui view there are two options:
 
 #### `Shape::Callback`
 Example:
-* <https://github.com/emilk/egui/blob/master/examples/custom_3d_glow/src/main.rs>
+* <https://github.com/emilk/egui/blob/main/examples/custom_3d_glow/src/main.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.
+`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/main/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 [`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe) + [`VTK (C++)`](https://vtk.org/): https://github.com/Gerharddc/vtk-egui-demo
 
 
 ## Other
@@ -354,11 +347,11 @@ Notable contributions by:
 * [@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)
+* [@KentaTheBugMaker](https://github.com/KentaTheBugMaker): [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)
 * [@mwcampbell](https://github.com/mwcampbell): [AccessKit](https://github.com/AccessKit/accesskit) [integration](https://github.com/emilk/egui/pull/2294)
-* [@hasenbanck](https://github.com/hasenbanck), [@s-nie](https://github.com/s-nie), [@Wumpf](https://github.com/Wumpf): [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu)
+* [@hasenbanck](https://github.com/hasenbanck), [@s-nie](https://github.com/s-nie), [@Wumpf](https://github.com/Wumpf): [`egui-wgpu`](https://github.com/emilk/egui/tree/main/crates/egui-wgpu)
 * [@jprochazk](https://github.com/jprochazk): [egui image API](https://github.com/emilk/egui/issues/3291)
 * And [many more](https://github.com/emilk/egui/graphs/contributors?type=a).
 
@@ -376,7 +369,7 @@ Default fonts:
 ---
 
 <div align="center">
-<a href="https://www.rerun.io/"><img src="media/rerun_io_logo.png" width="440"></a>
+<a href="https://www.rerun.io/"><img src="https://github.com/user-attachments/assets/78e79463-4357-461b-bbd1-31aa5ef5e1a2" width="440"></a>
 
 egui development is sponsored by [Rerun](https://www.rerun.io/), a startup building<br>
 an SDK for visualizing streams of multimodal data.
diff --git a/RELEASES.md b/RELEASES.md
index a8e629a03..cb75c3da8 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -9,7 +9,7 @@ All crates under the [`crates/`](crates/) folder are published in lock-step, wit
 
 The only exception to this are patch releases, where we sometimes only patch a single crate.
 
-The egui version in egui `master` is always the version of the last published crates. This is so that users can easily patch their egui crates to egui `master` if they want to.
+The egui version in egui `main` is always the version of the last published crates. This is so that users can easily patch their egui crates to egui `main` if they want to.
 
 ## Governance
 Releases are generally done by [emilk](https://github.com/emilk/), but the [rerun-io](https://github.com/rerun-io/) organization (where emilk is CTO) also has publish rights to all the crates.
@@ -22,8 +22,11 @@ We don't update the MSRV in a patch release, unless we really, really need to.
 
 
 # Release process
-## Patch release
-* [ ] Make a branch off of the latest release
+* [ ] copy this checklist to a new egui issue, called "Release 0.xx.y"
+* [ ] close all issues in the milestone for this release
+
+## Special steps for patch release
+* [ ] make a branch off of the _latest_ release
 * [ ] cherry-pick what you want to release
 * [ ] run `cargo semver-checks`
 
@@ -45,41 +48,32 @@ We don't update the MSRV in a patch release, unless we really, really need to.
 * [ ] check that CI is green
 
 ## Preparation
+* [ ] make sure there are no important unmerged PRs
+* [ ] Ensure we don't have any patch/git dependencies (e.g. kittest)
+* [ ] Create a branch called `release-0.xx.0` and open a PR for it
 * [ ] run `scripts/generate_example_screenshots.sh` if needed
 * [ ] write a short release note that fits in a bluesky post
 * [ ] record gif for `CHANGELOG.md` release note (and later bluesky post)
-* [ ] update changelogs using `scripts/generate_changelog.py --version 0.x.0 --write`
-* [ ] bump version numbers in workspace `Cargo.toml`
+* [ ] update changelogs
+  * [ ] run `scripts/generate_changelog.py --version 0.x.0 --write`
+  * [ ] read changelogs and clean them up if needed
+  * [ ] write a good intro with highlight for the main changelog
+* [ ] run `typos`
 
 ## Actual release
-I usually do this all on the `master` branch, but doing it in a release branch is also fine, as long as you remember to merge it into `master` later.
-
-* [ ] Run `typos`
-* [ ] `git commit -m 'Release 0.x.0 - <release title>'`
-* [ ] `cargo publish` (see below)
+* [ ] bump version numbers in workspace `Cargo.toml`
+* [ ] check that CI for the PR is green
+* [ ] publish the crates by running `scripts/publish_crates.sh`
 * [ ] `git tag -a 0.x.0 -m 'Release 0.x.0 - <release title>'`
 * [ ] `git pull --tags ; git tag -d latest && git tag -a latest -m 'Latest release' && git push --tags origin latest --force ; git push --tags`
-* [ ] merge release PR or push to `master`
-* [ ] check that CI is green
+* [ ] merge release PR as `Release 0.x.0 - <release title>`
+* [ ] check that CI for `main` is green
 * [ ] do a GitHub release: https://github.com/emilk/egui/releases/new
-  * Follow the format of the last release
-* [ ] wait for documentation to build: https://docs.rs/releases/queue
+  * follow the format of the last release
+* [ ] wait for  the documentation build to finish: https://docs.rs/releases/queue
+  * [ ] https://docs.rs/egui/ works
+  * [ ] https://docs.rs/eframe/ works
 
-###  `cargo publish`:
-```
-(cd crates/emath                && cargo publish --quiet)  &&  echo "✅ emath"
-(cd crates/ecolor               && cargo publish --quiet)  &&  echo "✅ ecolor"
-(cd crates/epaint_default_fonts && cargo publish --quiet)  &&  echo "✅ epaint_default_fonts"
-(cd crates/epaint               && cargo publish --quiet)  &&  echo "✅ epaint"
-(cd crates/egui                 && cargo publish --quiet)  &&  echo "✅ egui"
-(cd crates/egui-winit           && cargo publish --quiet)  &&  echo "✅ egui-winit"
-(cd crates/egui-wgpu            && cargo publish --quiet)  &&  echo "✅ egui-wgpu"
-(cd crates/egui_kittest         && cargo publish --quiet)  &&  echo "✅ egui_kittest"
-(cd crates/egui_extras          && cargo publish --quiet)  &&  echo "✅ egui_extras"
-(cd crates/egui_demo_lib        && cargo publish --quiet)  &&  echo "✅ egui_demo_lib"
-(cd crates/egui_glow            && cargo publish --quiet)  &&  echo "✅ egui_glow"
-(cd crates/eframe               && cargo publish --quiet)  &&  echo "✅ eframe"
-```
 
 ## Announcements
 * [ ] [Bluesky](https://bsky.app/profile/ernerfeldt.bsky.social)
@@ -88,10 +82,17 @@ I usually do this all on the `master` branch, but doing it in a release branch i
 * [ ] [r/programming](https://www.reddit.com/r/programming/comments/1bocsf6/announcing_egui_027_an_easytouse_crossplatform/)
 * [ ] [This Week in Rust](https://github.com/rust-lang/this-week-in-rust/pull/5167)
 
+
 ## After release
-* [ ] publish new `eframe_template`
+* [ ] update `eframe_template`
 * [ ] publish new `egui_plot`
 * [ ] publish new `egui_table`
 * [ ] publish new `egui_tiles`
 * [ ] make a PR to `egui_commonmark`
 * [ ] make a PR to `rerun`
+
+
+## Finally
+* [ ] close the milestone
+* [ ] close this issue
+* [ ] improve `RELEASES.md` with what you learned this time around
diff --git a/clippy.toml b/clippy.toml
index f349943a9..6602fbc6c 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -3,7 +3,7 @@
 # -----------------------------------------------------------------------------
 # Section identical to scripts/clippy_wasm/clippy.toml:
 
-msrv = "1.81"
+msrv = "1.88"
 
 allow-unwrap-in-tests = true
 
@@ -23,29 +23,25 @@ type-complexity-threshold = 350
 
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros
 disallowed-macros = [
-    'dbg',
-    'std::unimplemented',
+  'std::dbg',
+  'std::unimplemented',
 
-    # TODO(emilk): consider forbidding these to encourage the use of proper log stream, and then explicitly allow legitimate uses
-    # 'std::eprint',
-    # 'std::eprintln',
-    # 'std::print',
-    # 'std::println',
+  # TODO(emilk): consider forbidding these to encourage the use of proper log stream, and then explicitly allow legitimate uses
+  # 'std::eprint',
+  # 'std::eprintln',
+  # 'std::print',
+  # 'std::println',
 ]
 
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
 disallowed-methods = [
-    "std::env::temp_dir", # Use the tempdir crate instead
+  # NOTE: There are many things that aren't allowed on wasm,
+  # but we cannot disable them all here (because of e.g. https://github.com/rust-lang/rust-clippy/issues/10406)
+  # so we do that in `clipppy_wasm.toml` instead.
 
-    # There are many things that aren't allowed on wasm,
-    # but we cannot disable them all here (because of e.g. https://github.com/rust-lang/rust-clippy/issues/10406)
-    # so we do that in `clipppy_wasm.toml` instead.
-
-    "std::thread::spawn", # Use `std::thread::Builder` and name the thread
-
-    "sha1::Digest::new", # SHA1 is cryptographically broken
-
-    "std::panic::catch_unwind", # We compile with `panic = "abort"`
+  { path = "std::env::temp_dir", readon = "Use the tempfile crate instead" },
+  { path = "std::panic::catch_unwind", reason = "We compile with `panic = abort" },
+  { path = "std::thread::spawn", readon = "Use `std::thread::Builder` and name the thread" },
 ]
 
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names
@@ -53,28 +49,24 @@ disallowed-names = []
 
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
 disallowed-types = [
-    # Use the faster & simpler non-poisonable primitives in `parking_lot` instead
-    "std::sync::Mutex",
-    "std::sync::RwLock",
-    "std::sync::Condvar",
-    # "std::sync::Once",  # enabled for now as the `log_once` macro uses it internally
-
-    "ring::digest::SHA1_FOR_LEGACY_USE_ONLY", # SHA1 is cryptographically broken
-
-    "winit::dpi::LogicalSize",     # We do our own pixels<->point conversion, taking `egui_ctx.zoom_factor` into account
-    "winit::dpi::LogicalPosition", # We do our own pixels<->point conversion, taking `egui_ctx.zoom_factor` into account
+  { path = "std::sync::Condvar", reason = "Use parking_lot instead" },
+  { path = "std::sync::Mutex", reason = "Use epaint::mutex instead" },
+  { path = "std::sync::RwLock", reason = "Use epaint::mutex instead" },
+  { path = "winit::dpi::LogicalPosition", reason = "We do our own pixels<->point conversion, taking `egui_ctx.zoom_factor` into account" },
+  { path = "winit::dpi::LogicalSize", reason = "We do our own pixels<->point conversion, taking `egui_ctx.zoom_factor` into account" },
+  # "std::sync::Once",  # enabled for now as the `log_once` macro uses it internally
 ]
 
 # -----------------------------------------------------------------------------
 
 # Allow-list of words for markdown in docstrings https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 doc-valid-idents = [
-    # You must also update the same list in `scripts/clippy_wasm/clippy.toml`!
-    "AccessKit",
-    "WebGL",
-    "WebGL1",
-    "WebGL2",
-    "WebGPU",
-    "VirtualBox",
-    "..",
+  # You must also update the same list in `scripts/clippy_wasm/clippy.toml`!
+  "AccessKit",
+  "WebGL",
+  "WebGL1",
+  "WebGL2",
+  "WebGPU",
+  "VirtualBox",
+  "..",
 ]
diff --git a/crates/ecolor/CHANGELOG.md b/crates/ecolor/CHANGELOG.md
index 61cfce610..4dee81296 100644
--- a/crates/ecolor/CHANGELOG.md
+++ b/crates/ecolor/CHANGELOG.md
@@ -6,6 +6,38 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+Nothing new
+
+
+## 0.33.0 - 2025-10-09
+* Align `Color32` to 4 bytes [#7318](https://github.com/emilk/egui/pull/7318) by [@anti-social](https://github.com/anti-social)
+* Make the `hex_color` macro `const` [#7444](https://github.com/emilk/egui/pull/7444) by [@YgorSouza](https://github.com/YgorSouza)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+Nothing new
+
+
+## 0.32.1 - 2025-08-15
+Nothing new
+
+
+## 0.32.0 - 2025-07-10
+* Fix semi-transparent colors appearing too bright [#5824](https://github.com/emilk/egui/pull/5824) by [@emilk](https://github.com/emilk)
+* Remove things that have been deprecated for over a year [#7099](https://github.com/emilk/egui/pull/7099) by [@emilk](https://github.com/emilk)
+* Make `Hsva` derive serde [#7132](https://github.com/emilk/egui/pull/7132) by [@bircni](https://github.com/bircni)
+
+
+## 0.31.1 - 2025-03-05
+Nothing new
+
+
 ## 0.31.0 - 2025-02-04
 * Add `Color32::CYAN` and `Color32::MAGENTA` [#5663](https://github.com/emilk/egui/pull/5663) by [@juancampa](https://github.com/juancampa)
 
diff --git a/crates/ecolor/Cargo.toml b/crates/ecolor/Cargo.toml
index c1a10070c..f37aff109 100644
--- a/crates/ecolor/Cargo.toml
+++ b/crates/ecolor/Cargo.toml
@@ -1,10 +1,7 @@
 [package]
 name = "ecolor"
 version.workspace = true
-authors = [
-  "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
-  "Andreas Reich <reichandreas@gmx.de>",
-]
+authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>", "Andreas Reich <reichandreas@gmx.de>"]
 description = "Color structs and color conversion utilities"
 edition.workspace = true
 rust-version.workspace = true
@@ -39,10 +36,10 @@ emath.workspace = true
 bytemuck = { workspace = true, optional = true, features = ["derive"] }
 
 ## [`cint`](https://docs.rs/cint) enables interoperability with other color libraries.
-cint = { version = "0.3.1", optional = true }
+cint = { workspace = true, optional = true }
 
 ## Enable the [`hex_color`] macro.
-color-hex = { version = "0.2.0", optional = true }
+color-hex = { workspace = true, optional = true }
 
 ## Enable this when generating docs.
 document-features = { workspace = true, optional = true }
diff --git a/crates/ecolor/README.md b/crates/ecolor/README.md
index 4c84da019..98e3c3725 100644
--- a/crates/ecolor/README.md
+++ b/crates/ecolor/README.md
@@ -8,4 +8,6 @@
 
 A simple color storage and conversion library.
 
-Made for [`egui`](https://github.com/emilk/egui/).
+This crate is built for the wants and needs of [`egui`](https://github.com/emilk/egui/).
+
+If you want an actual _good_ color crate, use [`color`](https://crates.io/crates/color) instead.
diff --git a/crates/ecolor/src/cint_impl.rs b/crates/ecolor/src/cint_impl.rs
index 5d34e5e36..3d9c9d2a6 100644
--- a/crates/ecolor/src/cint_impl.rs
+++ b/crates/ecolor/src/cint_impl.rs
@@ -1,4 +1,4 @@
-use super::{linear_f32_from_linear_u8, linear_u8_from_linear_f32, Color32, Hsva, HsvaGamma, Rgba};
+use super::{Color32, Hsva, HsvaGamma, Rgba, linear_f32_from_linear_u8, linear_u8_from_linear_f32};
 use cint::{Alpha, ColorInterop, EncodedSrgb, Hsv, LinearSrgb, PremultipliedAlpha};
 
 // ---- Color32 ----
diff --git a/crates/ecolor/src/color32.rs b/crates/ecolor/src/color32.rs
index 87f4915cf..b9de323e0 100644
--- a/crates/ecolor/src/color32.rs
+++ b/crates/ecolor/src/color32.rs
@@ -1,21 +1,37 @@
-use crate::{fast_round, linear_f32_from_linear_u8, Rgba};
+use crate::{Rgba, fast_round, linear_f32_from_linear_u8};
 
 /// 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.
+/// Internally this uses 0-255 gamma space `sRGBA` color with _premultiplied alpha_.
 ///
-/// The special value of alpha=0 means the color is to be treated as an additive color.
+/// It's the non-linear ("gamma") values that are multiplied with the alpha.
+///
+/// Premultiplied alpha means that the color values have been pre-multiplied with the alpha (opacity).
+/// This is in contrast with "normal" RGBA, where the alpha is _separate_ (or "unmultiplied").
+/// Using premultiplied alpha has some advantages:
+/// * It allows encoding additive colors
+/// * It is the better way to blend colors, e.g. when filtering texture colors
+/// * Because the above, it is the better way to encode colors in a GPU texture
+///
+/// The color space is assumed to be [sRGB](https://en.wikipedia.org/wiki/SRGB).
+///
+/// All operations on `Color32` are done in "gamma space" (see <https://en.wikipedia.org/wiki/SRGB>).
+/// This is not physically correct, but it is fast and sometimes more perceptually even than linear space.
+/// If you instead want to perform these operations in linear-space color, use [`Rgba`].
+///
+/// An `alpha=0` means the color is to be treated as an additive color.
 #[repr(C)]
+#[repr(align(4))]
 #[derive(Clone, Copy, 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::fmt::Debug for Color32 {
+    /// Prints the contents with premultiplied alpha!
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let [r, g, b, a] = self.0;
         write!(f, "#{r:02X}_{g:02X}_{b:02X}_{a:02X}")
@@ -87,44 +103,49 @@ impl Color32 {
     /// i.e. often taken to mean "no color".
     pub const PLACEHOLDER: Self = Self::from_rgba_premultiplied(64, 254, 0, 128);
 
-    #[deprecated = "Renamed to PLACEHOLDER"]
-    pub const TEMPORARY_COLOR: Self = Self::PLACEHOLDER;
-
+    /// From RGB with alpha of 255 (opaque).
     #[inline]
     pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
         Self([r, g, b, 255])
     }
 
+    /// From RGB into an additive color (will make everything it blend with brighter).
     #[inline]
     pub const fn from_rgb_additive(r: u8, g: u8, b: u8) -> Self {
         Self([r, g, b, 0])
     }
 
     /// From `sRGBA` with premultiplied alpha.
+    ///
+    /// You likely want to use [`Self::from_rgba_unmultiplied`] instead.
     #[inline]
     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.
+    /// From `sRGBA` with separate alpha.
+    ///
+    /// This is a "normal" RGBA value that you would find in a color picker or a table somewhere.
+    ///
+    /// You can use [`Self::to_srgba_unmultiplied`] to get back these values,
+    /// but for transparent colors what you get back might be slightly different (rounding errors).
     #[inline]
     pub fn from_rgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
         use std::sync::OnceLock;
         match a {
-            // common-case optimization
+            // common-case optimization:
             0 => Self::TRANSPARENT,
-            // common-case optimization
+
+            // common-case optimization:
             255 => Self::from_rgb(r, g, b),
+
             a => {
                 static LOOKUP_TABLE: OnceLock<Box<[u8]>> = OnceLock::new();
                 let lut = LOOKUP_TABLE.get_or_init(|| {
-                    use crate::{gamma_u8_from_linear_f32, linear_f32_from_gamma_u8};
                     (0..=u16::MAX)
                         .map(|i| {
                             let [value, alpha] = i.to_ne_bytes();
-                            let value_lin = linear_f32_from_gamma_u8(value);
-                            let alpha_lin = linear_f32_from_linear_u8(alpha);
-                            gamma_u8_from_linear_f32(value_lin * alpha_lin)
+                            fast_round(value as f32 * linear_f32_from_linear_u8(alpha))
                         })
                         .collect()
                 });
@@ -136,22 +157,47 @@ impl Color32 {
         }
     }
 
+    /// Same as [`Self::from_rgba_unmultiplied`], but can be used in a const context.
+    ///
+    /// It is slightly slower when operating on non-const data.
+    #[inline]
+    pub const fn from_rgba_unmultiplied_const(r: u8, g: u8, b: u8, a: u8) -> Self {
+        match a {
+            // common-case optimization:
+            0 => Self::TRANSPARENT,
+
+            // common-case optimization:
+            255 => Self::from_rgb(r, g, b),
+
+            a => {
+                let r = fast_round(r as f32 * linear_f32_from_linear_u8(a));
+                let g = fast_round(g as f32 * linear_f32_from_linear_u8(a));
+                let b = fast_round(b as f32 * linear_f32_from_linear_u8(a));
+                Self::from_rgba_premultiplied(r, g, b, a)
+            }
+        }
+    }
+
+    /// Opaque gray.
     #[doc(alias = "from_grey")]
     #[inline]
     pub const fn from_gray(l: u8) -> Self {
         Self([l, l, l, 255])
     }
 
+    /// Black with the given opacity.
     #[inline]
     pub const fn from_black_alpha(a: u8) -> Self {
         Self([0, 0, 0, a])
     }
 
+    /// White with the given opacity.
     #[inline]
     pub fn from_white_alpha(a: u8) -> Self {
-        Rgba::from_white_alpha(linear_f32_from_linear_u8(a)).into()
+        Self([a, a, a, a])
     }
 
+    /// Additive white.
     #[inline]
     pub const fn from_additive_luminance(l: u8) -> Self {
         Self([l, l, l, 0])
@@ -162,21 +208,25 @@ impl Color32 {
         self.a() == 255
     }
 
+    /// Red component multiplied by alpha.
     #[inline]
     pub const fn r(&self) -> u8 {
         self.0[0]
     }
 
+    /// Green component multiplied by alpha.
     #[inline]
     pub const fn g(&self) -> u8 {
         self.0[1]
     }
 
+    /// Blue component multiplied by alpha.
     #[inline]
     pub const fn b(&self) -> u8 {
         self.0[2]
     }
 
+    /// Alpha (opacity).
     #[inline]
     pub const fn a(&self) -> u8 {
         self.0[3]
@@ -213,9 +263,26 @@ impl Color32 {
         (self.r(), self.g(), self.b(), self.a())
     }
 
+    /// Convert to a normal "unmultiplied" RGBA color (i.e. with separate alpha).
+    ///
+    /// This will unmultiply the alpha.
+    ///
+    /// This is the inverse of [`Self::from_rgba_unmultiplied`],
+    /// but due to precision problems it may return slightly different values for transparent colors.
     #[inline]
     pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
-        Rgba::from(*self).to_srgba_unmultiplied()
+        let [r, g, b, a] = self.to_array();
+        match a {
+            // Common-case optimization.
+            0 | 255 => self.to_array(),
+            a => {
+                let factor = 255.0 / a as f32;
+                let r = fast_round(factor * r as f32);
+                let g = fast_round(factor * g as f32);
+                let b = fast_round(factor * b as f32);
+                [r, g, b, a]
+            }
+        }
     }
 
     /// Multiply with 0.5 to make color half as opaque, perceptually.
@@ -225,7 +292,10 @@ impl Color32 {
     /// This is perceptually even, and faster that [`Self::linear_multiply`].
     #[inline]
     pub fn gamma_multiply(self, factor: f32) -> Self {
-        debug_assert!(0.0 <= factor && factor.is_finite());
+        debug_assert!(
+            0.0 <= factor && factor.is_finite(),
+            "factor should be finite, but was {factor}"
+        );
         let Self([r, g, b, a]) = self;
         Self([
             (r as f32 * factor + 0.5) as u8,
@@ -258,7 +328,10 @@ impl Color32 {
     /// You likely want to use [`Self::gamma_multiply`] instead.
     #[inline]
     pub fn linear_multiply(self, factor: f32) -> Self {
-        debug_assert!(0.0 <= factor && factor.is_finite());
+        debug_assert!(
+            0.0 <= factor && factor.is_finite(),
+            "factor should be finite, but was {factor}"
+        );
         // 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()
@@ -291,10 +364,18 @@ impl Color32 {
         )
     }
 
-    /// Blend two colors, so that `self` is behind the argument.
+    /// Blend two colors in gamma space, so that `self` is behind the argument.
     pub fn blend(self, on_top: Self) -> Self {
         self.gamma_multiply_u8(255 - on_top.a()) + on_top
     }
+
+    /// Intensity of the color.
+    ///
+    /// Returns a value in the range 0-1.
+    /// The brighter the color, the closer to 1.
+    pub fn intensity(&self) -> f32 {
+        (self.r() as f32 * 0.299 + self.g() as f32 * 0.587 + self.b() as f32 * 0.114) / 255.0
+    }
 }
 
 impl std::ops::Mul for Color32 {
@@ -325,3 +406,133 @@ impl std::ops::Add for Color32 {
         ])
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn test_rgba() -> impl Iterator<Item = [u8; 4]> {
+        [
+            [0, 0, 0, 0],
+            [0, 0, 0, 255],
+            [10, 0, 30, 0],
+            [10, 0, 30, 40],
+            [10, 100, 200, 0],
+            [10, 100, 200, 100],
+            [10, 100, 200, 200],
+            [10, 100, 200, 255],
+            [10, 100, 200, 40],
+            [10, 20, 0, 0],
+            [10, 20, 0, 255],
+            [10, 20, 30, 255],
+            [10, 20, 30, 40],
+            [255, 255, 255, 0],
+            [255, 255, 255, 255],
+        ]
+        .into_iter()
+    }
+
+    #[test]
+    fn test_color32_additive() {
+        let opaque = Color32::from_rgb(40, 50, 60);
+        let additive = Color32::from_rgb(255, 127, 10).additive();
+        assert_eq!(additive.blend(opaque), opaque, "opaque on top of additive");
+        assert_eq!(
+            opaque.blend(additive),
+            Color32::from_rgb(255, 177, 70),
+            "additive on top of opaque"
+        );
+    }
+
+    #[test]
+    fn test_color32_blend_vs_gamma_blend() {
+        let opaque = Color32::from_rgb(0x60, 0x60, 0x60);
+        let transparent = Color32::from_rgba_unmultiplied(168, 65, 65, 79);
+        assert_eq!(
+            transparent.blend(opaque),
+            opaque,
+            "Opaque on top of transparent"
+        );
+        // Blending in gamma-space is the de-facto standard almost everywhere.
+        // Browsers and most image editors do it, and so it is what users expect.
+        assert_eq!(
+            opaque.blend(transparent),
+            Color32::from_rgb(
+                blend(0x60, 168, 79),
+                blend(0x60, 65, 79),
+                blend(0x60, 65, 79)
+            ),
+            "Transparent on top of opaque"
+        );
+
+        fn blend(dest: u8, src: u8, alpha: u8) -> u8 {
+            let src = src as f32 / 255.0;
+            let dest = dest as f32 / 255.0;
+            let alpha = alpha as f32 / 255.0;
+            fast_round((src * alpha + dest * (1.0 - alpha)) * 255.0)
+        }
+    }
+
+    #[test]
+    fn color32_unmultiplied_round_trip() {
+        for in_rgba in test_rgba() {
+            let [r, g, b, a] = in_rgba;
+            if a == 0 {
+                continue;
+            }
+
+            let c = Color32::from_rgba_unmultiplied(r, g, b, a);
+            let out_rgba = c.to_srgba_unmultiplied();
+
+            if a == 255 {
+                assert_eq!(in_rgba, out_rgba);
+            } else {
+                // There will be small rounding errors whenever the alpha is not 0 or 255,
+                // because we multiply and then unmultiply the alpha.
+                for (&a, &b) in in_rgba.iter().zip(out_rgba.iter()) {
+                    assert!(a.abs_diff(b) <= 3, "{in_rgba:?} != {out_rgba:?}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn from_black_white_alpha() {
+        for a in 0..=255 {
+            assert_eq!(
+                Color32::from_white_alpha(a),
+                Color32::from_rgba_unmultiplied(255, 255, 255, a)
+            );
+            assert_eq!(
+                Color32::from_white_alpha(a),
+                Color32::WHITE.gamma_multiply_u8(a)
+            );
+
+            assert_eq!(
+                Color32::from_black_alpha(a),
+                Color32::from_rgba_unmultiplied(0, 0, 0, a)
+            );
+            assert_eq!(
+                Color32::from_black_alpha(a),
+                Color32::BLACK.gamma_multiply_u8(a)
+            );
+        }
+    }
+
+    #[test]
+    fn to_from_rgba() {
+        for [r, g, b, a] in test_rgba() {
+            let original = Color32::from_rgba_unmultiplied(r, g, b, a);
+            let constfn = Color32::from_rgba_unmultiplied_const(r, g, b, a);
+            let rgba = Rgba::from(original);
+            let back = Color32::from(rgba);
+            assert_eq!(back, original);
+            assert_eq!(constfn, original);
+        }
+
+        assert_eq!(
+            Color32::from(Rgba::from_rgba_unmultiplied(1.0, 0.0, 0.0, 0.5)),
+            Color32::from_rgba_unmultiplied(255, 0, 0, 128)
+        );
+    }
+}
diff --git a/crates/ecolor/src/hex_color_macro.rs b/crates/ecolor/src/hex_color_macro.rs
index e95bbc465..cda00a513 100644
--- a/crates/ecolor/src/hex_color_macro.rs
+++ b/crates/ecolor/src/hex_color_macro.rs
@@ -31,10 +31,11 @@
 /// let _ = ecolor::hex_color!("#20212x");
 /// ```
 ///
-/// The macro cannot be used in a `const` context.
+/// The macro can be used in a `const` context.
 ///
-/// ```compile_fail
+/// ```
 /// const COLOR: ecolor::Color32 = ecolor::hex_color!("#202122");
+/// assert_eq!(COLOR, ecolor::Color32::from_rgb(0x20, 0x21, 0x22));
 /// ```
 #[macro_export]
 macro_rules! hex_color {
@@ -42,7 +43,7 @@ macro_rules! hex_color {
         let array = $crate::color_hex::color_from_hex!($s);
         match array.as_slice() {
             [r, g, b] => $crate::Color32::from_rgb(*r, *g, *b),
-            [r, g, b, a] => $crate::Color32::from_rgba_unmultiplied(*r, *g, *b, *a),
+            [r, g, b, a] => $crate::Color32::from_rgba_unmultiplied_const(*r, *g, *b, *a),
             _ => panic!("Invalid hex color length: expected 3 (RGB) or 4 (RGBA) bytes"),
         }
     }};
diff --git a/crates/ecolor/src/hex_color_runtime.rs b/crates/ecolor/src/hex_color_runtime.rs
index 5b20258fa..21e07ffc4 100644
--- a/crates/ecolor/src/hex_color_runtime.rs
+++ b/crates/ecolor/src/hex_color_runtime.rs
@@ -90,14 +90,15 @@ impl HexColor {
                 let [r, gb] = u16::from_str_radix(s, 16)
                     .map_err(ParseHexColorError::InvalidInt)?
                     .to_be_bytes();
-                let [r, g, b] = [r, gb >> 4, gb & 0x0f].map(|u| u << 4 | u);
+                let [r, g, b] = [r, gb >> 4, gb & 0x0f].map(|u| (u << 4) | u);
                 Ok(Self::Hex3(Color32::from_rgb(r, g, b)))
             }
             4 => {
                 let [r_g, b_a] = u16::from_str_radix(s, 16)
                     .map_err(ParseHexColorError::InvalidInt)?
                     .to_be_bytes();
-                let [r, g, b, a] = [r_g >> 4, r_g & 0x0f, b_a >> 4, b_a & 0x0f].map(|u| u << 4 | u);
+                let [r, g, b, a] =
+                    [r_g >> 4, r_g & 0x0f, b_a >> 4, b_a & 0x0f].map(|u| (u << 4) | u);
                 Ok(Self::Hex4(Color32::from_rgba_unmultiplied(r, g, b, a)))
             }
             6 => {
@@ -207,17 +208,22 @@ mod tests {
 
     #[test]
     fn hex_string_round_trip() {
-        use Color32 as C;
         let cases = [
-            C::from_rgba_unmultiplied(10, 20, 30, 0),
-            C::from_rgba_unmultiplied(10, 20, 30, 40),
-            C::from_rgba_unmultiplied(10, 20, 30, 255),
-            C::from_rgba_unmultiplied(0, 20, 30, 0),
-            C::from_rgba_unmultiplied(10, 0, 30, 40),
-            C::from_rgba_unmultiplied(10, 20, 0, 255),
+            [0, 20, 30, 0],
+            [10, 0, 30, 40],
+            [10, 100, 200, 0],
+            [10, 100, 200, 100],
+            [10, 100, 200, 200],
+            [10, 100, 200, 255],
+            [10, 100, 200, 40],
+            [10, 20, 0, 255],
+            [10, 20, 30, 0],
+            [10, 20, 30, 255],
+            [10, 20, 30, 40],
         ];
-        for color in cases {
-            assert_eq!(C::from_hex(color.to_hex().as_str()), Ok(color));
+        for [r, g, b, a] in cases {
+            let color = Color32::from_rgba_unmultiplied(r, g, b, a);
+            assert_eq!(Color32::from_hex(color.to_hex().as_str()), Ok(color));
         }
     }
 }
diff --git a/crates/ecolor/src/hsva.rs b/crates/ecolor/src/hsva.rs
index 5f5430cf0..06adb121f 100644
--- a/crates/ecolor/src/hsva.rs
+++ b/crates/ecolor/src/hsva.rs
@@ -1,10 +1,10 @@
 use crate::{
-    gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8,
-    linear_u8_from_linear_f32, Color32, Rgba,
+    Color32, Rgba, gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_u8_from_linear_f32,
 };
 
 /// Hue, saturation, value, alpha. All in the range [0, 1].
 /// No premultiplied alpha.
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Hsva {
     /// hue 0-1
@@ -29,30 +29,20 @@ impl Hsva {
     /// From `sRGBA` with premultiplied alpha
     #[inline]
     pub fn from_srgba_premultiplied([r, g, b, a]: [u8; 4]) -> Self {
-        Self::from_rgba_premultiplied(
-            linear_f32_from_gamma_u8(r),
-            linear_f32_from_gamma_u8(g),
-            linear_f32_from_gamma_u8(b),
-            linear_f32_from_linear_u8(a),
-        )
+        Self::from(Color32::from_rgba_premultiplied(r, g, b, a))
     }
 
     /// From `sRGBA` without premultiplied alpha
     #[inline]
     pub fn from_srgba_unmultiplied([r, g, b, a]: [u8; 4]) -> Self {
-        Self::from_rgba_unmultiplied(
-            linear_f32_from_gamma_u8(r),
-            linear_f32_from_gamma_u8(g),
-            linear_f32_from_gamma_u8(b),
-            linear_f32_from_linear_u8(a),
-        )
+        Self::from(Color32::from_rgba_unmultiplied(r, g, b, a))
     }
 
     /// From linear RGBA with premultiplied alpha
     #[inline]
     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 a <= 0.0 {
             if r == 0.0 && b == 0.0 && a == 0.0 {
                 Self::default()
             } else {
@@ -152,13 +142,7 @@ impl Hsva {
 
     #[inline]
     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),
-        ]
+        Color32::from(*self).to_array()
     }
 
     /// To gamma-space 0-255.
@@ -250,7 +234,7 @@ pub fn rgb_from_hsv((h, s, v): (f32, f32, f32)) -> [f32; 3] {
 }
 
 #[test]
-#[ignore] // a bit expensive
+#[ignore = "too expensive"]
 fn test_hsv_roundtrip() {
     for r in 0..=255 {
         for g in 0..=255 {
diff --git a/crates/ecolor/src/hsva_gamma.rs b/crates/ecolor/src/hsva_gamma.rs
index 67e167677..19e31f337 100644
--- a/crates/ecolor/src/hsva_gamma.rs
+++ b/crates/ecolor/src/hsva_gamma.rs
@@ -1,4 +1,4 @@
-use crate::{gamma_from_linear, linear_from_gamma, Color32, Hsva, Rgba};
+use crate::{Color32, Hsva, Rgba, gamma_from_linear, linear_from_gamma};
 
 /// Like Hsva but with the `v` value (brightness) being gamma corrected
 /// so that it is somewhat perceptually even.
diff --git a/crates/ecolor/src/lib.rs b/crates/ecolor/src/lib.rs
index a9400d9de..f4cdf4d77 100644
--- a/crates/ecolor/src/lib.rs
+++ b/crates/ecolor/src/lib.rs
@@ -1,9 +1,20 @@
 //! Color conversions and types.
 //!
+//! This crate is built for the wants and needs of [`egui`](https://github.com/emilk/egui/).
+//!
+//! If you want an actual _good_ color crate, use [`color`](https://crates.io/crates/color) instead.
+//!
 //! If you want a compact color representation, use [`Color32`].
-//! If you want to manipulate RGBA colors use [`Rgba`].
+//! If you want to manipulate RGBA colors in linear space use [`Rgba`].
 //! If you want to manipulate colors in a way closer to how humans think about colors, use [`HsvaGamma`].
 //!
+//! ## Conventions
+//! The word "gamma" or "srgb" is used to refer to values in the non-linear space defined by
+//! [the sRGB transfer function](https://en.wikipedia.org/wiki/SRGB).
+//! We use `u8` for anything in the "gamma" space.
+//!
+//! We use `f32` in 0-1 range for anything in the linear space.
+//!
 //! ## Feature flags
 #![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
 //!
@@ -39,23 +50,46 @@ pub use hex_color_runtime::*;
 
 impl From<Color32> for Rgba {
     fn from(srgba: Color32) -> Self {
-        Self([
-            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]),
-        ])
+        let [r, g, b, a] = srgba.to_array();
+        if a == 0 {
+            // Additive, or completely transparent
+            Self([
+                linear_f32_from_gamma_u8(r),
+                linear_f32_from_gamma_u8(g),
+                linear_f32_from_gamma_u8(b),
+                0.0,
+            ])
+        } else {
+            let a = linear_f32_from_linear_u8(a);
+            Self([
+                linear_from_gamma(r as f32 / (255.0 * a)) * a,
+                linear_from_gamma(g as f32 / (255.0 * a)) * a,
+                linear_from_gamma(b as f32 / (255.0 * a)) * a,
+                a,
+            ])
+        }
     }
 }
 
 impl From<Rgba> for Color32 {
     fn from(rgba: Rgba) -> Self {
-        Self([
-            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]),
-        ])
+        let [r, g, b, a] = rgba.to_array();
+        if a == 0.0 {
+            // Additive, or completely transparent
+            Self([
+                gamma_u8_from_linear_f32(r),
+                gamma_u8_from_linear_f32(g),
+                gamma_u8_from_linear_f32(b),
+                0,
+            ])
+        } else {
+            Self([
+                fast_round(gamma_u8_from_linear_f32(r / a) as f32 * a),
+                fast_round(gamma_u8_from_linear_f32(g / a) as f32 * a),
+                fast_round(gamma_u8_from_linear_f32(b / a) as f32 * a),
+                linear_u8_from_linear_f32(a),
+            ])
+        }
     }
 }
 
@@ -71,7 +105,7 @@ pub fn linear_f32_from_gamma_u8(s: u8) -> f32 {
 /// linear [0, 255] -> linear [0, 1].
 /// Useful for alpha-channel.
 #[inline(always)]
-pub fn linear_f32_from_linear_u8(a: u8) -> f32 {
+pub const fn linear_f32_from_linear_u8(a: u8) -> f32 {
     a as f32 / 255.0
 }
 
@@ -96,7 +130,7 @@ pub fn linear_u8_from_linear_f32(a: f32) -> u8 {
     fast_round(a * 255.0)
 }
 
-fn fast_round(r: f32) -> u8 {
+const fn fast_round(r: f32) -> u8 {
     (r + 0.5) as _ // rust does a saturating cast since 1.45
 }
 
diff --git a/crates/ecolor/src/rgba.rs b/crates/ecolor/src/rgba.rs
index 93cb41d81..3e40af2b0 100644
--- a/crates/ecolor/src/rgba.rs
+++ b/crates/ecolor/src/rgba.rs
@@ -1,9 +1,8 @@
-use crate::{
-    gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_linear_u8,
-    linear_u8_from_linear_f32,
-};
+use crate::Color32;
 
 /// 0-1 linear space `RGBA` color with premultiplied alpha.
+///
+/// See [`crate::Color32`] for explanation of what "premultiplied alpha" means.
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -34,12 +33,11 @@ pub(crate) fn f32_hash<H: std::hash::Hasher>(state: &mut H, f: f32) {
     } else if f.is_nan() {
         state.write_u8(1);
     } else {
-        use std::hash::Hash;
+        use std::hash::Hash as _;
         f.to_bits().hash(state);
     }
 }
 
-#[allow(clippy::derived_hash_with_manual_eq)]
 impl std::hash::Hash for Rgba {
     #[inline]
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
@@ -70,20 +68,12 @@ impl Rgba {
 
     #[inline]
     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)
+        Self::from(Color32::from_rgba_premultiplied(r, g, b, a))
     }
 
     #[inline]
     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)
+        Self::from(Color32::from_rgba_unmultiplied(r, g, b, a))
     }
 
     #[inline]
@@ -99,15 +89,24 @@ impl Rgba {
 
     #[inline]
     pub fn from_luminance_alpha(l: f32, a: f32) -> Self {
-        debug_assert!(0.0 <= l && l <= 1.0);
-        debug_assert!(0.0 <= a && a <= 1.0);
+        debug_assert!(
+            0.0 <= l && l <= 1.0,
+            "l should be in the range [0, 1], but was {l}"
+        );
+        debug_assert!(
+            0.0 <= a && a <= 1.0,
+            "a should be in the range [0, 1], but was {a}"
+        );
         Self([l * a, l * a, l * a, a])
     }
 
     /// Transparent black
     #[inline]
     pub fn from_black_alpha(a: f32) -> Self {
-        debug_assert!(0.0 <= a && a <= 1.0);
+        debug_assert!(
+            0.0 <= a && a <= 1.0,
+            "a should be in the range [0, 1], but was {a}"
+        );
         Self([0.0, 0.0, 0.0, a])
     }
 
@@ -211,13 +210,12 @@ impl Rgba {
     /// unmultiply the alpha
     #[inline]
     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()),
-        ]
+        crate::Color32::from(*self).to_srgba_unmultiplied()
+    }
+
+    /// Blend two colors in linear space, so that `self` is behind the argument.
+    pub fn blend(self, on_top: Self) -> Self {
+        self.multiply(1.0 - on_top.a()) + on_top
     }
 }
 
@@ -276,3 +274,72 @@ impl std::ops::Mul<Rgba> for f32 {
         ])
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+
+    fn test_rgba() -> impl Iterator<Item = [u8; 4]> {
+        [
+            [0, 0, 0, 0],
+            [0, 0, 0, 255],
+            [10, 0, 30, 0],
+            [10, 0, 30, 40],
+            [10, 100, 200, 0],
+            [10, 100, 200, 100],
+            [10, 100, 200, 200],
+            [10, 100, 200, 255],
+            [10, 100, 200, 40],
+            [10, 20, 0, 0],
+            [10, 20, 0, 255],
+            [10, 20, 30, 255],
+            [10, 20, 30, 40],
+            [255, 255, 255, 0],
+            [255, 255, 255, 255],
+        ]
+        .into_iter()
+    }
+
+    #[test]
+    fn test_rgba_blend() {
+        let opaque = Rgba::from_rgb(0.4, 0.5, 0.6);
+        let transparent = Rgba::from_rgb(1.0, 0.5, 0.0).multiply(0.3);
+        assert_eq!(
+            transparent.blend(opaque),
+            opaque,
+            "Opaque on top of transparent"
+        );
+        assert_eq!(
+            opaque.blend(transparent),
+            Rgba::from_rgb(
+                0.7 * 0.4 + 0.3 * 1.0,
+                0.7 * 0.5 + 0.3 * 0.5,
+                0.7 * 0.6 + 0.3 * 0.0
+            ),
+            "Transparent on top of opaque"
+        );
+    }
+
+    #[test]
+    fn test_rgba_roundtrip() {
+        for in_rgba in test_rgba() {
+            let [r, g, b, a] = in_rgba;
+            if a == 0 {
+                continue;
+            }
+            let rgba = Rgba::from_srgba_unmultiplied(r, g, b, a);
+            let out_rgba = rgba.to_srgba_unmultiplied();
+
+            if a == 255 {
+                assert_eq!(in_rgba, out_rgba);
+            } else {
+                // There will be small rounding errors whenever the alpha is not 0 or 255,
+                // because we multiply and then unmultiply the alpha.
+                for (&a, &b) in in_rgba.iter().zip(out_rgba.iter()) {
+                    assert!(a.abs_diff(b) <= 3, "{in_rgba:?} != {out_rgba:?}");
+                }
+            }
+        }
+    }
+}
diff --git a/crates/eframe/CHANGELOG.md b/crates/eframe/CHANGELOG.md
index 967b69e3b..11f1c8fc9 100644
--- a/crates/eframe/CHANGELOG.md
+++ b/crates/eframe/CHANGELOG.md
@@ -7,6 +7,73 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+* Fix jittering during window resize on MacOS for WGPU/Metal [#7641](https://github.com/emilk/egui/pull/7641) by [@aspcartman](https://github.com/aspcartman)
+* Make sure `native_pixels_per_point` is set during app creation [#7683](https://github.com/emilk/egui/pull/7683) by [@emilk](https://github.com/emilk)
+
+
+## 0.33.0 - 2025-10-09
+### ⭐ Added
+* Add an option to limit the repaint rate in the web runner [#7482](https://github.com/emilk/egui/pull/7482) by [@s-nie](https://github.com/s-nie)
+* Add rotation gesture support for trackpad sources [#7453](https://github.com/emilk/egui/pull/7453) by [@thatcomputerguy0101](https://github.com/thatcomputerguy0101)
+* Add support for the safe area on iOS [#7578](https://github.com/emilk/egui/pull/7578) by [@irh](https://github.com/irh)
+
+### 🔧 Changed
+* Replace `winapi` with `windows-sys` crate [#7416](https://github.com/emilk/egui/pull/7416) by [@unlimitedsola](https://github.com/unlimitedsola)
+* Prevent default action on command-comma in eframe web [#7547](https://github.com/emilk/egui/pull/7547) by [@emilk](https://github.com/emilk)
+* Warn if `DYLD_LIBRARY_PATH` is set and we find no wgpu adapter [#7572](https://github.com/emilk/egui/pull/7572) by [@emilk](https://github.com/emilk)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+
+### 🐛 Fixed
+* Properly end winit event loop [#7565](https://github.com/emilk/egui/pull/7565) by [@tye-exe](https://github.com/tye-exe)
+* Fix eframe window not being focused on mac on startup [#7593](https://github.com/emilk/egui/pull/7593) by [@emilk](https://github.com/emilk)
+* Fix black flash on start in glow eframe backend [#7616](https://github.com/emilk/egui/pull/7616) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+Nothing new
+
+
+## 0.32.1 - 2025-08-15
+* Enable wgpu default features in eframe / egui_wgpu default features [#7344](https://github.com/emilk/egui/pull/7344) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Request a redraw when the url change through the `popstate` event listener [#7403](https://github.com/emilk/egui/pull/7403) by [@irevoire](https://github.com/irevoire)
+
+
+## 0.32.0 - 2025-07-10
+### ⭐ Added
+* Add pointer events and focus handling for apps run in a Shadow DOM [#5627](https://github.com/emilk/egui/pull/5627) by [@xxvvii](https://github.com/xxvvii)
+* MacOS: Add `movable_by_window_background` option to viewport [#5412](https://github.com/emilk/egui/pull/5412) by [@jim-ec](https://github.com/jim-ec)
+* Add macOS-specific `has_shadow` and `with_has_shadow` to ViewportBuilder [#6850](https://github.com/emilk/egui/pull/6850) by [@gaelanmcmillan](https://github.com/gaelanmcmillan)
+* Add external eventloop support [#6750](https://github.com/emilk/egui/pull/6750) by [@wpbrown](https://github.com/wpbrown)
+
+### 🔧 Changed
+* Update MSRV to 1.85 [#7279](https://github.com/emilk/egui/pull/7279) by [@emilk](https://github.com/emilk)
+* Use Rust edition 2024 [#7280](https://github.com/emilk/egui/pull/7280) by [@emilk](https://github.com/emilk)
+* Rename `should_propagate_event` and add `should_prevent_default` [#5779](https://github.com/emilk/egui/pull/5779) by [@th0rex](https://github.com/th0rex)
+* Clarify platform-specific details for `Viewport` positioning [#5715](https://github.com/emilk/egui/pull/5715) by [@aspiringLich](https://github.com/aspiringLich)
+* Enhance stability on Windows [#5723](https://github.com/emilk/egui/pull/5723) by [@rustbasic](https://github.com/rustbasic)
+* Set `web-sys` min version to `0.3.73` [#5862](https://github.com/emilk/egui/pull/5862) by [@wareya](https://github.com/wareya)
+* Bump `ron` to `0.10.1` [#6861](https://github.com/emilk/egui/pull/6861) by [@torokati44](https://github.com/torokati44)
+* Disallow `accesskit` on Android NativeActivity, making `hello_android` working again [#6855](https://github.com/emilk/egui/pull/6855) by [@podusowski](https://github.com/podusowski)
+* Respect and detect `prefers-color-scheme: no-preference` [#7293](https://github.com/emilk/egui/pull/7293) by [@emilk](https://github.com/emilk)
+
+### 🐛 Fixed
+* Mark all keys as up if the app loses focus [#5743](https://github.com/emilk/egui/pull/5743) by [@emilk](https://github.com/emilk)
+* Fix text input on Android [#5759](https://github.com/emilk/egui/pull/5759) by [@StratusFearMe21](https://github.com/StratusFearMe21)
+* Fix text distortion on mobile devices/browsers with `glow` backend [#6893](https://github.com/emilk/egui/pull/6893) by [@wareya](https://github.com/wareya)
+* Workaround libpng crash on macOS by not creating `NSImage` from png data [#7252](https://github.com/emilk/egui/pull/7252) by [@Wumpf](https://github.com/Wumpf)
+* Fix incorrect window sizes for non-resizable windows on Wayland [#7103](https://github.com/emilk/egui/pull/7103) by [@GoldsteinE](https://github.com/GoldsteinE)
+* Web: only consume copy/cut events if the canvas has focus [#7270](https://github.com/emilk/egui/pull/7270) by [@emilk](https://github.com/emilk)
+
+
+## 0.31.1 - 2025-03-05
+Nothing new
+
+
 ## 0.31.0 - 2025-02-04
 * Web: Fix incorrect scale when moving to screen with new DPI [#5631](https://github.com/emilk/egui/pull/5631) by [@emilk](https://github.com/emilk)
 * Re-enable IME support on Linux [#5198](https://github.com/emilk/egui/pull/5198) by [@YgorSouza](https://github.com/YgorSouza)
diff --git a/crates/eframe/Cargo.toml b/crates/eframe/Cargo.toml
index 883ec7d59..6924633f1 100644
--- a/crates/eframe/Cargo.toml
+++ b/crates/eframe/Cargo.toml
@@ -5,19 +5,13 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "egui framework - write GUI apps that compiles to web and/or natively"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/eframe"
+homepage = "https://github.com/emilk/egui/tree/main/crates/eframe"
 license.workspace = true
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/eframe"
+repository = "https://github.com/emilk/egui/tree/main/crates/eframe"
 categories = ["gui", "game-development"]
 keywords = ["egui", "gui", "gamedev"]
-include = [
-  "../LICENSE-APACHE",
-  "../LICENSE-MIT",
-  "**/*.rs",
-  "Cargo.toml",
-  "data/icon.png",
-]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml", "data/icon.png"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -34,16 +28,15 @@ workspace = true
 default = [
   "accesskit",
   "default_fonts",
-  "glow",
-  "wayland",                                      # Required for Linux support (including CI!)
+  "wayland", # Required for Linux support (including CI!)
   "web_screen_reader",
+  "wgpu",
   "winit/default",
   "x11",
-  "egui-wgpu?/fragile-send-sync-non-atomic-wasm",
 ]
 
 ## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
-accesskit = ["egui/accesskit", "egui-winit/accesskit"]
+accesskit = ["egui-winit/accesskit"]
 
 # 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
@@ -59,17 +52,15 @@ android-native-activity = ["egui-winit/android-native-activity"]
 ## 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).
+## Enable [`glow`](https://github.com/grovesNL/glow) for painting, via [`egui_glow`](https://github.com/emilk/egui/tree/main/crates/egui_glow).
+##
+## There is generally no need to enable both the `wgpu` and `glow` features,
+## but if you do you can pick the renderer to use with [`NativeOptions::renderer`]
+## and `WebOptions::renderer`.
 glow = ["dep:egui_glow", "dep:glow", "dep:glutin-winit", "dep:glutin"]
 
 ## Enable saving app state to disk.
-persistence = [
-  "dep:home",
-  "egui-winit/serde",
-  "egui/persistence",
-  "ron",
-  "serde",
-]
+persistence = ["dep:home", "egui-winit/serde", "egui/persistence", "ron", "serde"]
 
 ## Enables wayland support and fixes clipboard issue.
 ##
@@ -85,25 +76,30 @@ wayland = [
 ## 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 = [
-  "web-sys/SpeechSynthesis",
-  "web-sys/SpeechSynthesisUtterance",
-]
+web_screen_reader = ["web-sys/SpeechSynthesis", "web-sys/SpeechSynthesisUtterance"]
 
-## Use [`wgpu`](https://docs.rs/wgpu) for painting (via [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu)).
+## Enable [`wgpu`](https://docs.rs/wgpu) for painting (via [`egui-wgpu`](https://github.com/emilk/egui/tree/main/crates/egui-wgpu)).
 ##
-## This overrides the `glow` feature.
+## There is generally no need to enable both the `wgpu` and `glow` features,
+## but if you do you can pick the renderer to use with [`NativeOptions::renderer`]
+## and `WebOptions::renderer`.
 ##
-## By default, only WebGPU is enabled on web.
-## If you want to enable WebGL, you need to turn on the `webgl` feature of crate `wgpu`:
-##
-## ```toml
-## wgpu = { version = "*", features = ["webgpu", "webgl"] }
-## ```
+## Switching from `wgpu (the default)` to `glow` can significantly reduce your binary size
+## (including the .wasm of a web app).
+## See <https://github.com/emilk/egui/issues/5889> for more details.
 ##
 ## By default, eframe will prefer WebGPU over WebGL, but
 ## you can configure this at run-time with [`NativeOptions::wgpu_options`].
-wgpu = ["dep:wgpu", "dep:egui-wgpu", "dep:pollster"]
+wgpu = ["wgpu_no_default_features", "egui-wgpu/default"]
+
+## This is exactly like the `wgpu` feature, but does NOT enable the default features of `wgpu` and `egui-wgpu`.
+##
+## This means that no `wgpu` backends are enabled. You will need to enable them yourself, e.g. like this:
+##
+## ```toml
+## wgpu = { version = "*", features = ["dx12", "metal", "webgl"] }
+## ```
+wgpu_no_default_features = ["dep:wgpu", "dep:egui-wgpu", "dep:pollster"]
 
 ## Enables compiling for x11.
 x11 = [
@@ -121,10 +117,7 @@ x11 = [
 __screenshot = []
 
 [dependencies]
-egui = { workspace = true, default-features = false, features = [
-  "bytemuck",
-  "log",
-] }
+egui = { workspace = true, default-features = false, features = ["bytemuck"] }
 
 ahash.workspace = true
 document-features.workspace = true
@@ -132,7 +125,7 @@ log.workspace = true
 parking_lot.workspace = true
 profiling.workspace = true
 raw-window-handle.workspace = true
-static_assertions = "1.1.0"
+static_assertions.workspace = true
 web-time.workspace = true
 
 # Optional dependencies
@@ -145,45 +138,35 @@ serde = { workspace = true, optional = true }
 # -------------------------------------------
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-egui-winit = { workspace = true, default-features = false, features = [
-  "clipboard",
-  "links",
-] }
+egui-winit = { workspace = true, default-features = false, features = ["clipboard", "links"] }
 image = { workspace = true, features = ["png"] } # Needed for app icon
 winit = { workspace = true, default-features = false, features = ["rwh_06"] }
 
 # optional native:
 egui-wgpu = { workspace = true, optional = true, features = [
   "winit",
+  "capture",
 ] } # if wgpu is used, use it with winit
 pollster = { workspace = true, optional = true } # needed for wgpu
 
-glutin = { workspace = true, optional = true, default-features = false, features = [
-  "egl",
-  "wgl",
-] }
+glutin = { workspace = true, optional = true, default-features = false, features = ["egl", "wgl"] }
 glutin-winit = { workspace = true, optional = true, default-features = false, features = [
   "egl",
   "wgl",
 ] }
 home = { workspace = true, optional = true }
-wgpu = { workspace = true, optional = true, features = [
-  # Let's enable some backends so that users can use `eframe` out-of-the-box
-  # without having to explicitly opt-in to backends
-  "metal",
-  "webgpu",
-] }
+wgpu = { workspace = true, optional = true }
 
 # mac:
 [target.'cfg(any(target_os = "macos"))'.dependencies]
-objc2 = "0.5.1"
-objc2-foundation = { version = "0.2.0", default-features = false, features = [
+objc2.workspace = true
+objc2-foundation = { workspace = true, default-features = false, features = [
   "std",
   "block2",
   "NSData",
   "NSString",
 ] }
-objc2-app-kit = { version = "0.2.0", default-features = false, features = [
+objc2-app-kit = { workspace = true, default-features = false, features = [
   "std",
   "NSApplication",
   "NSImage",
@@ -194,11 +177,12 @@ objc2-app-kit = { version = "0.2.0", default-features = false, features = [
 
 # windows:
 [target.'cfg(any(target_os = "windows"))'.dependencies]
-winapi = { version = "0.3.9", features = ["winuser"] }
 windows-sys = { workspace = true, features = [
   "Win32_Foundation",
-  "Win32_UI_Shell",
   "Win32_System_Com",
+  "Win32_UI_Input_KeyboardAndMouse",
+  "Win32_UI_Shell",
+  "Win32_UI_WindowsAndMessaging",
 ] }
 
 # -------------------------------------------
@@ -206,8 +190,8 @@ windows-sys = { workspace = true, features = [
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 bytemuck.workspace = true
 image = { workspace = true, features = ["png"] } # For copying images
-js-sys = "0.3"
-percent-encoding = "2.1"
+js-sys.workspace = true
+percent-encoding.workspace = true
 wasm-bindgen.workspace = true
 wasm-bindgen-futures.workspace = true
 web-sys = { workspace = true, features = [
@@ -253,6 +237,7 @@ web-sys = { workspace = true, features = [
   "ResizeObserverEntry",
   "ResizeObserverOptions",
   "ResizeObserverSize",
+  "ShadowRoot",
   "Storage",
   "Touch",
   "TouchEvent",
@@ -266,13 +251,9 @@ web-sys = { workspace = true, features = [
 ] }
 
 # optional web:
-egui-wgpu = { workspace = true, optional = true } # if wgpu is used, use it without (!) winit
-wgpu = { workspace = true, optional = true, features = [
-  # Let's enable some backends so that users can use `eframe` out-of-the-box
-  # without having to explicitly opt-in to backends
-  "webgpu",
-] }
+egui-wgpu = { workspace = true, optional = true, features = ["capture"] } # if wgpu is used, use it without (!) winit
+wgpu = { workspace = true, optional = true }
 
 # Native dev dependencies for testing
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-directories = "5"
+directories.workspace = true
diff --git a/crates/eframe/README.md b/crates/eframe/README.md
index 5ffd427d0..9dbf42caf 100644
--- a/crates/eframe/README.md
+++ b/crates/eframe/README.md
@@ -7,7 +7,7 @@
 
 `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 (for Linux, Mac, Windows, and Android) or as a web app (using [Wasm](https://en.wikipedia.org/wiki/WebAssembly)).
 
-To get started, see the [examples](https://github.com/emilk/egui/tree/master/examples).
+To get started, see the [examples](https://github.com/emilk/egui/tree/main/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>.
@@ -16,7 +16,7 @@ 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).
+`eframe` uses [`egui_glow`](https://github.com/emilk/egui/tree/main/crates/egui_glow) for rendering, and on native it uses [`egui-winit`](https://github.com/emilk/egui/tree/main/crates/egui-winit).
 
 To use on Linux, first run:
 
@@ -24,14 +24,14 @@ 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 need to either use `edition = "2024"`, 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`.
+You can opt-in to the using [`egui-wgpu`](https://github.com/emilk/egui/tree/main/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>.
+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/main/crates/egui_glow/examples/pure_glow.rs>.
 
 
 ## Limitations when running egui on the web
diff --git a/crates/eframe/src/epi.rs b/crates/eframe/src/epi.rs
index a8db9ec9d..a7bcfd6ef 100644
--- a/crates/eframe/src/epi.rs
+++ b/crates/eframe/src/epi.rs
@@ -10,7 +10,7 @@
 use std::any::Any;
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 pub use crate::native::winit_integration::UserEvent;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -22,7 +22,7 @@ use raw_window_handle::{
 use static_assertions::assert_not_impl_any;
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 pub use winit::{event_loop::EventLoopBuilder, window::WindowAttributes};
 
 /// Hook into the building of an event loop before it is run
@@ -30,7 +30,7 @@ pub use winit::{event_loop::EventLoopBuilder, window::WindowAttributes};
 /// 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"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 pub type EventLoopBuilderHook = Box<dyn FnOnce(&mut EventLoopBuilder<UserEvent>)>;
 
 /// Hook into the building of a the native window.
@@ -38,7 +38,7 @@ pub type EventLoopBuilderHook = Box<dyn FnOnce(&mut EventLoopBuilder<UserEvent>)
 /// 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"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 pub type WindowBuilderHook = Box<dyn FnOnce(egui::ViewportBuilder) -> egui::ViewportBuilder>;
 
 type DynError = Box<dyn std::error::Error + Send + Sync>;
@@ -79,7 +79,7 @@ pub struct CreationContext<'s> {
     /// 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")]
+    #[cfg(feature = "wgpu_no_default_features")]
     pub wgpu_render_state: Option<egui_wgpu::RenderState>,
 
     /// Raw platform window handle
@@ -91,7 +91,7 @@ pub struct CreationContext<'s> {
     pub(crate) raw_display_handle: Result<RawDisplayHandle, HandleError>,
 }
 
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
 impl HasWindowHandle for CreationContext<'_> {
     fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
@@ -100,7 +100,7 @@ impl HasWindowHandle for CreationContext<'_> {
     }
 }
 
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
 impl HasDisplayHandle for CreationContext<'_> {
     fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
@@ -121,7 +121,7 @@ impl CreationContext<'_> {
             gl: None,
             #[cfg(feature = "glow")]
             get_proc_address: None,
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             wgpu_render_state: None,
             #[cfg(not(target_arch = "wasm32"))]
             raw_window_handle: Err(HandleError::NotSupported),
@@ -133,7 +133,7 @@ impl CreationContext<'_> {
 
 // ----------------------------------------------------------------------------
 
-/// 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).
+/// 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/main/crates/eframe).
 pub trait App {
     /// Called each time the UI needs repainting, which may be many times per second.
     ///
@@ -317,7 +317,7 @@ pub struct NativeOptions {
     pub hardware_acceleration: HardwareAcceleration,
 
     /// What rendering backend to use.
-    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
     pub renderer: Renderer,
 
     /// This controls what happens when you close the main eframe window.
@@ -340,7 +340,7 @@ pub struct NativeOptions {
     /// event loop before it is run.
     ///
     /// Note: A [`NativeOptions`] clone will not include any `event_loop_builder` hook.
-    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
     pub event_loop_builder: Option<EventLoopBuilderHook>,
 
     /// Hook into the building of a window.
@@ -349,7 +349,7 @@ pub struct NativeOptions {
     /// window appearance.
     ///
     /// Note: A [`NativeOptions`] clone will not include any `window_builder` hook.
-    #[cfg(any(feature = "glow", feature = "wgpu"))]
+    #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
     pub window_builder: Option<WindowBuilderHook>,
 
     #[cfg(feature = "glow")]
@@ -367,7 +367,7 @@ pub struct NativeOptions {
     pub centered: bool,
 
     /// Configures wgpu instance/device/adapter/surface creation and renderloop.
-    #[cfg(feature = "wgpu")]
+    #[cfg(feature = "wgpu_no_default_features")]
     pub wgpu_options: egui_wgpu::WgpuConfiguration,
 
     /// Controls whether or not the native window position and size will be
@@ -404,13 +404,13 @@ impl Clone for NativeOptions {
         Self {
             viewport: self.viewport.clone(),
 
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
             event_loop_builder: None, // Skip any builder callbacks if cloning
 
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
             window_builder: None, // Skip any builder callbacks if cloning
 
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             wgpu_options: self.wgpu_options.clone(),
 
             persistence_path: self.persistence_path.clone(),
@@ -435,15 +435,15 @@ impl Default for NativeOptions {
             stencil_buffer: 0,
             hardware_acceleration: HardwareAcceleration::Preferred,
 
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
             renderer: Renderer::default(),
 
             run_and_return: true,
 
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
             event_loop_builder: None,
 
-            #[cfg(any(feature = "glow", feature = "wgpu"))]
+            #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
             window_builder: None,
 
             #[cfg(feature = "glow")]
@@ -451,7 +451,7 @@ impl Default for NativeOptions {
 
             centered: false,
 
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             wgpu_options: egui_wgpu::WgpuConfiguration::default(),
 
             persist_window: true,
@@ -471,6 +471,10 @@ impl Default for NativeOptions {
 /// Options when using `eframe` in a web page.
 #[cfg(target_arch = "wasm32")]
 pub struct WebOptions {
+    /// What rendering backend to use.
+    #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+    pub renderer: Renderer,
+
     /// Sets the number of bits in the depth buffer.
     ///
     /// `egui` doesn't need the depth buffer, so the default value is 0.
@@ -484,7 +488,7 @@ pub struct WebOptions {
     pub webgl_context_option: WebGlContextOption,
 
     /// Configures wgpu instance/device/adapter/surface creation and renderloop.
-    #[cfg(feature = "wgpu")]
+    #[cfg(feature = "wgpu_no_default_features")]
     pub wgpu_options: egui_wgpu::WgpuConfiguration,
 
     /// Controls whether to apply dithering to minimize banding artifacts.
@@ -499,27 +503,43 @@ pub struct WebOptions {
     /// If the web event corresponding to an egui event should be propagated
     /// to the rest of the web page.
     ///
-    /// The default is `false`, meaning
+    /// The default is `true`, meaning
     /// [`stopPropagation`](https://developer.mozilla.org/en-US/docs/Web/API/Event/stopPropagation)
-    /// is called on every event.
-    pub should_propagate_event: Box<dyn Fn(&egui::Event) -> bool>,
+    /// is called on every event, and the event is not propagated to the rest of the web page.
+    pub should_stop_propagation: Box<dyn Fn(&egui::Event) -> bool>,
+
+    /// Whether the web event corresponding to an egui event should have `prevent_default` called
+    /// on it or not.
+    ///
+    /// Defaults to true.
+    pub should_prevent_default: Box<dyn Fn(&egui::Event) -> bool>,
+
+    /// Maximum rate at which to repaint. This can be used to artificially reduce the repaint rate below
+    /// vsync in order to save resources.
+    pub max_fps: Option<u32>,
 }
 
 #[cfg(target_arch = "wasm32")]
 impl Default for WebOptions {
     fn default() -> Self {
         Self {
+            #[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+            renderer: Renderer::default(),
+
             depth_buffer: 0,
 
             #[cfg(feature = "glow")]
             webgl_context_option: WebGlContextOption::BestFirst,
 
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             wgpu_options: egui_wgpu::WgpuConfiguration::default(),
 
             dithering: true,
 
-            should_propagate_event: Box::new(|_| false),
+            should_stop_propagation: Box::new(|_| true),
+            should_prevent_default: Box::new(|_| true),
+
+            max_fps: None,
         }
     }
 }
@@ -548,7 +568,7 @@ pub enum WebGlContextOption {
 /// What rendering backend to use.
 ///
 /// You need to enable the "glow" and "wgpu" features to have a choice.
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
@@ -558,47 +578,49 @@ pub enum Renderer {
     Glow,
 
     /// Use [`egui_wgpu`] renderer for [`wgpu`](https://github.com/gfx-rs/wgpu).
-    #[cfg(feature = "wgpu")]
+    #[cfg(feature = "wgpu_no_default_features")]
     Wgpu,
 }
 
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 impl Default for Renderer {
     fn default() -> Self {
         #[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(not(feature = "wgpu_no_default_features"))]
+        compile_error!(
+            "eframe: you must enable at least one of the rendering backend features: 'glow' or 'wgpu'"
+        );
 
         #[cfg(feature = "glow")]
-        #[cfg(not(feature = "wgpu"))]
+        #[cfg(not(feature = "wgpu_no_default_features"))]
         return Self::Glow;
 
         #[cfg(not(feature = "glow"))]
-        #[cfg(feature = "wgpu")]
+        #[cfg(feature = "wgpu_no_default_features")]
         return Self::Wgpu;
 
-        // By default, only the `glow` feature is enabled, so if the user added `wgpu` to the feature list
-        // they probably wanted to use wgpu:
+        // It's weird that the user has enabled both glow and wgpu,
+        // but let's pick the better of the two (wgpu):
         #[cfg(feature = "glow")]
-        #[cfg(feature = "wgpu")]
+        #[cfg(feature = "wgpu_no_default_features")]
         return Self::Wgpu;
     }
 }
 
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 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")]
+            #[cfg(feature = "wgpu_no_default_features")]
             Self::Wgpu => "wgpu".fmt(f),
         }
     }
 }
 
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 impl std::str::FromStr for Renderer {
     type Err = String;
 
@@ -607,10 +629,12 @@ impl std::str::FromStr for Renderer {
             #[cfg(feature = "glow")]
             "glow" => Ok(Self::Glow),
 
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             "wgpu" => Ok(Self::Wgpu),
 
-            _ => Err(format!("eframe renderer {name:?} is not available. Make sure that the corresponding eframe feature is enabled."))
+            _ => Err(format!(
+                "eframe renderer {name:?} is not available. Make sure that the corresponding eframe feature is enabled."
+            )),
         }
     }
 }
@@ -638,7 +662,7 @@ pub struct Frame {
         Option<Box<dyn FnMut(glow::Texture) -> egui::TextureId>>,
 
     /// Can be used to manage GPU resources for custom rendering with WGPU using [`egui::PaintCallback`]s.
-    #[cfg(feature = "wgpu")]
+    #[cfg(feature = "wgpu_no_default_features")]
     #[doc(hidden)]
     pub wgpu_render_state: Option<egui_wgpu::RenderState>,
 
@@ -655,7 +679,7 @@ pub struct Frame {
 #[cfg(not(target_arch = "wasm32"))]
 assert_not_impl_any!(Frame: Clone);
 
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
 impl HasWindowHandle for Frame {
     fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
@@ -664,7 +688,7 @@ impl HasWindowHandle for Frame {
     }
 }
 
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
 impl HasDisplayHandle for Frame {
     fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
@@ -688,7 +712,7 @@ impl Frame {
             #[cfg(not(target_arch = "wasm32"))]
             raw_window_handle: Err(HandleError::NotSupported),
             storage: None,
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             wgpu_render_state: None,
         }
     }
@@ -696,7 +720,7 @@ impl Frame {
     /// True if you are in a web environment.
     ///
     /// Equivalent to `cfg!(target_arch = "wasm32")`
-    #[allow(clippy::unused_self)]
+    #[expect(clippy::unused_self)]
     pub fn is_web(&self) -> bool {
         cfg!(target_arch = "wasm32")
     }
@@ -747,7 +771,7 @@ impl Frame {
     /// 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")]
+    #[cfg(feature = "wgpu_no_default_features")]
     pub fn wgpu_render_state(&self) -> Option<&egui_wgpu::RenderState> {
         self.wgpu_render_state.as_ref()
     }
@@ -882,16 +906,15 @@ pub trait Storage {
 #[cfg(feature = "ron")]
 pub fn get_value<T: serde::de::DeserializeOwned>(storage: &dyn Storage, key: &str) -> Option<T> {
     profiling::function_scope!(key);
-    storage
-        .get_string(key)
-        .and_then(|value| match ron::from_str(&value) {
-            Ok(value) => Some(value),
-            Err(err) => {
-                // This happens on when we break the format, e.g. when updating egui.
-                log::debug!("Failed to decode RON: {err}");
-                None
-            }
-        })
+    let value = storage.get_string(key)?;
+    match ron::from_str(&value) {
+        Ok(value) => Some(value),
+        Err(err) => {
+            // This happens on when we break the format, e.g. when updating egui.
+            log::debug!("Failed to decode RON: {err}");
+            None
+        }
+    }
 }
 
 /// Serialize the given value as [RON](https://github.com/ron-rs/ron) and store with the given key.
@@ -900,7 +923,7 @@ pub fn set_value<T: serde::Serialize>(storage: &mut dyn Storage, key: &str, valu
     profiling::function_scope!(key);
     match ron::ser::to_string(value) {
         Ok(string) => storage.set_string(key, string),
-        Err(err) => log::error!("eframe failed to encode data using ron: {}", err),
+        Err(err) => log::error!("eframe failed to encode data using ron: {err}"),
     }
 }
 
diff --git a/crates/eframe/src/lib.rs b/crates/eframe/src/lib.rs
index 7b342a4c2..d803a5249 100644
--- a/crates/eframe/src/lib.rs
+++ b/crates/eframe/src/lib.rs
@@ -3,7 +3,7 @@
 //! 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 get started, see the [examples](https://github.com/emilk/egui/tree/main/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
@@ -69,7 +69,7 @@
 //! #[wasm_bindgen]
 //! impl WebHandle {
 //!     /// Installs a panic hook, then returns.
-//!     #[allow(clippy::new_without_default)]
+//!     #[expect(clippy::new_without_default)]
 //!     #[wasm_bindgen(constructor)]
 //!     pub fn new() -> Self {
 //!         // Redirect [`log`] message to `console.log` and friends:
@@ -144,13 +144,22 @@
 #![warn(missing_docs)] // let's keep eframe well-documented
 #![allow(clippy::needless_doctest_main)]
 
+// Limitation imposed by `accesskit_winit`:
+// https://github.com/AccessKit/accesskit/tree/accesskit-v0.18.0/platforms/winit#android-activity-compatibility`
+#[cfg(all(
+    target_os = "android",
+    feature = "accesskit",
+    feature = "android-native-activity"
+))]
+compile_error!("`accesskit` feature is only available with `android-game-activity`");
+
 // Re-export all useful libraries:
 pub use {egui, egui::emath, egui::epaint};
 
 #[cfg(feature = "glow")]
 pub use {egui_glow, glow};
 
-#[cfg(feature = "wgpu")]
+#[cfg(feature = "wgpu_no_default_features")]
 pub use {egui_wgpu, wgpu};
 
 mod epi;
@@ -179,11 +188,19 @@ pub use web::{WebLogger, WebRunner};
 // When compiling natively
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 mod native;
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(any(feature = "glow", feature = "wgpu"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+pub use native::run::EframeWinitApplication;
+
+#[cfg(not(any(target_arch = "wasm32", target_os = "ios")))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+pub use native::run::EframePumpStatus;
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 #[cfg(feature = "persistence")]
 pub use native::file_storage::storage_dir;
 
@@ -192,7 +209,7 @@ pub mod icon_data;
 
 /// This is how you start a native (desktop) app.
 ///
-/// The first argument is name of your app, which is a an identifier
+/// The first argument is name of your app, which is an identifier
 /// used for the save location of persistence (see [`App::save`]).
 /// It is also used as the application id on wayland.
 /// If you set no title on the viewport, the app id will be used
@@ -235,13 +252,113 @@ pub mod icon_data;
 /// # 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)]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+#[allow(clippy::needless_pass_by_value, clippy::allow_attributes)]
 pub fn run_native(
     app_name: &str,
     mut native_options: NativeOptions,
     app_creator: AppCreator<'_>,
 ) -> Result {
+    let renderer = init_native(app_name, &mut native_options);
+
+    match renderer {
+        #[cfg(feature = "glow")]
+        Renderer::Glow => {
+            log::debug!("Using the glow renderer");
+            native::run::run_glow(app_name, native_options, app_creator)
+        }
+
+        #[cfg(feature = "wgpu_no_default_features")]
+        Renderer::Wgpu => {
+            log::debug!("Using the wgpu renderer");
+            native::run::run_wgpu(app_name, native_options, app_creator)
+        }
+    }
+}
+
+/// Provides a proxy for your native eframe application to run on your own event loop.
+///
+/// See `run_native` for details about `app_name`.
+///
+/// Call from `fn main` like this:
+/// ``` no_run
+/// use eframe::{egui, UserEvent};
+/// use winit::event_loop::{ControlFlow, EventLoop};
+///
+/// fn main() -> eframe::Result {
+///     let native_options = eframe::NativeOptions::default();
+///     let eventloop = EventLoop::<UserEvent>::with_user_event().build()?;
+///     eventloop.set_control_flow(ControlFlow::Poll);
+///
+///     let mut winit_app = eframe::create_native(
+///         "MyExtApp",
+///         native_options,
+///         Box::new(|cc| Ok(Box::new(MyEguiApp::new(cc)))),
+///         &eventloop,
+///     );
+///
+///     eventloop.run_app(&mut winit_app)?;
+///
+///     Ok(())
+/// }
+///
+/// #[derive(Default)]
+/// struct MyEguiApp {}
+///
+/// impl MyEguiApp {
+///     fn new(cc: &eframe::CreationContext<'_>) -> Self {
+///         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!");
+///        });
+///    }
+/// }
+/// ```
+///
+/// See the `external_eventloop` example for a more complete example.
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+pub fn create_native<'a>(
+    app_name: &str,
+    mut native_options: NativeOptions,
+    app_creator: AppCreator<'a>,
+    event_loop: &winit::event_loop::EventLoop<UserEvent>,
+) -> EframeWinitApplication<'a> {
+    let renderer = init_native(app_name, &mut native_options);
+
+    match renderer {
+        #[cfg(feature = "glow")]
+        Renderer::Glow => {
+            log::debug!("Using the glow renderer");
+            EframeWinitApplication::new(native::run::create_glow(
+                app_name,
+                native_options,
+                app_creator,
+                event_loop,
+            ))
+        }
+
+        #[cfg(feature = "wgpu_no_default_features")]
+        Renderer::Wgpu => {
+            log::debug!("Using the wgpu renderer");
+            EframeWinitApplication::new(native::run::create_wgpu(
+                app_name,
+                native_options,
+                app_creator,
+                event_loop,
+            ))
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
+fn init_native(app_name: &str, native_options: &mut NativeOptions) -> Renderer {
     #[cfg(not(feature = "__screenshot"))]
     assert!(
         std::env::var("EFRAME_SCREENSHOT_TO").is_err(),
@@ -254,28 +371,16 @@ pub fn run_native(
 
     let renderer = native_options.renderer;
 
-    #[cfg(all(feature = "glow", feature = "wgpu"))]
+    #[cfg(all(feature = "glow", feature = "wgpu_no_default_features"))]
     {
-        match renderer {
+        match native_options.renderer {
             Renderer::Glow => "glow",
             Renderer::Wgpu => "wgpu",
         };
         log::info!("Both the glow and wgpu renderers are available. Using {renderer}.");
     }
 
-    match renderer {
-        #[cfg(feature = "glow")]
-        Renderer::Glow => {
-            log::debug!("Using the glow renderer");
-            native::run::run_glow(app_name, native_options, app_creator)
-        }
-
-        #[cfg(feature = "wgpu")]
-        Renderer::Wgpu => {
-            log::debug!("Using the wgpu renderer");
-            native::run::run_wgpu(app_name, native_options, app_creator)
-        }
-    }
+    renderer
 }
 
 // ----------------------------------------------------------------------------
@@ -315,7 +420,7 @@ pub fn run_native(
 /// # 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"))]
+#[cfg(any(feature = "glow", feature = "wgpu_no_default_features"))]
 pub fn run_simple_native(
     app_name: &str,
     native_options: NativeOptions,
@@ -367,7 +472,7 @@ pub enum Error {
     OpenGL(egui_glow::PainterError),
 
     /// An error from [`wgpu`].
-    #[cfg(feature = "wgpu")]
+    #[cfg(feature = "wgpu_no_default_features")]
     Wgpu(egui_wgpu::WgpuError),
 }
 
@@ -405,7 +510,7 @@ impl From<egui_glow::PainterError> for Error {
     }
 }
 
-#[cfg(feature = "wgpu")]
+#[cfg(feature = "wgpu_no_default_features")]
 impl From<egui_wgpu::WgpuError> for Error {
     #[inline]
     fn from(err: egui_wgpu::WgpuError) -> Self {
@@ -446,7 +551,7 @@ impl std::fmt::Display for Error {
                 write!(f, "egui_glow: {err}")
             }
 
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             Self::Wgpu(err) => {
                 write!(f, "WGPU error: {err}")
             }
diff --git a/crates/eframe/src/native/app_icon.rs b/crates/eframe/src/native/app_icon.rs
index 8591ba2a8..233bf4c9d 100644
--- a/crates/eframe/src/native/app_icon.rs
+++ b/crates/eframe/src/native/app_icon.rs
@@ -14,10 +14,10 @@ pub struct AppTitleIconSetter {
 
 impl AppTitleIconSetter {
     pub fn new(title: String, mut icon_data: Option<Arc<IconData>>) -> Self {
-        if let Some(icon) = &icon_data {
-            if **icon == IconData::default() {
-                icon_data = None;
-            }
+        if let Some(icon) = &icon_data
+            && **icon == IconData::default()
+        {
+            icon_data = None;
         }
 
         Self {
@@ -47,7 +47,7 @@ enum AppIconStatus {
     NotSetTryAgain,
 
     /// We successfully set the icon and it should be visible now.
-    #[allow(dead_code)] // Not used on Linux
+    #[allow(dead_code, clippy::allow_attributes)] // Not used on Linux
     Set,
 }
 
@@ -71,16 +71,20 @@ fn set_title_and_icon(_title: &str, _icon_data: Option<&IconData>) -> AppIconSta
     #[cfg(target_os = "macos")]
     return set_title_and_icon_mac(_title, _icon_data);
 
-    #[allow(unreachable_code)]
+    #[allow(unreachable_code, clippy::allow_attributes)]
     AppIconStatus::NotSetIgnored
 }
 
 /// Set icon for Windows applications.
 #[cfg(target_os = "windows")]
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
     use crate::icon_data::IconDataExt as _;
-    use winapi::um::winuser;
+    use windows_sys::Win32::UI::Input::KeyboardAndMouse::GetActiveWindow;
+    use windows_sys::Win32::UI::WindowsAndMessaging::{
+        CreateIconFromResourceEx, GetSystemMetrics, HICON, ICON_BIG, ICON_SMALL, LR_DEFAULTCOLOR,
+        SM_CXICON, SM_CXSMICON, SendMessageW, WM_SETICON,
+    };
 
     // We would get fairly far already with winit's `set_window_icon` (which is exposed to eframe) actually!
     // However, it only sets ICON_SMALL, i.e. doesn't allow us to set a higher resolution icon for the task bar.
@@ -92,16 +96,13 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
     //      * using undocumented SetConsoleIcon method (successfully queried via GetProcAddress)
 
     // SAFETY: WinApi function without side-effects.
-    let window_handle = unsafe { winuser::GetActiveWindow() };
+    let window_handle = unsafe { GetActiveWindow() };
     if window_handle.is_null() {
         // The Window isn't available yet. Try again later!
         return AppIconStatus::NotSetTryAgain;
     }
 
-    fn create_hicon_with_scale(
-        unscaled_image: &image::RgbaImage,
-        target_size: i32,
-    ) -> winapi::shared::windef::HICON {
+    fn create_hicon_with_scale(unscaled_image: &image::RgbaImage, target_size: i32) -> HICON {
         let image_scaled = image::imageops::resize(
             unscaled_image,
             target_size as _,
@@ -127,14 +128,14 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
 
         // SAFETY: Creating an HICON which should be readonly on our data.
         unsafe {
-            winuser::CreateIconFromResourceEx(
+            CreateIconFromResourceEx(
                 image_scaled_bytes.as_mut_ptr(),
                 image_scaled_bytes.len() as u32,
                 1,           // Means this is an icon, not a cursor.
                 0x00030000,  // Version number of the HICON
                 target_size, // Note that this method can scale, but it does so *very* poorly. So let's avoid that!
                 target_size,
-                winuser::LR_DEFAULTCOLOR,
+                LR_DEFAULTCOLOR,
             )
         }
     }
@@ -155,7 +156,7 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
     // Note that ICON_SMALL may be used even if we don't render a title bar as it may be used in alt+tab!
     {
         // SAFETY: WinAPI getter function with no known side effects.
-        let icon_size_big = unsafe { winuser::GetSystemMetrics(winuser::SM_CXICON) };
+        let icon_size_big = unsafe { GetSystemMetrics(SM_CXICON) };
         let icon_big = create_hicon_with_scale(&unscaled_image, icon_size_big);
         if icon_big.is_null() {
             log::warn!("Failed to create HICON (for big icon) from embedded png data.");
@@ -163,10 +164,10 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
         } else {
             // SAFETY: Unsafe WinApi function, takes objects previously created with WinAPI, all checked for null prior.
             unsafe {
-                winuser::SendMessageW(
+                SendMessageW(
                     window_handle,
-                    winuser::WM_SETICON,
-                    winuser::ICON_BIG as usize,
+                    WM_SETICON,
+                    ICON_BIG as usize,
                     icon_big as isize,
                 );
             }
@@ -174,7 +175,7 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
     }
     {
         // SAFETY: WinAPI getter function with no known side effects.
-        let icon_size_small = unsafe { winuser::GetSystemMetrics(winuser::SM_CXSMICON) };
+        let icon_size_small = unsafe { GetSystemMetrics(SM_CXSMICON) };
         let icon_small = create_hicon_with_scale(&unscaled_image, icon_size_small);
         if icon_small.is_null() {
             log::warn!("Failed to create HICON (for small icon) from embedded png data.");
@@ -182,10 +183,10 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
         } else {
             // SAFETY: Unsafe WinApi function, takes objects previously created with WinAPI, all checked for null prior.
             unsafe {
-                winuser::SendMessageW(
+                SendMessageW(
                     window_handle,
-                    winuser::WM_SETICON,
-                    winuser::ICON_SMALL as usize,
+                    WM_SETICON,
+                    ICON_SMALL as usize,
                     icon_small as isize,
                 );
             }
@@ -198,20 +199,25 @@ fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
 
 /// Set icon & app title for `MacOS` applications.
 #[cfg(target_os = "macos")]
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 fn set_title_and_icon_mac(title: &str, icon_data: Option<&IconData>) -> AppIconStatus {
     use crate::icon_data::IconDataExt as _;
     profiling::function_scope!();
 
-    use objc2::ClassType;
+    use objc2::ClassType as _;
     use objc2_app_kit::{NSApplication, NSImage};
-    use objc2_foundation::{NSData, NSString};
+    use objc2_foundation::NSString;
 
-    let png_bytes = if let Some(icon_data) = icon_data {
-        match icon_data.to_png_bytes() {
-            Ok(png_bytes) => Some(png_bytes),
+    // Do NOT use png even though creating `NSImage` from it is much easier than from raw images data!
+    //
+    // Some MacOS versions have a bug where creating an `NSImage` from a png will cause it to load an arbitrary `libpng.dylib`.
+    // If this dylib isn't the right version, the application will crash with SIGBUS.
+    // For details see https://github.com/emilk/egui/issues/7155
+    let image = if let Some(icon_data) = icon_data {
+        match icon_data.to_image() {
+            Ok(image) => Some(image),
             Err(err) => {
-                log::warn!("Failed to convert IconData to png: {err}");
+                log::warn!("Failed to read icon data: {err}");
                 return AppIconStatus::NotSetIgnored;
             }
         }
@@ -220,7 +226,7 @@ fn set_title_and_icon_mac(title: &str, icon_data: Option<&IconData>) -> AppIconS
     };
 
     // TODO(madsmtm): Move this into `objc2-app-kit`
-    extern "C" {
+    unsafe extern "C" {
         static NSApp: Option<&'static NSApplication>;
     }
 
@@ -231,25 +237,50 @@ fn set_title_and_icon_mac(title: &str, icon_data: Option<&IconData>) -> AppIconS
             return AppIconStatus::NotSetIgnored;
         };
 
-        if let Some(png_bytes) = png_bytes {
-            let data = NSData::from_vec(png_bytes);
+        if let Some(image) = image {
+            use objc2_app_kit::{NSBitmapImageRep, NSDeviceRGBColorSpace};
+            use objc2_foundation::NSSize;
 
-            log::trace!("NSImage::initWithData…");
-            let app_icon = NSImage::initWithData(NSImage::alloc(), &data);
+            log::trace!(
+                "NSBitmapImageRep::initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel"
+            );
+            let Some(image_rep) = NSBitmapImageRep::initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(
+                NSBitmapImageRep::alloc(),
+                [image.as_raw().as_ptr().cast_mut()].as_mut_ptr(),
+                image.width() as isize,
+                image.height() as isize,
+                8, // bits per sample
+                4, // samples per pixel
+                true, // has alpha
+                false, // is not planar
+                NSDeviceRGBColorSpace,
+                (image.width() * 4) as isize, // bytes per row
+                32 // bits per pixel
+            ) else {
+                log::warn!("Failed to create NSBitmapImageRep from app icon data.");
+                return AppIconStatus::NotSetIgnored;
+            };
+
+            log::trace!("NSImage::initWithSize");
+            let app_icon = NSImage::initWithSize(
+                NSImage::alloc(),
+                NSSize::new(image.width() as f64, image.height() as f64),
+            );
+            log::trace!("NSImage::addRepresentation");
+            app_icon.addRepresentation(&image_rep);
 
             profiling::scope!("setApplicationIconImage_");
             log::trace!("setApplicationIconImage…");
-            app.setApplicationIconImage(app_icon.as_deref());
+            app.setApplicationIconImage(Some(&app_icon));
         }
 
         // Change the title in the top bar - for python processes this would be again "python" otherwise.
-        if let Some(main_menu) = app.mainMenu() {
-            if let Some(item) = main_menu.itemAtIndex(0) {
-                if let Some(app_menu) = item.submenu() {
-                    profiling::scope!("setTitle_");
-                    app_menu.setTitle(&NSString::from_str(title));
-                }
-            }
+        if let Some(main_menu) = app.mainMenu()
+            && let Some(item) = main_menu.itemAtIndex(0)
+            && let Some(app_menu) = item.submenu()
+        {
+            profiling::scope!("setTitle_");
+            app_menu.setTitle(&NSString::from_str(title));
         }
 
         // The title in the Dock apparently can't be changed.
diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
index 03b5f2dcd..447b3ea9d 100644
--- a/crates/eframe/src/native/epi_integration.rs
+++ b/crates/eframe/src/native/epi_integration.rs
@@ -52,14 +52,13 @@ pub fn viewport_builder(
             viewport_builder = viewport_builder.with_position(pos);
         }
 
-        if clamp_size_to_monitor_size {
-            if let Some(initial_window_size) = viewport_builder.inner_size {
-                let initial_window_size = egui::NumExt::at_most(
-                    initial_window_size,
-                    largest_monitor_point_size(egui_zoom_factor, event_loop),
-                );
-                viewport_builder = viewport_builder.with_inner_size(initial_window_size);
-            }
+        if clamp_size_to_monitor_size && let Some(initial_window_size) = viewport_builder.inner_size
+        {
+            let initial_window_size = egui::NumExt::at_most(
+                initial_window_size,
+                largest_monitor_point_size(egui_zoom_factor, event_loop),
+            );
+            viewport_builder = viewport_builder.with_inner_size(initial_window_size);
         }
 
         viewport_builder.inner_size
@@ -136,7 +135,7 @@ pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
     None
 }
 
-#[allow(clippy::unnecessary_wraps)]
+#[allow(clippy::allow_attributes, clippy::unnecessary_wraps)]
 pub fn create_storage_with_file(_file: impl Into<PathBuf>) -> Option<Box<dyn epi::Storage>> {
     #[cfg(feature = "persistence")]
     return Some(Box::new(
@@ -169,7 +168,7 @@ pub struct EpiIntegration {
 }
 
 impl EpiIntegration {
-    #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::allow_attributes, clippy::too_many_arguments)]
     pub fn new(
         egui_ctx: egui::Context,
         window: &winit::window::Window,
@@ -180,7 +179,9 @@ impl EpiIntegration {
         #[cfg(feature = "glow")] glow_register_native_texture: Option<
             Box<dyn FnMut(glow::Texture) -> egui::TextureId>,
         >,
-        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
+        #[cfg(feature = "wgpu_no_default_features")] wgpu_render_state: Option<
+            egui_wgpu::RenderState,
+        >,
     ) -> Self {
         let frame = epi::Frame {
             info: epi::IntegrationInfo { cpu_usage: None },
@@ -189,7 +190,7 @@ impl EpiIntegration {
             gl,
             #[cfg(feature = "glow")]
             glow_register_native_texture,
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             wgpu_render_state,
             raw_display_handle: window.display_handle().map(|h| h.as_raw()),
             raw_window_handle: window.window_handle().map(|h| h.as_raw()),
@@ -326,30 +327,32 @@ impl EpiIntegration {
         }
     }
 
-    #[allow(clippy::unused_self)]
-    pub fn save(&mut self, _app: &mut dyn epi::App, _window: Option<&winit::window::Window>) {
+    pub fn save(&mut self, app: &mut dyn epi::App, window: Option<&winit::window::Window>) {
+        #[cfg(not(feature = "persistence"))]
+        let _ = (self, app, window);
+
         #[cfg(feature = "persistence")]
         if let Some(storage) = self.frame.storage_mut() {
             profiling::function_scope!();
 
-            if let Some(window) = _window {
-                if self.persist_window {
-                    profiling::scope!("native_window");
-                    epi::set_value(
-                        storage,
-                        STORAGE_WINDOW_KEY,
-                        &WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
-                    );
-                }
+            if let Some(window) = window
+                && self.persist_window
+            {
+                profiling::scope!("native_window");
+                epi::set_value(
+                    storage,
+                    STORAGE_WINDOW_KEY,
+                    &WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
+                );
             }
-            if _app.persist_egui_memory() {
+            if app.persist_egui_memory() {
                 profiling::scope!("egui_memory");
                 self.egui_ctx
                     .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
             }
             {
                 profiling::scope!("App::save");
-                _app.save(storage);
+                app.save(storage);
             }
 
             profiling::scope!("Storage::flush");
diff --git a/crates/eframe/src/native/event_loop_context.rs b/crates/eframe/src/native/event_loop_context.rs
index f1262f853..810db8e1f 100644
--- a/crates/eframe/src/native/event_loop_context.rs
+++ b/crates/eframe/src/native/event_loop_context.rs
@@ -27,7 +27,7 @@ impl Drop for EventLoopGuard {
 }
 
 // Helper function to safely use the current event loop
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 pub fn with_current_event_loop<F, R>(f: F) -> Option<R>
 where
     F: FnOnce(&ActiveEventLoop) -> R,
diff --git a/crates/eframe/src/native/file_storage.rs b/crates/eframe/src/native/file_storage.rs
index 7fde2d288..f26a6df74 100644
--- a/crates/eframe/src/native/file_storage.rs
+++ b/crates/eframe/src/native/file_storage.rs
@@ -1,6 +1,6 @@
 use std::{
     collections::HashMap,
-    io::Write,
+    io::Write as _,
     path::{Path, PathBuf},
 };
 
@@ -42,20 +42,20 @@ pub fn storage_dir(app_id: &str) -> Option<PathBuf> {
 // Adapted from
 // https://github.com/rust-lang/cargo/blob/6e11c77384989726bb4f412a0e23b59c27222c34/crates/home/src/windows.rs#L19-L37
 #[cfg(all(windows, not(target_vendor = "uwp")))]
-#[allow(unsafe_code)]
+#[expect(unsafe_code)]
 fn roaming_appdata() -> Option<PathBuf> {
     use std::ffi::OsString;
-    use std::os::windows::ffi::OsStringExt;
+    use std::os::windows::ffi::OsStringExt as _;
     use std::ptr;
     use std::slice;
 
     use windows_sys::Win32::Foundation::S_OK;
     use windows_sys::Win32::System::Com::CoTaskMemFree;
     use windows_sys::Win32::UI::Shell::{
-        FOLDERID_RoamingAppData, SHGetKnownFolderPath, KF_FLAG_DONT_VERIFY,
+        FOLDERID_RoamingAppData, KF_FLAG_DONT_VERIFY, SHGetKnownFolderPath,
     };
 
-    extern "C" {
+    unsafe extern "C" {
         fn wcslen(buf: *const u16) -> usize;
     }
     let mut path_raw = ptr::null_mut();
@@ -72,7 +72,7 @@ fn roaming_appdata() -> Option<PathBuf> {
     };
 
     let path = if result == S_OK {
-        // SAFETY: SHGetKnownFolderPath indicated success and is supposed to allocate a nullterminated string for us.
+        // SAFETY: SHGetKnownFolderPath indicated success and is supposed to allocate a null-terminated string for us.
         let path_slice = unsafe { slice::from_raw_parts(path_raw, wcslen(path_raw)) };
         Some(PathBuf::from(OsString::from_wide(path_slice)))
     } else {
@@ -118,7 +118,7 @@ impl FileStorage {
     pub(crate) fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
         profiling::function_scope!();
         let ron_filepath: PathBuf = ron_filepath.into();
-        log::debug!("Loading app state from {:?}…", ron_filepath);
+        log::debug!("Loading app state from {}…", ron_filepath.display());
         Self {
             kv: read_ron(&ron_filepath).unwrap_or_default(),
             ron_filepath,
@@ -133,9 +133,8 @@ impl FileStorage {
         if let Some(data_dir) = storage_dir(app_id) {
             if let Err(err) = std::fs::create_dir_all(&data_dir) {
                 log::warn!(
-                    "Saving disabled: Failed to create app path at {:?}: {}",
-                    data_dir,
-                    err
+                    "Saving disabled: Failed to create app path at {}: {err}",
+                    data_dir.display()
                 );
                 None
             } else {
@@ -193,12 +192,11 @@ impl crate::Storage for FileStorage {
 fn save_to_disk(file_path: &PathBuf, kv: &HashMap<String, String>) {
     profiling::function_scope!();
 
-    if let Some(parent_dir) = file_path.parent() {
-        if !parent_dir.exists() {
-            if let Err(err) = std::fs::create_dir_all(parent_dir) {
-                log::warn!("Failed to create directory {parent_dir:?}: {err}");
-            }
-        }
+    if let Some(parent_dir) = file_path.parent()
+        && !parent_dir.exists()
+        && let Err(err) = std::fs::create_dir_all(parent_dir)
+    {
+        log::warn!("Failed to create directory {}: {err}", parent_dir.display());
     }
 
     match std::fs::File::create(file_path) {
@@ -207,16 +205,17 @@ fn save_to_disk(file_path: &PathBuf, kv: &HashMap<String, String>) {
             let config = Default::default();
 
             profiling::scope!("ron::serialize");
-            if let Err(err) = ron::ser::to_writer_pretty(&mut writer, &kv, config)
+            if let Err(err) = ron::Options::default()
+                .to_io_writer_pretty(&mut writer, &kv, config)
                 .and_then(|_| writer.flush().map_err(|err| err.into()))
             {
-                log::warn!("Failed to serialize app state: {}", err);
+                log::warn!("Failed to serialize app state: {err}");
             } else {
-                log::trace!("Persisted to {:?}", file_path);
+                log::trace!("Persisted to {}", file_path.display());
             }
         }
         Err(err) => {
-            log::warn!("Failed to create file {file_path:?}: {err}");
+            log::warn!("Failed to create file {}: {err}", file_path.display());
         }
     }
 }
@@ -234,7 +233,7 @@ where
             match ron::de::from_reader(reader) {
                 Ok(value) => Some(value),
                 Err(err) => {
-                    log::warn!("Failed to parse RON: {}", err);
+                    log::warn!("Failed to parse RON: {err}");
                     None
                 }
             }
diff --git a/crates/eframe/src/native/glow_integration.rs b/crates/eframe/src/native/glow_integration.rs
index 877245e22..c5358527a 100644
--- a/crates/eframe/src/native/glow_integration.rs
+++ b/crates/eframe/src/native/glow_integration.rs
@@ -11,34 +11,34 @@ use std::{cell::RefCell, num::NonZeroU32, rc::Rc, sync::Arc, time::Instant};
 
 use egui_winit::ActionRequested;
 use glutin::{
-    config::GlConfig,
-    context::NotCurrentGlContext,
-    display::GetGlDisplay,
-    prelude::{GlDisplay, PossiblyCurrentGlContext},
-    surface::GlSurface,
+    config::GlConfig as _,
+    context::NotCurrentGlContext as _,
+    display::GetGlDisplay as _,
+    prelude::{GlDisplay as _, PossiblyCurrentGlContext as _},
+    surface::GlSurface as _,
 };
-use raw_window_handle::HasWindowHandle;
+use raw_window_handle::HasWindowHandle as _;
 use winit::{
     event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
     window::{Window, WindowId},
 };
 
-use ahash::{HashMap, HashSet};
+use ahash::HashMap;
 use egui::{
-    DeferredViewportUiCallback, ImmediateViewport, ViewportBuilder, ViewportClass, ViewportId,
-    ViewportIdMap, ViewportIdPair, ViewportInfo, ViewportOutput,
+    DeferredViewportUiCallback, ImmediateViewport, OrderedViewportIdMap, ViewportBuilder,
+    ViewportClass, ViewportId, ViewportIdPair, ViewportInfo, ViewportOutput,
 };
 #[cfg(feature = "accesskit")]
 use egui_winit::accesskit_winit;
 
 use crate::{
-    native::epi_integration::EpiIntegration, App, AppCreator, CreationContext, NativeOptions,
-    Result, Storage,
+    App, AppCreator, CreationContext, NativeOptions, Result, Storage,
+    native::epi_integration::EpiIntegration,
 };
 
 use super::{
     epi_integration, event_loop_context,
-    winit_integration::{create_egui_context, EventResult, UserEvent, WinitApp},
+    winit_integration::{EventResult, UserEvent, WinitApp, create_egui_context},
 };
 
 // ----------------------------------------------------------------------------
@@ -94,9 +94,9 @@ struct GlutinWindowContext {
     current_gl_context: Option<glutin::context::PossiblyCurrentContext>,
     not_current_gl_context: Option<glutin::context::NotCurrentContext>,
 
-    viewports: ViewportIdMap<Viewport>,
+    viewports: OrderedViewportIdMap<Viewport>,
     viewport_from_window: HashMap<WindowId, ViewportId>,
-    window_from_viewport: ViewportIdMap<WindowId>,
+    window_from_viewport: OrderedViewportIdMap<WindowId>,
 
     focused_viewport: Option<ViewportId>,
 }
@@ -107,7 +107,7 @@ struct Viewport {
     builder: ViewportBuilder,
     deferred_commands: Vec<egui::viewport::ViewportCommand>,
     info: ViewportInfo,
-    actions_requested: HashSet<egui_winit::ActionRequested>,
+    actions_requested: Vec<egui_winit::ActionRequested>,
 
     /// The user-callback that shows the ui.
     /// None for immediate viewports.
@@ -139,7 +139,7 @@ impl<'app> GlowWinitApp<'app> {
         }
     }
 
-    #[allow(unsafe_code)]
+    #[expect(unsafe_code)]
     fn create_glutin_windowed_context(
         egui_ctx: &egui::Context,
         event_loop: &ActiveEventLoop,
@@ -239,7 +239,7 @@ impl<'app> GlowWinitApp<'app> {
                 let painter = painter.clone();
                 move |native| painter.borrow_mut().register_native_texture(native)
             })),
-            #[cfg(feature = "wgpu")]
+            #[cfg(feature = "wgpu_no_default_features")]
             None,
         );
 
@@ -272,7 +272,7 @@ impl<'app> GlowWinitApp<'app> {
                 ..
             } = viewport
             {
-                egui_winit.init_accesskit(window, event_loop_proxy);
+                egui_winit.init_accesskit(event_loop, window, event_loop_proxy);
             }
         }
 
@@ -281,10 +281,9 @@ impl<'app> GlowWinitApp<'app> {
             .viewport
             .mouse_passthrough
             .unwrap_or(false)
+            && let Err(err) = glutin.window(ViewportId::ROOT).set_cursor_hittest(false)
         {
-            if let Err(err) = glutin.window(ViewportId::ROOT).set_cursor_hittest(false) {
-                log::warn!("set_cursor_hittest(false) failed: {err}");
-            }
+            log::warn!("set_cursor_hittest(false) failed: {err}");
         }
 
         let app_creator = std::mem::take(&mut self.app_creator)
@@ -302,7 +301,7 @@ impl<'app> GlowWinitApp<'app> {
                 storage: integration.frame.storage(),
                 gl: Some(gl),
                 get_proc_address: Some(&get_proc_address),
-                #[cfg(feature = "wgpu")]
+                #[cfg(feature = "wgpu_no_default_features")]
                 wgpu_render_state: None,
                 raw_display_handle: window.display_handle().map(|h| h.as_raw()),
                 raw_window_handle: window.window_handle().map(|h| h.as_raw()),
@@ -336,10 +335,10 @@ impl<'app> GlowWinitApp<'app> {
         }
 
         Ok(self.running.insert(GlowWinitRunning {
-            glutin,
-            painter,
             integration,
             app,
+            glutin,
+            painter,
         }))
     }
 }
@@ -362,8 +361,12 @@ impl WinitApp for GlowWinitApp<'_> {
 
     fn window_id_from_viewport_id(&self, id: ViewportId) -> Option<WindowId> {
         self.running
-            .as_ref()
-            .and_then(|r| r.glutin.borrow().window_from_viewport.get(&id).copied())
+            .as_ref()?
+            .glutin
+            .borrow()
+            .window_from_viewport
+            .get(&id)
+            .copied()
     }
 
     fn save(&mut self) {
@@ -436,20 +439,20 @@ impl WinitApp for GlowWinitApp<'_> {
         _: winit::event::DeviceId,
         event: winit::event::DeviceEvent,
     ) -> crate::Result<EventResult> {
-        if let winit::event::DeviceEvent::MouseMotion { delta } = event {
-            if let Some(running) = &mut self.running {
-                let mut glutin = running.glutin.borrow_mut();
-                if let Some(viewport) = glutin
-                    .focused_viewport
-                    .and_then(|viewport| glutin.viewports.get_mut(&viewport))
-                {
-                    if let Some(egui_winit) = viewport.egui_winit.as_mut() {
-                        egui_winit.on_mouse_motion(delta);
-                    }
+        if let winit::event::DeviceEvent::MouseMotion { delta } = event
+            && let Some(running) = &mut self.running
+        {
+            let mut glutin = running.glutin.borrow_mut();
+            if let Some(viewport) = glutin
+                .focused_viewport
+                .and_then(|viewport| glutin.viewports.get_mut(&viewport))
+            {
+                if let Some(egui_winit) = viewport.egui_winit.as_mut() {
+                    egui_winit.on_mouse_motion(delta);
+                }
 
-                    if let Some(window) = viewport.window.as_ref() {
-                        return Ok(EventResult::RepaintNext(window.id()));
-                    }
+                if let Some(window) = viewport.window.as_ref() {
+                    return Ok(EventResult::RepaintNext(window.id()));
                 }
             }
         }
@@ -466,7 +469,7 @@ impl WinitApp for GlowWinitApp<'_> {
         if let Some(running) = &mut self.running {
             Ok(running.on_window_event(window_id, &event))
         } else {
-            Ok(EventResult::Wait)
+            Ok(EventResult::Exit)
         }
     }
 
@@ -476,16 +479,15 @@ impl WinitApp for GlowWinitApp<'_> {
 
         if let Some(running) = &self.running {
             let mut glutin = running.glutin.borrow_mut();
-            if let Some(viewport_id) = glutin.viewport_from_window.get(&event.window_id).copied() {
-                if let Some(viewport) = glutin.viewports.get_mut(&viewport_id) {
-                    if let Some(egui_winit) = &mut viewport.egui_winit {
-                        return Ok(winit_integration::on_accesskit_window_event(
-                            egui_winit,
-                            event.window_id,
-                            &event.window_event,
-                        ));
-                    }
-                }
+            if let Some(viewport_id) = glutin.viewport_from_window.get(&event.window_id).copied()
+                && let Some(viewport) = glutin.viewports.get_mut(&viewport_id)
+                && let Some(egui_winit) = &mut viewport.egui_winit
+            {
+                return Ok(winit_integration::on_accesskit_window_event(
+                    egui_winit,
+                    event.window_id,
+                    &event.window_event,
+                ));
             }
         }
 
@@ -523,10 +525,10 @@ impl GlowWinitRunning<'_> {
             if is_immediate && viewport_id != ViewportId::ROOT {
                 // This will only happen if this is an immediate viewport.
                 // That means that the viewport cannot be rendered by itself and needs his parent to be rendered.
-                if let Some(parent_viewport) = glutin.viewports.get(&viewport.ids.parent) {
-                    if let Some(window) = parent_viewport.window.as_ref() {
-                        return Ok(EventResult::RepaintNext(window.id()));
-                    }
+                if let Some(parent_viewport) = glutin.viewports.get(&viewport.ids.parent)
+                    && let Some(window) = parent_viewport.window.as_ref()
+                {
+                    return Ok(EventResult::RepaintNext(window.id()));
                 }
                 return Ok(EventResult::Wait);
             }
@@ -561,6 +563,12 @@ impl GlowWinitRunning<'_> {
             (raw_input, viewport_ui_cb)
         };
 
+        // HACK: In order to get the right clear_color, the system theme needs to be set, which
+        // usually only happens in the `update` call. So we call Options::begin_pass early
+        // to set the right theme. Without this there would be a black flash on the first frame.
+        self.integration
+            .egui_ctx
+            .options_mut(|opt| opt.begin_pass(&raw_input));
         let clear_color = self
             .app
             .clear_color(&self.integration.egui_ctx.style().visuals);
@@ -671,7 +679,7 @@ impl GlowWinitRunning<'_> {
         );
 
         {
-            for action in viewport.actions_requested.drain() {
+            for action in viewport.actions_requested.drain(..) {
                 match action {
                     ActionRequested::Screenshot(user_data) => {
                         let screenshot = painter.read_screen_rgba(screen_size_in_pixels);
@@ -723,10 +731,10 @@ impl GlowWinitRunning<'_> {
 
         // give it time to settle:
         #[cfg(feature = "__screenshot")]
-        if integration.egui_ctx.cumulative_pass_nr() == 2 {
-            if let Ok(path) = std::env::var("EFRAME_SCREENSHOT_TO") {
-                save_screenshot_and_exit(&path, &painter, screen_size_in_pixels);
-            }
+        if integration.egui_ctx.cumulative_pass_nr() == 2
+            && let Ok(path) = std::env::var("EFRAME_SCREENSHOT_TO")
+        {
+            save_screenshot_and_exit(&path, &painter, screen_size_in_pixels);
         }
 
         glutin.handle_viewport_output(event_loop, &integration.egui_ctx, &viewport_output);
@@ -743,7 +751,7 @@ impl GlowWinitRunning<'_> {
         }
 
         if integration.should_close() {
-            Ok(EventResult::Exit)
+            Ok(EventResult::CloseRequested)
         } else {
             Ok(EventResult::Wait)
         }
@@ -773,19 +781,33 @@ impl GlowWinitRunning<'_> {
         let mut repaint_asap = false;
 
         match event {
-            winit::event::WindowEvent::Focused(new_focused) => {
-                glutin.focused_viewport = new_focused.then(|| viewport_id).flatten();
+            winit::event::WindowEvent::Focused(focused) => {
+                let focused = if cfg!(target_os = "macos")
+                    && let Some(viewport_id) = viewport_id
+                    && let Some(viewport) = glutin.viewports.get(&viewport_id)
+                    && let Some(window) = &viewport.window
+                {
+                    // TODO(emilk): remove this work-around once we update winit
+                    // https://github.com/rust-windowing/winit/issues/4371
+                    // https://github.com/emilk/egui/issues/7588
+                    window.has_focus()
+                } else {
+                    *focused
+                };
+
+                glutin.focused_viewport = focused.then_some(viewport_id).flatten();
             }
 
             winit::event::WindowEvent::Resized(physical_size) => {
                 // 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 0 < physical_size.width && 0 < physical_size.height {
-                    if let Some(viewport_id) = viewport_id {
-                        repaint_asap = true;
-                        glutin.resize(viewport_id, *physical_size);
-                    }
+                if 0 < physical_size.width
+                    && 0 < physical_size.height
+                    && let Some(viewport_id) = viewport_id
+                {
+                    repaint_asap = true;
+                    glutin.resize(viewport_id, *physical_size);
                 }
             }
 
@@ -794,44 +816,31 @@ impl GlowWinitRunning<'_> {
                     log::debug!(
                         "Received WindowEvent::CloseRequested for main viewport - shutting down."
                     );
-                    return EventResult::Exit;
+                    return EventResult::CloseRequested;
                 }
 
                 log::debug!("Received WindowEvent::CloseRequested for viewport {viewport_id:?}");
 
-                if let Some(viewport_id) = viewport_id {
-                    if let Some(viewport) = glutin.viewports.get_mut(&viewport_id) {
-                        // Tell viewport it should close:
-                        viewport.info.events.push(egui::ViewportEvent::Close);
+                if let Some(viewport_id) = viewport_id
+                    && let Some(viewport) = glutin.viewports.get_mut(&viewport_id)
+                {
+                    // Tell viewport it should close:
+                    viewport.info.events.push(egui::ViewportEvent::Close);
 
-                        // We may need to repaint both us and our parent to close the window,
-                        // and perhaps twice (once to notice the close-event, once again to enforce it).
-                        // `request_repaint_of` does a double-repaint though:
-                        self.integration.egui_ctx.request_repaint_of(viewport_id);
-                        self.integration
-                            .egui_ctx
-                            .request_repaint_of(viewport.ids.parent);
-                    }
+                    // We may need to repaint both us and our parent to close the window,
+                    // and perhaps twice (once to notice the close-event, once again to enforce it).
+                    // `request_repaint_of` does a double-repaint though:
+                    self.integration.egui_ctx.request_repaint_of(viewport_id);
+                    self.integration
+                        .egui_ctx
+                        .request_repaint_of(viewport.ids.parent);
                 }
             }
-
-            winit::event::WindowEvent::Destroyed => {
-                log::debug!(
-                    "Received WindowEvent::Destroyed for viewport {:?}",
-                    viewport_id
-                );
-                if viewport_id == Some(ViewportId::ROOT) {
-                    return EventResult::Exit;
-                } else {
-                    return EventResult::Wait;
-                }
-            }
-
             _ => {}
         }
 
         if self.integration.should_close() {
-            return EventResult::Exit;
+            return EventResult::CloseRequested;
         }
 
         let mut event_response = egui_winit::EventResponse {
@@ -901,7 +910,7 @@ fn change_gl_context(
 }
 
 impl GlutinWindowContext {
-    #[allow(unsafe_code)]
+    #[expect(unsafe_code)]
     unsafe fn new(
         egui_ctx: &egui::Context,
         viewport_builder: ViewportBuilder,
@@ -959,7 +968,6 @@ impl GlutinWindowContext {
             .with_preference(glutin_winit::ApiPreference::FallbackEgl)
             .with_window_attributes(Some(egui_winit::create_winit_window_attributes(
                 egui_ctx,
-                event_loop,
                 viewport_builder.clone(),
             )));
 
@@ -1016,7 +1024,9 @@ impl GlutinWindowContext {
         let gl_context = match gl_context_result {
             Ok(it) => it,
             Err(err) => {
-                log::warn!("Failed to create context using default context attributes {context_attributes:?} due to error: {err}");
+                log::warn!(
+                    "Failed to create context using default context attributes {context_attributes:?} due to error: {err}"
+                );
                 log::debug!(
                     "Retrying with fallback context attributes: {fallback_context_attributes:?}"
                 );
@@ -1030,15 +1040,27 @@ impl GlutinWindowContext {
         let not_current_gl_context = Some(gl_context);
 
         let mut viewport_from_window = HashMap::default();
-        let mut window_from_viewport = ViewportIdMap::default();
-        let mut info = ViewportInfo::default();
+        let mut window_from_viewport = OrderedViewportIdMap::default();
+        let mut viewport_info = ViewportInfo::default();
         if let Some(window) = &window {
             viewport_from_window.insert(window.id(), ViewportId::ROOT);
             window_from_viewport.insert(ViewportId::ROOT, window.id());
-            egui_winit::update_viewport_info(&mut info, egui_ctx, window, true);
+            egui_winit::update_viewport_info(&mut viewport_info, egui_ctx, window, true);
+
+            // Tell egui right away about native_pixels_per_point etc,
+            // so that the app knows about it during app creation:
+            let pixels_per_point = egui_winit::pixels_per_point(egui_ctx, window);
+
+            egui_ctx.input_mut(|i| {
+                i.raw
+                    .viewports
+                    .insert(ViewportId::ROOT, viewport_info.clone());
+
+                i.pixels_per_point = pixels_per_point;
+            });
         }
 
-        let mut viewports = ViewportIdMap::default();
+        let mut viewports = OrderedViewportIdMap::default();
         viewports.insert(
             ViewportId::ROOT,
             Viewport {
@@ -1046,7 +1068,7 @@ impl GlutinWindowContext {
                 class: ViewportClass::Root,
                 builder: viewport_builder,
                 deferred_commands: vec![],
-                info,
+                info: viewport_info,
                 actions_requested: Default::default(),
                 viewport_ui_cb: None,
                 gl_surface: None,
@@ -1094,7 +1116,7 @@ impl GlutinWindowContext {
     }
 
     /// Create a surface, window, and winit integration for the viewport, if missing.
-    #[allow(unsafe_code)]
+    #[expect(unsafe_code)]
     pub(crate) fn initialize_window(
         &mut self,
         viewport_id: ViewportId,
@@ -1113,7 +1135,6 @@ impl GlutinWindowContext {
             log::debug!("Creating a window for viewport {viewport_id:?}");
             let window_attributes = egui_winit::create_winit_window_attributes(
                 &self.egui_ctx,
-                event_loop,
                 viewport.builder.clone(),
             );
             if window_attributes.transparent()
@@ -1241,21 +1262,21 @@ impl GlutinWindowContext {
         let width_px = NonZeroU32::new(physical_size.width).unwrap_or(NonZeroU32::MIN);
         let height_px = NonZeroU32::new(physical_size.height).unwrap_or(NonZeroU32::MIN);
 
-        if let Some(viewport) = self.viewports.get(&viewport_id) {
-            if let Some(gl_surface) = &viewport.gl_surface {
-                change_gl_context(
-                    &mut self.current_gl_context,
-                    &mut self.not_current_gl_context,
-                    gl_surface,
-                );
-                gl_surface.resize(
-                    self.current_gl_context
-                        .as_ref()
-                        .expect("failed to get current context to resize surface"),
-                    width_px,
-                    height_px,
-                );
-            }
+        if let Some(viewport) = self.viewports.get(&viewport_id)
+            && let Some(gl_surface) = &viewport.gl_surface
+        {
+            change_gl_context(
+                &mut self.current_gl_context,
+                &mut self.not_current_gl_context,
+                gl_surface,
+            );
+            gl_surface.resize(
+                self.current_gl_context
+                    .as_ref()
+                    .expect("failed to get current context to resize surface"),
+                width_px,
+                height_px,
+            );
         }
     }
 
@@ -1265,7 +1286,7 @@ impl GlutinWindowContext {
 
     pub(crate) fn remove_viewports_not_in(
         &mut self,
-        viewport_output: &ViewportIdMap<ViewportOutput>,
+        viewport_output: &OrderedViewportIdMap<ViewportOutput>,
     ) {
         // GC old viewports
         self.viewports
@@ -1280,7 +1301,7 @@ impl GlutinWindowContext {
         &mut self,
         event_loop: &ActiveEventLoop,
         egui_ctx: &egui::Context,
-        viewport_output: &ViewportIdMap<ViewportOutput>,
+        viewport_output: &OrderedViewportIdMap<ViewportOutput>,
     ) {
         profiling::function_scope!();
 
@@ -1337,7 +1358,7 @@ impl GlutinWindowContext {
 }
 
 fn initialize_or_update_viewport(
-    viewports: &mut ViewportIdMap<Viewport>,
+    viewports: &mut OrderedViewportIdMap<Viewport>,
     ids: ViewportIdPair,
     class: ViewportClass,
     mut builder: ViewportBuilder,
@@ -1345,6 +1366,8 @@ fn initialize_or_update_viewport(
 ) -> &mut Viewport {
     profiling::function_scope!();
 
+    use std::collections::btree_map::Entry;
+
     if builder.icon.is_none() {
         // Inherit icon from parent
         builder.icon = viewports
@@ -1353,7 +1376,7 @@ fn initialize_or_update_viewport(
     }
 
     match viewports.entry(ids.this) {
-        std::collections::hash_map::Entry::Vacant(entry) => {
+        Entry::Vacant(entry) => {
             // New viewport:
             log::debug!("Creating new viewport {:?} ({:?})", ids.this, builder.title);
             entry.insert(Viewport {
@@ -1370,7 +1393,7 @@ fn initialize_or_update_viewport(
             })
         }
 
-        std::collections::hash_map::Entry::Occupied(mut entry) => {
+        Entry::Occupied(mut entry) => {
             // Patch an existing viewport:
             let viewport = entry.get_mut();
 
@@ -1566,6 +1589,6 @@ fn save_screenshot_and_exit(
     });
     log::info!("Screenshot saved to {path:?}.");
 
-    #[allow(clippy::exit)]
+    #[expect(clippy::exit)]
     std::process::exit(0);
 }
diff --git a/crates/eframe/src/native/mod.rs b/crates/eframe/src/native/mod.rs
index cc0bfd7fc..eb9413717 100644
--- a/crates/eframe/src/native/mod.rs
+++ b/crates/eframe/src/native/mod.rs
@@ -12,5 +12,5 @@ pub(crate) mod winit_integration;
 #[cfg(feature = "glow")]
 mod glow_integration;
 
-#[cfg(feature = "wgpu")]
+#[cfg(feature = "wgpu_no_default_features")]
 mod wgpu_integration;
diff --git a/crates/eframe/src/native/run.rs b/crates/eframe/src/native/run.rs
index fb02ac439..7a3a8b4c4 100644
--- a/crates/eframe/src/native/run.rs
+++ b/crates/eframe/src/native/run.rs
@@ -10,9 +10,8 @@ use ahash::HashMap;
 
 use super::winit_integration::{UserEvent, WinitApp};
 use crate::{
-    epi,
+    Result, epi,
     native::{event_loop_context, winit_integration::EventResult},
-    Result,
 };
 
 // ----------------------------------------------------------------------------
@@ -93,48 +92,57 @@ impl<T: WinitApp> WinitAppWrapper<T> {
 
         log::trace!("event_result: {event_result:?}");
 
-        let combined_result = event_result.and_then(|event_result| {
-            match event_result {
-                EventResult::Wait => {
-                    event_loop.set_control_flow(ControlFlow::Wait);
-                    Ok(event_result)
-                }
-                EventResult::RepaintNow(window_id) => {
-                    log::trace!("RepaintNow of {window_id:?}",);
+        let mut event_result = event_result;
 
-                    if cfg!(target_os = "windows") {
-                        // Fix flickering on Windows, see https://github.com/emilk/egui/pull/2280
-                        self.winit_app.run_ui_and_paint(event_loop, window_id)
-                    } else {
-                        // Fix for https://github.com/emilk/egui/issues/2425
-                        self.windows_next_repaint_times
-                            .insert(window_id, Instant::now());
-                        Ok(event_result)
-                    }
-                }
-                EventResult::RepaintNext(window_id) => {
-                    log::trace!("RepaintNext of {window_id:?}",);
+        if cfg!(target_os = "windows")
+            && let Ok(EventResult::RepaintNow(window_id)) = event_result
+        {
+            log::trace!("RepaintNow of {window_id:?}");
+            self.windows_next_repaint_times
+                .insert(window_id, Instant::now());
+
+            // Fix flickering on Windows, see https://github.com/emilk/egui/pull/2280
+            event_result = self.winit_app.run_ui_and_paint(event_loop, window_id);
+        }
+
+        let combined_result = event_result.map(|event_result| match event_result {
+            EventResult::Wait => {
+                event_loop.set_control_flow(ControlFlow::Wait);
+                event_result
+            }
+            EventResult::RepaintNow(window_id) => {
+                log::trace!("RepaintNow of {window_id:?}",);
+                self.windows_next_repaint_times
+                    .insert(window_id, Instant::now());
+                event_result
+            }
+            EventResult::RepaintNext(window_id) => {
+                log::trace!("RepaintNext of {window_id:?}",);
+                self.windows_next_repaint_times
+                    .insert(window_id, Instant::now());
+                event_result
+            }
+            EventResult::RepaintAt(window_id, repaint_time) => {
+                self.windows_next_repaint_times.insert(
+                    window_id,
                     self.windows_next_repaint_times
-                        .insert(window_id, Instant::now());
-                    Ok(event_result)
-                }
-                EventResult::RepaintAt(window_id, repaint_time) => {
-                    self.windows_next_repaint_times.insert(
-                        window_id,
-                        self.windows_next_repaint_times
-                            .get(&window_id)
-                            .map_or(repaint_time, |last| (*last).min(repaint_time)),
-                    );
-                    Ok(event_result)
-                }
-                EventResult::Save => {
-                    save = true;
-                    Ok(event_result)
-                }
-                EventResult::Exit => {
-                    exit = true;
-                    Ok(event_result)
-                }
+                        .get(&window_id)
+                        .map_or(repaint_time, |last| (*last).min(repaint_time)),
+                );
+                event_result
+            }
+            EventResult::Save => {
+                save = true;
+                event_result
+            }
+            EventResult::Exit => {
+                exit = true;
+                event_result
+            }
+            EventResult::CloseRequested => {
+                // The windows need to be dropped whilst the event loop is running to allow for proper cleanup.
+                self.winit_app.save_and_destroy();
+                event_result
             }
         });
 
@@ -142,7 +150,7 @@ impl<T: WinitApp> WinitAppWrapper<T> {
             log::error!("Exiting because of error: {err}");
             exit = true;
             self.return_result = Err(err);
-        };
+        }
 
         if save {
             log::debug!("Received an EventResult::Save - saving app state");
@@ -159,7 +167,6 @@ impl<T: WinitApp> WinitAppWrapper<T> {
 
                 log::debug!("Exiting with return code 0");
 
-                #[allow(clippy::exit)]
                 std::process::exit(0);
             }
         }
@@ -174,7 +181,7 @@ impl<T: WinitApp> WinitAppWrapper<T> {
             .retain(|window_id, repaint_time| {
                 if now < *repaint_time {
                     return true; // not yet ready
-                };
+                }
 
                 event_loop.set_control_flow(ControlFlow::Poll);
 
@@ -190,7 +197,7 @@ impl<T: WinitApp> WinitAppWrapper<T> {
         let next_repaint_time = self.windows_next_repaint_times.values().min().copied();
         if let Some(next_repaint_time) = next_repaint_time {
             event_loop.set_control_flow(ControlFlow::WaitUntil(next_repaint_time));
-        };
+        }
     }
 }
 
@@ -313,7 +320,7 @@ impl<T: WinitApp> ApplicationHandler<UserEvent> for WinitAppWrapper<T> {
 
 #[cfg(not(target_os = "ios"))]
 fn run_and_return(event_loop: &mut EventLoop<UserEvent>, winit_app: impl WinitApp) -> Result {
-    use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
+    use winit::platform::run_on_demand::EventLoopExtRunOnDemand as _;
 
     log::trace!("Entering the winit event loop (run_app_on_demand)…");
 
@@ -359,9 +366,22 @@ pub fn run_glow(
     run_and_exit(event_loop, glow_eframe)
 }
 
+#[cfg(feature = "glow")]
+pub fn create_glow<'a>(
+    app_name: &str,
+    native_options: epi::NativeOptions,
+    app_creator: epi::AppCreator<'a>,
+    event_loop: &EventLoop<UserEvent>,
+) -> impl ApplicationHandler<UserEvent> + 'a {
+    use super::glow_integration::GlowWinitApp;
+
+    let glow_eframe = GlowWinitApp::new(event_loop, app_name, native_options, app_creator);
+    WinitAppWrapper::new(glow_eframe, true)
+}
+
 // ----------------------------------------------------------------------------
 
-#[cfg(feature = "wgpu")]
+#[cfg(feature = "wgpu_no_default_features")]
 pub fn run_wgpu(
     app_name: &str,
     mut native_options: epi::NativeOptions,
@@ -383,3 +403,120 @@ pub fn run_wgpu(
     let wgpu_eframe = WgpuWinitApp::new(&event_loop, app_name, native_options, app_creator);
     run_and_exit(event_loop, wgpu_eframe)
 }
+
+#[cfg(feature = "wgpu_no_default_features")]
+pub fn create_wgpu<'a>(
+    app_name: &str,
+    native_options: epi::NativeOptions,
+    app_creator: epi::AppCreator<'a>,
+    event_loop: &EventLoop<UserEvent>,
+) -> impl ApplicationHandler<UserEvent> + 'a {
+    use super::wgpu_integration::WgpuWinitApp;
+
+    let wgpu_eframe = WgpuWinitApp::new(event_loop, app_name, native_options, app_creator);
+    WinitAppWrapper::new(wgpu_eframe, true)
+}
+
+// ----------------------------------------------------------------------------
+
+/// A proxy to the eframe application that implements [`ApplicationHandler`].
+///
+/// This can be run directly on your own [`EventLoop`] by itself or with other
+/// windows you manage outside of eframe.
+pub struct EframeWinitApplication<'a> {
+    wrapper: Box<dyn ApplicationHandler<UserEvent> + 'a>,
+    control_flow: ControlFlow,
+}
+
+impl ApplicationHandler<UserEvent> for EframeWinitApplication<'_> {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        self.wrapper.resumed(event_loop);
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: winit::window::WindowId,
+        event: winit::event::WindowEvent,
+    ) {
+        self.wrapper.window_event(event_loop, window_id, event);
+    }
+
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: winit::event::StartCause) {
+        self.wrapper.new_events(event_loop, cause);
+    }
+
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
+        self.wrapper.user_event(event_loop, event);
+    }
+
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: winit::event::DeviceId,
+        event: winit::event::DeviceEvent,
+    ) {
+        self.wrapper.device_event(event_loop, device_id, event);
+    }
+
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        self.wrapper.about_to_wait(event_loop);
+        self.control_flow = event_loop.control_flow();
+    }
+
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        self.wrapper.suspended(event_loop);
+    }
+
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        self.wrapper.exiting(event_loop);
+    }
+
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        self.wrapper.memory_warning(event_loop);
+    }
+}
+
+impl<'a> EframeWinitApplication<'a> {
+    pub(crate) fn new<T: ApplicationHandler<UserEvent> + 'a>(app: T) -> Self {
+        Self {
+            wrapper: Box::new(app),
+            control_flow: ControlFlow::default(),
+        }
+    }
+
+    /// Pump the `EventLoop` to check for and dispatch pending events to this application.
+    ///
+    /// Returns either the exit code for the application or the final state of the [`ControlFlow`]
+    /// after all events have been dispatched in this iteration.
+    ///
+    /// This is useful when your [`EventLoop`] is not the main event loop for your application.
+    /// See the `external_eventloop_async` example.
+    #[cfg(not(target_os = "ios"))]
+    pub fn pump_eframe_app(
+        &mut self,
+        event_loop: &mut EventLoop<UserEvent>,
+        timeout: Option<std::time::Duration>,
+    ) -> EframePumpStatus {
+        use winit::platform::pump_events::{EventLoopExtPumpEvents as _, PumpStatus};
+
+        match event_loop.pump_app_events(timeout, self) {
+            PumpStatus::Continue => EframePumpStatus::Continue(self.control_flow),
+            PumpStatus::Exit(code) => EframePumpStatus::Exit(code),
+        }
+    }
+}
+
+/// Either an exit code or a [`ControlFlow`] from the [`ActiveEventLoop`].
+///
+/// The result of [`EframeWinitApplication::pump_eframe_app`].
+#[cfg(not(target_os = "ios"))]
+pub enum EframePumpStatus {
+    /// The final state of the [`ControlFlow`] after all events have been dispatched
+    ///
+    /// Callers should perform the action that is appropriate for the [`ControlFlow`] value.
+    Continue(ControlFlow),
+
+    /// The exit code for the application
+    Exit(i32),
+}
diff --git a/crates/eframe/src/native/wgpu_integration.rs b/crates/eframe/src/native/wgpu_integration.rs
index 0e0fcbf5d..c6c715c8c 100644
--- a/crates/eframe/src/native/wgpu_integration.rs
+++ b/crates/eframe/src/native/wgpu_integration.rs
@@ -15,18 +15,19 @@ use winit::{
     window::{Window, WindowId},
 };
 
-use ahash::{HashMap, HashSet, HashSetExt};
+use ahash::HashMap;
 use egui::{
-    DeferredViewportUiCallback, FullOutput, ImmediateViewport, ViewportBuilder, ViewportClass,
-    ViewportId, ViewportIdMap, ViewportIdPair, ViewportIdSet, ViewportInfo, ViewportOutput,
+    DeferredViewportUiCallback, FullOutput, ImmediateViewport, OrderedViewportIdMap,
+    ViewportBuilder, ViewportClass, ViewportId, ViewportIdPair, ViewportIdSet, ViewportInfo,
+    ViewportOutput,
 };
 #[cfg(feature = "accesskit")]
 use egui_winit::accesskit_winit;
 use winit_integration::UserEvent;
 
 use crate::{
-    native::{epi_integration::EpiIntegration, winit_integration::EventResult},
     App, AppCreator, CreationContext, NativeOptions, Result, Storage,
+    native::{epi_integration::EpiIntegration, winit_integration::EventResult},
 };
 
 use super::{epi_integration, event_loop_context, winit_integration, winit_integration::WinitApp};
@@ -70,9 +71,10 @@ pub struct SharedState {
     painter: egui_wgpu::winit::Painter,
     viewport_from_window: HashMap<WindowId, ViewportId>,
     focused_viewport: Option<ViewportId>,
+    resized_viewport: Option<ViewportId>,
 }
 
-pub type Viewports = ViewportIdMap<Viewport>;
+pub type Viewports = egui::OrderedViewportIdMap<Viewport>;
 
 pub struct Viewport {
     ids: ViewportIdPair,
@@ -80,7 +82,7 @@ pub struct Viewport {
     builder: ViewportBuilder,
     deferred_commands: Vec<egui::viewport::ViewportCommand>,
     info: ViewportInfo,
-    actions_requested: HashSet<ActionRequested>,
+    actions_requested: Vec<ActionRequested>,
 
     /// `None` for sync viewports.
     viewport_ui_cb: Option<Arc<DeferredViewportUiCallback>>,
@@ -182,19 +184,37 @@ impl<'app> WgpuWinitApp<'app> {
         builder: ViewportBuilder,
     ) -> crate::Result<&mut WgpuWinitRunning<'app>> {
         profiling::function_scope!();
-        #[allow(unsafe_code, unused_mut, unused_unsafe)]
         let mut painter = pollster::block_on(egui_wgpu::winit::Painter::new(
             egui_ctx.clone(),
             self.native_options.wgpu_options.clone(),
-            self.native_options.multisampling.max(1) as _,
-            egui_wgpu::depth_format_from_bits(
-                self.native_options.depth_buffer,
-                self.native_options.stencil_buffer,
-            ),
             self.native_options.viewport.transparent.unwrap_or(false),
-            self.native_options.dithering,
+            egui_wgpu::RendererOptions {
+                msaa_samples: self.native_options.multisampling as _,
+                depth_stencil_format: egui_wgpu::depth_format_from_bits(
+                    self.native_options.depth_buffer,
+                    self.native_options.stencil_buffer,
+                ),
+                dithering: self.native_options.dithering,
+                ..Default::default()
+            },
         ));
 
+        let mut viewport_info = ViewportInfo::default();
+        egui_winit::update_viewport_info(&mut viewport_info, &egui_ctx, &window, true);
+
+        {
+            // Tell egui right away about native_pixels_per_point etc,
+            // so that the app knows about it during app creation:
+            let pixels_per_point = egui_winit::pixels_per_point(&egui_ctx, &window);
+
+            egui_ctx.input_mut(|i| {
+                i.raw
+                    .viewports
+                    .insert(ViewportId::ROOT, viewport_info.clone());
+                i.pixels_per_point = pixels_per_point;
+            });
+        }
+
         let window = Arc::new(window);
 
         {
@@ -236,7 +256,7 @@ impl<'app> WgpuWinitApp<'app> {
             });
         }
 
-        #[allow(unused_mut)] // used for accesskit
+        #[allow(unused_mut, clippy::allow_attributes)] // used for accesskit
         let mut egui_winit = egui_winit::State::new(
             egui_ctx.clone(),
             ViewportId::ROOT,
@@ -249,7 +269,7 @@ impl<'app> WgpuWinitApp<'app> {
         #[cfg(feature = "accesskit")]
         {
             let event_loop_proxy = self.repaint_proxy.lock().clone();
-            egui_winit.init_accesskit(&window, event_loop_proxy);
+            egui_winit.init_accesskit(event_loop, &window, event_loop_proxy);
         }
 
         let app_creator = std::mem::take(&mut self.app_creator)
@@ -274,9 +294,6 @@ impl<'app> WgpuWinitApp<'app> {
         let mut viewport_from_window = HashMap::default();
         viewport_from_window.insert(window.id(), ViewportId::ROOT);
 
-        let mut info = ViewportInfo::default();
-        egui_winit::update_viewport_info(&mut info, &egui_ctx, &window, true);
-
         let mut viewports = Viewports::default();
         viewports.insert(
             ViewportId::ROOT,
@@ -285,7 +302,7 @@ impl<'app> WgpuWinitApp<'app> {
                 class: ViewportClass::Root,
                 builder,
                 deferred_commands: vec![],
-                info,
+                info: viewport_info,
                 actions_requested: Default::default(),
                 viewport_ui_cb: None,
                 window: Some(window),
@@ -299,6 +316,7 @@ impl<'app> WgpuWinitApp<'app> {
             viewports,
             painter,
             focused_viewport: Some(ViewportId::ROOT),
+            resized_viewport: None,
         }));
 
         {
@@ -333,10 +351,8 @@ impl WinitApp for WgpuWinitApp<'_> {
             .as_ref()
             .and_then(|r| {
                 let shared = r.shared.borrow();
-                shared
-                    .viewport_from_window
-                    .get(&window_id)
-                    .and_then(|id| shared.viewports.get(id).map(|v| v.window.clone()))
+                let id = shared.viewport_from_window.get(&window_id)?;
+                shared.viewports.get(id).map(|v| v.window.clone())
             })
             .flatten()
     }
@@ -431,20 +447,20 @@ impl WinitApp for WgpuWinitApp<'_> {
         _: winit::event::DeviceId,
         event: winit::event::DeviceEvent,
     ) -> crate::Result<EventResult> {
-        if let winit::event::DeviceEvent::MouseMotion { delta } = event {
-            if let Some(running) = &mut self.running {
-                let mut shared = running.shared.borrow_mut();
-                if let Some(viewport) = shared
-                    .focused_viewport
-                    .and_then(|viewport| shared.viewports.get_mut(&viewport))
-                {
-                    if let Some(egui_winit) = viewport.egui_winit.as_mut() {
-                        egui_winit.on_mouse_motion(delta);
-                    }
+        if let winit::event::DeviceEvent::MouseMotion { delta } = event
+            && let Some(running) = &mut self.running
+        {
+            let mut shared = running.shared.borrow_mut();
+            if let Some(viewport) = shared
+                .focused_viewport
+                .and_then(|viewport| shared.viewports.get_mut(&viewport))
+            {
+                if let Some(egui_winit) = viewport.egui_winit.as_mut() {
+                    egui_winit.on_mouse_motion(delta);
+                }
 
-                    if let Some(window) = viewport.window.as_ref() {
-                        return Ok(EventResult::RepaintNext(window.id()));
-                    }
+                if let Some(window) = viewport.window.as_ref() {
+                    return Ok(EventResult::RepaintNext(window.id()));
                 }
             }
         }
@@ -463,7 +479,8 @@ impl WinitApp for WgpuWinitApp<'_> {
         if let Some(running) = &mut self.running {
             Ok(running.on_window_event(window_id, &event))
         } else {
-            Ok(EventResult::Wait)
+            // running is removed to get ready for exiting
+            Ok(EventResult::Exit)
         }
     }
 
@@ -479,14 +496,13 @@ impl WinitApp for WgpuWinitApp<'_> {
             if let Some(viewport) = viewport_from_window
                 .get(&event.window_id)
                 .and_then(|id| viewports.get_mut(id))
+                && let Some(egui_winit) = &mut viewport.egui_winit
             {
-                if let Some(egui_winit) = &mut viewport.egui_winit {
-                    return Ok(winit_integration::on_accesskit_window_event(
-                        egui_winit,
-                        event.window_id,
-                        &event.window_event,
-                    ));
-                }
+                return Ok(winit_integration::on_accesskit_window_event(
+                    egui_winit,
+                    event.window_id,
+                    &event.window_event,
+                ));
             }
         }
 
@@ -564,10 +580,10 @@ impl WgpuWinitRunning<'_> {
                 if viewport.viewport_ui_cb.is_none() {
                     // This will only happen if this is an immediate viewport.
                     // That means that the viewport cannot be rendered by itself and needs his parent to be rendered.
-                    if let Some(viewport) = viewports.get(&viewport.ids.parent) {
-                        if let Some(window) = viewport.window.as_ref() {
-                            return Ok(EventResult::RepaintNext(window.id()));
-                        }
+                    if let Some(viewport) = viewports.get(&viewport.ids.parent)
+                        && let Some(window) = viewport.window.as_ref()
+                    {
+                        return Ok(EventResult::RepaintNext(window.id()));
                     }
                     return Ok(EventResult::Wait);
                 }
@@ -680,7 +696,7 @@ impl WgpuWinitRunning<'_> {
             screenshot_commands,
         );
 
-        for action in viewport.actions_requested.drain() {
+        for action in viewport.actions_requested.drain(..) {
             match action {
                 ActionRequested::Screenshot { .. } => {
                     // already handled above
@@ -731,17 +747,17 @@ impl WgpuWinitRunning<'_> {
 
         integration.maybe_autosave(app.as_mut(), window.map(|w| w.as_ref()));
 
-        if let Some(window) = window {
-            if window.is_minimized() == Some(true) {
-                // On Mac, a minimized Window uses up all CPU:
-                // https://github.com/emilk/egui/issues/325
-                profiling::scope!("minimized_sleep");
-                std::thread::sleep(std::time::Duration::from_millis(10));
-            }
+        if let Some(window) = window
+            && window.is_minimized() == Some(true)
+        {
+            // On Mac, a minimized Window uses up all CPU:
+            // https://github.com/emilk/egui/issues/325
+            profiling::scope!("minimized_sleep");
+            std::thread::sleep(std::time::Duration::from_millis(10));
         }
 
         if integration.should_close() {
-            Ok(EventResult::Exit)
+            Ok(EventResult::CloseRequested)
         } else {
             Ok(EventResult::Wait)
         }
@@ -762,37 +778,68 @@ impl WgpuWinitRunning<'_> {
         let viewport_id = shared.viewport_from_window.get(&window_id).copied();
 
         // 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.
+        // 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
+        // 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;
 
+        // On MacOS the asap repaint is not enough. The drawn frames must be synchronized with
+        // the CoreAnimation transactions driving the window resize process.
+        //
+        // Thus, Painter, responsible for wgpu surfaces and their resize, has to be notified of the
+        // resize lifecycle, yet winit does not provide any events for that. To work around,
+        // the last resized viewport is tracked until any next non-resize event is received.
+        //
+        // Accidental state change during the resize process due to an unexpected event fire
+        // is ok, state will switch back upon next resize event.
+        //
+        // See: https://github.com/emilk/egui/issues/903
+        if let Some(id) = viewport_id
+            && shared.resized_viewport == viewport_id
+        {
+            shared.painter.on_window_resize_state_change(id, false);
+            shared.resized_viewport = None;
+        }
+
         match event {
-            winit::event::WindowEvent::Focused(new_focused) => {
-                shared.focused_viewport = new_focused.then(|| viewport_id).flatten();
+            winit::event::WindowEvent::Focused(focused) => {
+                let focused = if cfg!(target_os = "macos")
+                    && let Some(viewport_id) = viewport_id
+                    && let Some(viewport) = shared.viewports.get(&viewport_id)
+                    && let Some(window) = &viewport.window
+                {
+                    // TODO(emilk): remove this work-around once we update winit
+                    // https://github.com/rust-windowing/winit/issues/4371
+                    // https://github.com/emilk/egui/issues/7588
+                    window.has_focus()
+                } else {
+                    *focused
+                };
+
+                shared.focused_viewport = focused.then_some(viewport_id).flatten();
             }
 
             winit::event::WindowEvent::Resized(physical_size) => {
                 // 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 let Some(viewport_id) = viewport_id {
-                    if let (Some(width), Some(height)) = (
+                if let Some(id) = viewport_id
+                    && let (Some(width), Some(height)) = (
                         NonZeroU32::new(physical_size.width),
                         NonZeroU32::new(physical_size.height),
-                    ) {
-                        repaint_asap = true;
-                        shared.painter.on_window_resized(viewport_id, width, height);
+                    )
+                {
+                    if shared.resized_viewport != viewport_id {
+                        shared.resized_viewport = viewport_id;
+                        shared.painter.on_window_resize_state_change(id, true);
                     }
+                    shared.painter.on_window_resized(id, width, height);
+                    repaint_asap = true;
                 }
             }
 
@@ -801,42 +848,41 @@ impl WgpuWinitRunning<'_> {
                     log::debug!(
                         "Received WindowEvent::CloseRequested for main viewport - shutting down."
                     );
-                    return EventResult::Exit;
+                    return EventResult::CloseRequested;
                 }
 
                 log::debug!("Received WindowEvent::CloseRequested for viewport {viewport_id:?}");
 
-                if let Some(viewport_id) = viewport_id {
-                    if let Some(viewport) = shared.viewports.get_mut(&viewport_id) {
-                        // Tell viewport it should close:
-                        viewport.info.events.push(egui::ViewportEvent::Close);
+                if let Some(viewport_id) = viewport_id
+                    && let Some(viewport) = shared.viewports.get_mut(&viewport_id)
+                {
+                    // Tell viewport it should close:
+                    viewport.info.events.push(egui::ViewportEvent::Close);
 
-                        // We may need to repaint both us and our parent to close the window,
-                        // and perhaps twice (once to notice the close-event, once again to enforce it).
-                        // `request_repaint_of` does a double-repaint though:
-                        integration.egui_ctx.request_repaint_of(viewport_id);
-                        integration.egui_ctx.request_repaint_of(viewport.ids.parent);
-                    }
+                    // We may need to repaint both us and our parent to close the window,
+                    // and perhaps twice (once to notice the close-event, once again to enforce it).
+                    // `request_repaint_of` does a double-repaint though:
+                    integration.egui_ctx.request_repaint_of(viewport_id);
+                    integration.egui_ctx.request_repaint_of(viewport.ids.parent);
                 }
             }
 
             _ => {}
-        };
+        }
 
         let event_response = viewport_id
             .and_then(|viewport_id| {
-                shared.viewports.get_mut(&viewport_id).and_then(|viewport| {
-                    Some(integration.on_window_event(
-                        viewport.window.as_deref()?,
-                        viewport.egui_winit.as_mut()?,
-                        event,
-                    ))
-                })
+                let viewport = shared.viewports.get_mut(&viewport_id)?;
+                Some(integration.on_window_event(
+                    viewport.window.as_deref()?,
+                    viewport.egui_winit.as_mut()?,
+                    event,
+                ))
             })
             .unwrap_or_default();
 
         if integration.should_close() {
-            EventResult::Exit
+            EventResult::CloseRequested
         } else if event_response.repaint {
             if repaint_asap {
                 EventResult::RepaintNow(window_id)
@@ -1035,10 +1081,10 @@ fn render_immediate_viewport(
 }
 
 pub(crate) fn remove_viewports_not_in(
-    viewports: &mut ViewportIdMap<Viewport>,
+    viewports: &mut Viewports,
     painter: &mut egui_wgpu::winit::Painter,
     viewport_from_window: &mut HashMap<WindowId, ViewportId>,
-    viewport_output: &ViewportIdMap<ViewportOutput>,
+    viewport_output: &OrderedViewportIdMap<ViewportOutput>,
 ) {
     let active_viewports_ids: ViewportIdSet = viewport_output.keys().copied().collect();
 
@@ -1051,8 +1097,8 @@ pub(crate) fn remove_viewports_not_in(
 /// Add new viewports, and update existing ones:
 fn handle_viewport_output(
     egui_ctx: &egui::Context,
-    viewport_output: &ViewportIdMap<ViewportOutput>,
-    viewports: &mut ViewportIdMap<Viewport>,
+    viewport_output: &OrderedViewportIdMap<ViewportOutput>,
+    viewports: &mut Viewports,
     painter: &mut egui_wgpu::winit::Painter,
     viewport_from_window: &mut HashMap<WindowId, ViewportId>,
 ) {
@@ -1089,13 +1135,13 @@ fn handle_viewport_output(
             // For Wayland : https://github.com/emilk/egui/issues/4196
             if cfg!(target_os = "linux") {
                 let new_inner_size = window.inner_size();
-                if new_inner_size != old_inner_size {
-                    if let (Some(width), Some(height)) = (
+                if new_inner_size != old_inner_size
+                    && let (Some(width), Some(height)) = (
                         NonZeroU32::new(new_inner_size.width),
                         NonZeroU32::new(new_inner_size.height),
-                    ) {
-                        painter.on_window_resized(viewport_id, width, height);
-                    }
+                    )
+                {
+                    painter.on_window_resized(viewport_id, width, height);
                 }
             }
         }
@@ -1112,6 +1158,8 @@ fn initialize_or_update_viewport<'a>(
     viewport_ui_cb: Option<Arc<dyn Fn(&egui::Context) + Send + Sync>>,
     painter: &mut egui_wgpu::winit::Painter,
 ) -> &'a mut Viewport {
+    use std::collections::btree_map::Entry;
+
     profiling::function_scope!();
 
     if builder.icon.is_none() {
@@ -1122,7 +1170,7 @@ fn initialize_or_update_viewport<'a>(
     }
 
     match viewports.entry(ids.this) {
-        std::collections::hash_map::Entry::Vacant(entry) => {
+        Entry::Vacant(entry) => {
             // New viewport:
             log::debug!("Creating new viewport {:?} ({:?})", ids.this, builder.title);
             entry.insert(Viewport {
@@ -1131,14 +1179,14 @@ fn initialize_or_update_viewport<'a>(
                 builder,
                 deferred_commands: vec![],
                 info: Default::default(),
-                actions_requested: HashSet::new(),
+                actions_requested: Vec::new(),
                 viewport_ui_cb,
                 window: None,
                 egui_winit: None,
             })
         }
 
-        std::collections::hash_map::Entry::Occupied(mut entry) => {
+        Entry::Occupied(mut entry) => {
             // Patch an existing viewport:
             let viewport = entry.get_mut();
 
diff --git a/crates/eframe/src/native/winit_integration.rs b/crates/eframe/src/native/winit_integration.rs
index d85443f37..2cf2e9019 100644
--- a/crates/eframe/src/native/winit_integration.rs
+++ b/crates/eframe/src/native/winit_integration.rs
@@ -124,6 +124,25 @@ pub enum EventResult {
     /// Causes a save of the client state when the persistence feature is enabled.
     Save,
 
+    /// Starts the process of ending eframe execution whilst allowing for proper
+    /// clean up of resources.
+    ///
+    /// # Warning
+    /// This event **must** occur before [`Exit`] to correctly exit eframe code.
+    /// If in doubt, return this event.
+    ///
+    /// [`Exit`]: [EventResult::Exit]
+    CloseRequested,
+
+    /// The event loop will exit, now.
+    /// The correct circumstance to return this event is in response to a winit "Destroyed" event.
+    ///
+    /// # Warning
+    /// The [`CloseRequested`] **must** occur before this event to ensure that winit
+    /// is able to remove any open windows. Otherwise the window(s) will remain open
+    /// until the program terminates.
+    ///
+    /// [`CloseRequested`]: EventResult::CloseRequested
     Exit,
 }
 
diff --git a/crates/eframe/src/stopwatch.rs b/crates/eframe/src/stopwatch.rs
index 9b0136189..e6eabcbdd 100644
--- a/crates/eframe/src/stopwatch.rs
+++ b/crates/eframe/src/stopwatch.rs
@@ -18,7 +18,7 @@ impl Stopwatch {
     }
 
     pub fn start(&mut self) {
-        assert!(self.start.is_none());
+        assert!(self.start.is_none(), "Stopwatch already running");
         self.start = Some(Instant::now());
     }
 
@@ -29,7 +29,7 @@ impl Stopwatch {
     }
 
     pub fn resume(&mut self) {
-        assert!(self.start.is_none());
+        assert!(self.start.is_none(), "Stopwatch still running");
         self.start = Some(Instant::now());
     }
 
diff --git a/crates/eframe/src/web/app_runner.rs b/crates/eframe/src/web/app_runner.rs
index 76ae1761f..8a10a90ef 100644
--- a/crates/eframe/src/web/app_runner.rs
+++ b/crates/eframe/src/web/app_runner.rs
@@ -1,15 +1,15 @@
 use egui::{TexturesDelta, UserData, ViewportCommand};
 
-use crate::{epi, App};
+use crate::{App, epi, web::web_painter::WebPainter};
 
-use super::{now_sec, text_agent::TextAgent, web_painter::WebPainter, NeedRepaint};
+use super::{NeedRepaint, now_sec, text_agent::TextAgent};
 
 pub struct AppRunner {
-    #[allow(dead_code)]
+    #[allow(dead_code, clippy::allow_attributes)]
     pub(crate) web_options: crate::WebOptions,
     pub(crate) frame: epi::Frame,
     egui_ctx: egui::Context,
-    painter: super::ActiveWebPainter,
+    painter: Box<dyn WebPainter>,
     pub(crate) input: super::WebInput,
     app: Box<dyn epi::App>,
     pub(crate) needs_repaint: std::sync::Arc<NeedRepaint>,
@@ -34,6 +34,10 @@ impl Drop for AppRunner {
 impl AppRunner {
     /// # Errors
     /// Failure to initialize WebGL renderer, or failure to create app.
+    #[cfg_attr(
+        not(feature = "wgpu_no_default_features"),
+        expect(clippy::unused_async)
+    )]
     pub async fn new(
         canvas: web_sys::HtmlCanvasElement,
         web_options: crate::WebOptions,
@@ -41,7 +45,41 @@ impl AppRunner {
         text_agent: TextAgent,
     ) -> Result<Self, String> {
         let egui_ctx = egui::Context::default();
-        let painter = super::ActiveWebPainter::new(egui_ctx.clone(), canvas, &web_options).await?;
+
+        #[allow(clippy::allow_attributes, unused_assignments)]
+        #[cfg(feature = "glow")]
+        let mut gl = None;
+
+        #[allow(clippy::allow_attributes, unused_assignments)]
+        #[cfg(feature = "wgpu_no_default_features")]
+        let mut wgpu_render_state = None;
+
+        let painter = match web_options.renderer {
+            #[cfg(feature = "glow")]
+            epi::Renderer::Glow => {
+                log::debug!("Using the glow renderer");
+                let painter = super::web_painter_glow::WebPainterGlow::new(
+                    egui_ctx.clone(),
+                    canvas,
+                    &web_options,
+                )?;
+                gl = Some(painter.gl().clone());
+                Box::new(painter) as Box<dyn WebPainter>
+            }
+
+            #[cfg(feature = "wgpu_no_default_features")]
+            epi::Renderer::Wgpu => {
+                log::debug!("Using the wgpu renderer");
+                let painter = super::web_painter_wgpu::WebPainterWgpu::new(
+                    egui_ctx.clone(),
+                    canvas,
+                    &web_options,
+                )
+                .await?;
+                wgpu_render_state = painter.render_state();
+                Box::new(painter) as Box<dyn WebPainter>
+            }
+        };
 
         let info = epi::IntegrationInfo {
             web_info: epi::WebInfo {
@@ -65,21 +103,27 @@ impl AppRunner {
             o.zoom_factor = 1.0;
         });
 
+        // Tell egui right away about native_pixels_per_point
+        // so that the app knows about it during app creation:
+        egui_ctx.input_mut(|i| {
+            let viewport_info = i.raw.viewports.entry(egui::ViewportId::ROOT).or_default();
+            viewport_info.native_pixels_per_point = Some(super::native_pixels_per_point());
+            i.pixels_per_point = super::native_pixels_per_point();
+        });
+
         let cc = epi::CreationContext {
             egui_ctx: egui_ctx.clone(),
             integration_info: info.clone(),
             storage: Some(&storage),
 
             #[cfg(feature = "glow")]
-            gl: Some(painter.gl().clone()),
+            gl: gl.clone(),
 
             #[cfg(feature = "glow")]
             get_proc_address: None,
 
-            #[cfg(all(feature = "wgpu", not(feature = "glow")))]
-            wgpu_render_state: painter.render_state(),
-            #[cfg(all(feature = "wgpu", feature = "glow"))]
-            wgpu_render_state: None,
+            #[cfg(feature = "wgpu_no_default_features")]
+            wgpu_render_state: wgpu_render_state.clone(),
         };
         let app = app_creator(&cc).map_err(|err| err.to_string())?;
 
@@ -88,15 +132,14 @@ impl AppRunner {
             storage: Some(Box::new(storage)),
 
             #[cfg(feature = "glow")]
-            gl: Some(painter.gl().clone()),
+            gl,
 
-            #[cfg(all(feature = "wgpu", not(feature = "glow")))]
-            wgpu_render_state: painter.render_state(),
-            #[cfg(all(feature = "wgpu", feature = "glow"))]
-            wgpu_render_state: None,
+            #[cfg(feature = "wgpu_no_default_features")]
+            wgpu_render_state,
         };
 
-        let needs_repaint: std::sync::Arc<NeedRepaint> = Default::default();
+        let needs_repaint: std::sync::Arc<NeedRepaint> =
+            std::sync::Arc::new(NeedRepaint::new(web_options.max_fps));
         {
             let needs_repaint = needs_repaint.clone();
             egui_ctx.set_request_repaint_callback(move |info| {
@@ -304,8 +347,6 @@ impl AppRunner {
     }
 
     fn handle_platform_output(&self, platform_output: egui::PlatformOutput) {
-        #![allow(deprecated)]
-
         #[cfg(feature = "web_screen_reader")]
         if self.egui_ctx.options(|o| o.screen_reader) {
             super::screen_reader::speak(&platform_output.events_description());
@@ -314,13 +355,10 @@ impl AppRunner {
         let egui::PlatformOutput {
             commands,
             cursor_icon,
-            open_url,
-            copied_text,
             events: _,                    // already handled
             mutable_text_under_cursor: _, // TODO(#4569): https://github.com/emilk/egui/issues/4569
             ime,
-            #[cfg(feature = "accesskit")]
-                accesskit_update: _, // not currently implemented
+            accesskit_update: _,        // not currently implemented
             num_completed_passes: _,    // handled by `Context::run`
             request_discard_reasons: _, // handled by `Context::run`
         } = platform_output;
@@ -341,14 +379,6 @@ impl AppRunner {
 
         super::set_cursor_icon(cursor_icon);
 
-        if let Some(open) = open_url {
-            super::open_url(&open.url, open.new_tab);
-        }
-
-        if !copied_text.is_empty() {
-            super::set_clipboard_text(&copied_text);
-        }
-
         if self.has_focus() {
             // The eframe app has focus.
             if ime.is_some() {
diff --git a/crates/eframe/src/web/backend.rs b/crates/eframe/src/web/backend.rs
index 5877f424c..4814fa99b 100644
--- a/crates/eframe/src/web/backend.rs
+++ b/crates/eframe/src/web/backend.rs
@@ -11,9 +11,15 @@ use super::percent_decode;
 /// Data gathered between frames.
 #[derive(Default)]
 pub(crate) struct WebInput {
-    /// Required because we don't get a position on touched
+    /// Required because we don't get a position on touchend
     pub primary_touch: Option<egui::TouchId>,
 
+    /// Helps to track the delta scale from gesture events
+    pub accumulated_scale: f32,
+
+    /// Helps to track the delta rotation from gesture events
+    pub accumulated_rotation: f32,
+
     /// The raw input to `egui`.
     pub raw: egui::RawInput,
 }
@@ -50,11 +56,20 @@ impl WebInput {
 // ----------------------------------------------------------------------------
 
 /// Stores when to do the next repaint.
-pub(crate) struct NeedRepaint(Mutex<f64>);
+pub(crate) struct NeedRepaint {
+    /// Time in seconds when the next repaint should happen.
+    next_repaint: Mutex<f64>,
 
-impl Default for NeedRepaint {
-    fn default() -> Self {
-        Self(Mutex::new(f64::NEG_INFINITY)) // start with a repaint
+    /// Rate limit for repaint. 0 means "unlimited". The rate may still be limited by vsync.
+    max_fps: u32,
+}
+
+impl NeedRepaint {
+    pub fn new(max_fps: Option<u32>) -> Self {
+        Self {
+            next_repaint: Mutex::new(f64::NEG_INFINITY), // start with a repaint
+            max_fps: max_fps.unwrap_or(0),
+        }
     }
 }
 
@@ -62,25 +77,43 @@ impl NeedRepaint {
     /// Returns the time (in [`now_sec`] scale) when
     /// we should next repaint.
     pub fn when_to_repaint(&self) -> f64 {
-        *self.0.lock()
+        *self.next_repaint.lock()
     }
 
     /// Unschedule repainting.
     pub fn clear(&self) {
-        *self.0.lock() = f64::INFINITY;
+        *self.next_repaint.lock() = f64::INFINITY;
     }
 
     pub fn repaint_after(&self, num_seconds: f64) {
-        let mut repaint_time = self.0.lock();
-        *repaint_time = repaint_time.min(super::now_sec() + num_seconds);
+        let mut time = super::now_sec() + num_seconds;
+        time = self.round_repaint_time_to_rate(time);
+        let mut repaint_time = self.next_repaint.lock();
+        *repaint_time = repaint_time.min(time);
+    }
+
+    /// Request a repaint. Depending on the presence of rate limiting, this may not be instant.
+    pub fn repaint(&self) {
+        let time = self.round_repaint_time_to_rate(super::now_sec());
+        let mut repaint_time = self.next_repaint.lock();
+        *repaint_time = repaint_time.min(time);
+    }
+
+    pub fn repaint_asap(&self) {
+        *self.next_repaint.lock() = f64::NEG_INFINITY;
     }
 
     pub fn needs_repaint(&self) -> bool {
         self.when_to_repaint() <= super::now_sec()
     }
 
-    pub fn repaint_asap(&self) {
-        *self.0.lock() = f64::NEG_INFINITY;
+    fn round_repaint_time_to_rate(&self, time: f64) -> f64 {
+        if self.max_fps == 0 {
+            time
+        } else {
+            let interval = 1.0 / self.max_fps as f64;
+            (time / interval).ceil() * interval
+        }
     }
 }
 
diff --git a/crates/eframe/src/web/events.rs b/crates/eframe/src/web/events.rs
index 762f202fa..c61a80012 100644
--- a/crates/eframe/src/web/events.rs
+++ b/crates/eframe/src/web/events.rs
@@ -1,15 +1,15 @@
-use web_sys::EventTarget;
-
 use crate::web::string_from_js_value;
 
 use super::{
-    button_from_mouse_event, location_hash, modifiers_from_kb_event, modifiers_from_mouse_event,
-    modifiers_from_wheel_event, native_pixels_per_point, pos_from_mouse_event,
-    prefers_color_scheme_dark, primary_touch_pos, push_touches, text_from_keyboard_event,
-    theme_from_dark_mode, translate_key, AppRunner, Closure, JsCast, JsValue, WebRunner,
-    DEBUG_RESIZE,
+    AppRunner, Closure, DEBUG_RESIZE, JsCast as _, JsValue, WebRunner, button_from_mouse_event,
+    location_hash, modifiers_from_kb_event, modifiers_from_mouse_event, modifiers_from_wheel_event,
+    native_pixels_per_point, pos_from_mouse_event, prefers_color_scheme, primary_touch_pos,
+    push_touches, text_from_keyboard_event, translate_key,
 };
 
+use js_sys::Reflect;
+use web_sys::{Document, EventTarget, ShadowRoot};
+
 // TODO(emilk): there are more calls to `prevent_default` and `stop_propagation`
 // than what is probably needed.
 
@@ -102,6 +102,7 @@ pub(crate) fn install_event_handlers(runner_ref: &WebRunner) -> Result<(), JsVal
     install_touchcancel(runner_ref, &canvas)?;
 
     install_wheel(runner_ref, &canvas)?;
+    install_gesture(runner_ref, &canvas)?;
     install_drag_and_drop(runner_ref, &canvas)?;
     install_window_events(runner_ref, &window)?;
     install_color_scheme_change_event(runner_ref, &window)?;
@@ -139,15 +140,20 @@ fn install_keydown(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), J
             {
                 if let Some(text) = text_from_keyboard_event(&event) {
                     let egui_event = egui::Event::Text(text);
-                    let should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+                    let should_stop_propagation =
+                        (runner.web_options.should_stop_propagation)(&egui_event);
+                    let should_prevent_default =
+                        (runner.web_options.should_prevent_default)(&egui_event);
                     runner.input.raw.events.push(egui_event);
                     runner.needs_repaint.repaint_asap();
 
                     // If this is indeed text, then prevent any other action.
-                    event.prevent_default();
+                    if should_prevent_default {
+                        event.prevent_default();
+                    }
 
                     // Use web options to tell if the event should be propagated to parent elements.
-                    if !should_propagate {
+                    if should_stop_propagation {
                         event.stop_propagation();
                     }
                 }
@@ -158,7 +164,7 @@ fn install_keydown(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), J
     )
 }
 
-#[allow(clippy::needless_pass_by_value)] // So that we can pass it directly to `add_event_listener`
+#[expect(clippy::needless_pass_by_value)] // So that we can pass it directly to `add_event_listener`
 pub(crate) fn on_keydown(event: web_sys::KeyboardEvent, runner: &mut AppRunner) {
     let has_focus = runner.input.raw.focused;
     if !has_focus {
@@ -184,7 +190,7 @@ pub(crate) fn on_keydown(event: web_sys::KeyboardEvent, runner: &mut AppRunner)
             repeat: false, // egui will fill this in for us!
             modifiers,
         };
-        let should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+        let should_stop_propagation = (runner.web_options.should_stop_propagation)(&egui_event);
         runner.input.raw.events.push(egui_event);
         runner.needs_repaint.repaint_asap();
 
@@ -201,7 +207,7 @@ pub(crate) fn on_keydown(event: web_sys::KeyboardEvent, runner: &mut AppRunner)
         }
 
         // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-        if !should_propagate {
+        if should_stop_propagation {
             event.stop_propagation();
         }
     }
@@ -221,9 +227,10 @@ fn should_prevent_default_for_key(
 
     // Prevent cmd/ctrl plus these keys from triggering the default browser action:
     let keys = [
-        egui::Key::O, // open
-        egui::Key::P, // print (cmd-P is common for command palette)
-        egui::Key::S, // save
+        egui::Key::Comma, // cmd-, opens options on macOS, which egui apps may wanna "steal"
+        egui::Key::O,     // open
+        egui::Key::P,     // print (cmd-P is common for command palette)
+        egui::Key::S,     // save
     ];
     for key in keys {
         if egui_key == key && (modifiers.ctrl || modifiers.command || modifiers.mac_cmd) {
@@ -256,12 +263,12 @@ fn install_keyup(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), JsV
     runner_ref.add_event_listener(target, "keyup", on_keyup)
 }
 
-#[allow(clippy::needless_pass_by_value)] // So that we can pass it directly to `add_event_listener`
+#[expect(clippy::needless_pass_by_value)] // So that we can pass it directly to `add_event_listener`
 pub(crate) fn on_keyup(event: web_sys::KeyboardEvent, runner: &mut AppRunner) {
     let modifiers = modifiers_from_kb_event(&event);
     runner.input.raw.modifiers = modifiers;
 
-    let mut propagate_event = false;
+    let mut should_stop_propagation = true;
 
     if let Some(key) = translate_key(&event.key()) {
         let egui_event = egui::Event::Key {
@@ -271,7 +278,7 @@ pub(crate) fn on_keyup(event: web_sys::KeyboardEvent, runner: &mut AppRunner) {
             repeat: false,
             modifiers,
         };
-        propagate_event |= (runner.web_options.should_propagate_event)(&egui_event);
+        should_stop_propagation &= (runner.web_options.should_stop_propagation)(&egui_event);
         runner.input.raw.events.push(egui_event);
     }
 
@@ -282,6 +289,8 @@ pub(crate) fn on_keyup(event: web_sys::KeyboardEvent, runner: &mut AppRunner) {
         // See https://github.com/emilk/egui/issues/4724
 
         let keys_down = runner.egui_ctx().input(|i| i.keys_down.clone());
+
+        #[expect(clippy::iter_over_hash_type)]
         for key in keys_down {
             let egui_event = egui::Event::Key {
                 key,
@@ -290,7 +299,7 @@ pub(crate) fn on_keyup(event: web_sys::KeyboardEvent, runner: &mut AppRunner) {
                 repeat: false,
                 modifiers,
             };
-            propagate_event |= (runner.web_options.should_propagate_event)(&egui_event);
+            should_stop_propagation &= (runner.web_options.should_stop_propagation)(&egui_event);
             runner.input.raw.events.push(egui_event);
         }
     }
@@ -299,70 +308,91 @@ pub(crate) fn on_keyup(event: web_sys::KeyboardEvent, runner: &mut AppRunner) {
 
     // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
     let has_focus = runner.input.raw.focused;
-    if has_focus && !propagate_event {
+    if has_focus && should_stop_propagation {
         event.stop_propagation();
     }
 }
 
 fn install_copy_cut_paste(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), JsValue> {
     runner_ref.add_event_listener(target, "paste", |event: web_sys::ClipboardEvent, runner| {
+        if !runner.input.raw.focused {
+            return; // The eframe app is not interested
+        }
+
         if let Some(data) = event.clipboard_data() {
             if let Ok(text) = data.get_data("text") {
                 let text = text.replace("\r\n", "\n");
 
-                let mut should_propagate = false;
-                if !text.is_empty() && runner.input.raw.focused {
+                let mut should_stop_propagation = true;
+                let mut should_prevent_default = true;
+                if !text.is_empty() {
                     let egui_event = egui::Event::Paste(text);
-                    should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+                    should_stop_propagation =
+                        (runner.web_options.should_stop_propagation)(&egui_event);
+                    should_prevent_default =
+                        (runner.web_options.should_prevent_default)(&egui_event);
                     runner.input.raw.events.push(egui_event);
                     runner.needs_repaint.repaint_asap();
                 }
 
                 // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-                if !should_propagate {
+                if should_stop_propagation {
                     event.stop_propagation();
                 }
-                event.prevent_default();
+
+                if should_prevent_default {
+                    event.prevent_default();
+                }
             }
         }
     })?;
 
     runner_ref.add_event_listener(target, "cut", |event: web_sys::ClipboardEvent, runner| {
-        if runner.input.raw.focused {
-            runner.input.raw.events.push(egui::Event::Cut);
-
-            // In Safari we are only allowed to write to the clipboard during the
-            // event callback, which is why we run the app logic here and now:
-            runner.logic();
-
-            // Make sure we paint the output of the above logic call asap:
-            runner.needs_repaint.repaint_asap();
+        if !runner.input.raw.focused {
+            return; // The eframe app is not interested
         }
 
+        runner.input.raw.events.push(egui::Event::Cut);
+
+        // In Safari we are only allowed to write to the clipboard during the
+        // event callback, which is why we run the app logic here and now:
+        runner.logic();
+
+        // Make sure we paint the output of the above logic call asap:
+        runner.needs_repaint.repaint_asap();
+
         // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-        if !(runner.web_options.should_propagate_event)(&egui::Event::Cut) {
+        if (runner.web_options.should_stop_propagation)(&egui::Event::Cut) {
             event.stop_propagation();
         }
-        event.prevent_default();
+
+        if (runner.web_options.should_prevent_default)(&egui::Event::Cut) {
+            event.prevent_default();
+        }
     })?;
 
     runner_ref.add_event_listener(target, "copy", |event: web_sys::ClipboardEvent, runner| {
-        if runner.input.raw.focused {
-            runner.input.raw.events.push(egui::Event::Copy);
-
-            // In Safari we are only allowed to write to the clipboard during the
-            // event callback, which is why we run the app logic here and now:
-            runner.logic();
-
-            // Make sure we paint the output of the above logic call asap:
-            runner.needs_repaint.repaint_asap();
+        if !runner.input.raw.focused {
+            return; // The eframe app is not interested
         }
 
+        runner.input.raw.events.push(egui::Event::Copy);
+
+        // In Safari we are only allowed to write to the clipboard during the
+        // event callback, which is why we run the app logic here and now:
+        runner.logic();
+
+        // Make sure we paint the output of the above logic call asap:
+        runner.needs_repaint.repaint_asap();
+
         // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-        if !(runner.web_options.should_propagate_event)(&egui::Event::Copy) {
+        if (runner.web_options.should_stop_propagation)(&egui::Event::Copy) {
             event.stop_propagation();
         }
-        event.prevent_default();
+
+        if (runner.web_options.should_prevent_default)(&egui::Event::Copy) {
+            event.prevent_default();
+        }
     })?;
 
     Ok(())
@@ -380,7 +410,7 @@ fn install_window_events(runner_ref: &WebRunner, window: &EventTarget) -> Result
 
     // No need to subscribe to "resize": we already subscribe to the canvas
     // size using a ResizeObserver, and we also subscribe to DPR changes of the monitor.
-    for event_name in &["load", "pagehide", "pageshow"] {
+    for event_name in &["load", "pagehide", "pageshow", "popstate"] {
         runner_ref.add_event_listener(window, event_name, move |_: web_sys::Event, runner| {
             if DEBUG_RESIZE {
                 log::debug!("{event_name:?}");
@@ -444,16 +474,19 @@ fn install_color_scheme_change_event(
     runner_ref: &WebRunner,
     window: &web_sys::Window,
 ) -> Result<(), JsValue> {
-    if let Some(media_query_list) = prefers_color_scheme_dark(window)? {
-        runner_ref.add_event_listener::<web_sys::MediaQueryListEvent>(
-            &media_query_list,
-            "change",
-            |event, runner| {
-                let theme = theme_from_dark_mode(event.matches());
-                runner.input.raw.system_theme = Some(theme);
-                runner.needs_repaint.repaint_asap();
-            },
-        )?;
+    for theme in [egui::Theme::Dark, egui::Theme::Light] {
+        if let Some(media_query_list) = prefers_color_scheme(window, theme)? {
+            runner_ref.add_event_listener::<web_sys::MediaQueryListEvent>(
+                &media_query_list,
+                "change",
+                |_event, runner| {
+                    if let Some(theme) = super::system_theme() {
+                        runner.input.raw.system_theme = Some(theme);
+                        runner.needs_repaint.repaint_asap();
+                    }
+                },
+            )?;
+        }
     }
 
     Ok(())
@@ -484,7 +517,7 @@ fn install_pointerdown(runner_ref: &WebRunner, target: &EventTarget) -> Result<(
         |event: web_sys::PointerEvent, runner: &mut AppRunner| {
             let modifiers = modifiers_from_mouse_event(&event);
             runner.input.raw.modifiers = modifiers;
-            let mut should_propagate = false;
+            let mut should_stop_propagation = true;
             if let Some(button) = button_from_mouse_event(&event) {
                 let pos = pos_from_mouse_event(runner.canvas(), &event, runner.egui_ctx());
                 let modifiers = runner.input.raw.modifiers;
@@ -494,7 +527,7 @@ fn install_pointerdown(runner_ref: &WebRunner, target: &EventTarget) -> Result<(
                     pressed: true,
                     modifiers,
                 };
-                should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+                should_stop_propagation = (runner.web_options.should_stop_propagation)(&egui_event);
                 runner.input.raw.events.push(egui_event);
 
                 // In Safari we are only allowed to write to the clipboard during the
@@ -506,7 +539,7 @@ fn install_pointerdown(runner_ref: &WebRunner, target: &EventTarget) -> Result<(
             }
 
             // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-            if !should_propagate {
+            if should_stop_propagation {
                 event.stop_propagation();
             }
             // Note: prevent_default breaks VSCode tab focusing, hence why we don't call it here.
@@ -536,7 +569,10 @@ fn install_pointerup(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
                         pressed: false,
                         modifiers,
                     };
-                    let should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+                    let should_stop_propagation =
+                        (runner.web_options.should_stop_propagation)(&egui_event);
+                    let should_prevent_default =
+                        (runner.web_options.should_prevent_default)(&egui_event);
                     runner.input.raw.events.push(egui_event);
 
                     // Previously on iOS, the canvas would not receive focus on
@@ -555,10 +591,12 @@ fn install_pointerup(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
                     // Make sure we paint the output of the above logic call asap:
                     runner.needs_repaint.repaint_asap();
 
-                    event.prevent_default();
+                    if should_prevent_default {
+                        event.prevent_default();
+                    }
 
                     // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-                    if !should_propagate {
+                    if should_stop_propagation {
                         event.stop_propagation();
                     }
                 }
@@ -570,10 +608,17 @@ fn install_pointerup(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
 /// Returns true if the cursor is above the canvas, or if we're dragging something.
 /// Pass in the position in browser viewport coordinates (usually event.clientX/Y).
 fn is_interested_in_pointer_event(runner: &AppRunner, pos: egui::Pos2) -> bool {
-    let document = web_sys::window().unwrap().document().unwrap();
-    let is_hovering_canvas = document
-        .element_from_point(pos.x, pos.y)
-        .is_some_and(|element| element.eq(runner.canvas()));
+    let root_node = runner.canvas().get_root_node();
+
+    let element_at_point = if let Some(document) = root_node.dyn_ref::<Document>() {
+        document.element_from_point(pos.x, pos.y)
+    } else if let Some(shadow) = root_node.dyn_ref::<ShadowRoot>() {
+        shadow.element_from_point(pos.x, pos.y)
+    } else {
+        None
+    };
+
+    let is_hovering_canvas = element_at_point.is_some_and(|element| element.eq(runner.canvas()));
     let is_pointer_down = runner
         .egui_ctx()
         .input(|i| i.pointer.any_down() || i.any_touches());
@@ -593,15 +638,19 @@ fn install_mousemove(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
             egui::pos2(event.client_x() as f32, event.client_y() as f32),
         ) {
             let egui_event = egui::Event::PointerMoved(pos);
-            let should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+            let should_stop_propagation = (runner.web_options.should_stop_propagation)(&egui_event);
+            let should_prevent_default = (runner.web_options.should_prevent_default)(&egui_event);
             runner.input.raw.events.push(egui_event);
-            runner.needs_repaint.repaint_asap();
+            runner.needs_repaint.repaint();
 
             // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-            if !should_propagate {
+            if should_stop_propagation {
                 event.stop_propagation();
             }
-            event.prevent_default();
+
+            if should_prevent_default {
+                event.prevent_default();
+            }
         }
     })
 }
@@ -615,10 +664,13 @@ fn install_mouseleave(runner_ref: &WebRunner, target: &EventTarget) -> Result<()
             runner.needs_repaint.repaint_asap();
 
             // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-            if !(runner.web_options.should_propagate_event)(&egui::Event::PointerGone) {
+            if (runner.web_options.should_stop_propagation)(&egui::Event::PointerGone) {
                 event.stop_propagation();
             }
-            event.prevent_default();
+
+            if (runner.web_options.should_prevent_default)(&egui::Event::PointerGone) {
+                event.prevent_default();
+            }
         },
     )
 }
@@ -628,7 +680,8 @@ fn install_touchstart(runner_ref: &WebRunner, target: &EventTarget) -> Result<()
         target,
         "touchstart",
         |event: web_sys::TouchEvent, runner| {
-            let mut should_propagate = false;
+            let mut should_stop_propagation = true;
+            let mut should_prevent_default = true;
             if let Some((pos, _)) = primary_touch_pos(runner, &event) {
                 let egui_event = egui::Event::PointerButton {
                     pos,
@@ -636,7 +689,8 @@ fn install_touchstart(runner_ref: &WebRunner, target: &EventTarget) -> Result<()
                     pressed: true,
                     modifiers: runner.input.raw.modifiers,
                 };
-                should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+                should_stop_propagation = (runner.web_options.should_stop_propagation)(&egui_event);
+                should_prevent_default = (runner.web_options.should_prevent_default)(&egui_event);
                 runner.input.raw.events.push(egui_event);
             }
 
@@ -644,10 +698,13 @@ fn install_touchstart(runner_ref: &WebRunner, target: &EventTarget) -> Result<()
             runner.needs_repaint.repaint_asap();
 
             // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-            if !should_propagate {
+            if should_stop_propagation {
                 event.stop_propagation();
             }
-            event.prevent_default();
+
+            if should_prevent_default {
+                event.prevent_default();
+            }
         },
     )
 }
@@ -660,17 +717,23 @@ fn install_touchmove(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
                 egui::pos2(touch.client_x() as f32, touch.client_y() as f32),
             ) {
                 let egui_event = egui::Event::PointerMoved(pos);
-                let should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+                let should_stop_propagation =
+                    (runner.web_options.should_stop_propagation)(&egui_event);
+                let should_prevent_default =
+                    (runner.web_options.should_prevent_default)(&egui_event);
                 runner.input.raw.events.push(egui_event);
 
                 push_touches(runner, egui::TouchPhase::Move, &event);
-                runner.needs_repaint.repaint_asap();
+                runner.needs_repaint.repaint();
 
                 // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-                if !should_propagate {
+                if should_stop_propagation {
                     event.stop_propagation();
                 }
-                event.prevent_default();
+
+                if should_prevent_default {
+                    event.prevent_default();
+                }
             }
         }
     })
@@ -684,18 +747,23 @@ fn install_touchend(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
                 egui::pos2(touch.client_x() as f32, touch.client_y() as f32),
             ) {
                 // First release mouse to click:
-                let mut should_propagate = false;
+                let mut should_stop_propagation = true;
+                let mut should_prevent_default = true;
                 let egui_event = egui::Event::PointerButton {
                     pos,
                     button: egui::PointerButton::Primary,
                     pressed: false,
                     modifiers: runner.input.raw.modifiers,
                 };
-                should_propagate |= (runner.web_options.should_propagate_event)(&egui_event);
+                should_stop_propagation &=
+                    (runner.web_options.should_stop_propagation)(&egui_event);
+                should_prevent_default &= (runner.web_options.should_prevent_default)(&egui_event);
                 runner.input.raw.events.push(egui_event);
                 // Then remove hover effect:
-                should_propagate |=
-                    (runner.web_options.should_propagate_event)(&egui::Event::PointerGone);
+                should_stop_propagation &=
+                    (runner.web_options.should_stop_propagation)(&egui::Event::PointerGone);
+                should_prevent_default &=
+                    (runner.web_options.should_prevent_default)(&egui::Event::PointerGone);
                 runner.input.raw.events.push(egui::Event::PointerGone);
 
                 push_touches(runner, egui::TouchPhase::End, &event);
@@ -703,10 +771,13 @@ fn install_touchend(runner_ref: &WebRunner, target: &EventTarget) -> Result<(),
                 runner.needs_repaint.repaint_asap();
 
                 // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-                if !should_propagate {
+                if should_stop_propagation {
                     event.stop_propagation();
                 }
-                event.prevent_default();
+
+                if should_prevent_default {
+                    event.prevent_default();
+                }
 
                 // Fix virtual keyboard IOS
                 // Need call focus at the same time of event
@@ -748,7 +819,7 @@ fn install_wheel(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), JsV
 
         let egui_event = if modifiers.ctrl && !runner.input.raw.modifiers.ctrl {
             // The browser is saying the ctrl key is down, but it isn't _really_.
-            // This happens on pinch-to-zoom on a Mac trackpad.
+            // This happens on pinch-to-zoom on multitouch trackpads
             // egui will treat ctrl+scroll as zoom, so it all works.
             // However, we explicitly handle it here in order to better match the pinch-to-zoom
             // speed of a native app, without being sensitive to egui's `scroll_zoom_speed` setting.
@@ -760,19 +831,91 @@ fn install_wheel(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), JsV
                 unit,
                 delta,
                 modifiers,
+                phase: egui::TouchPhase::Move,
             }
         };
-        let should_propagate = (runner.web_options.should_propagate_event)(&egui_event);
+        let should_stop_propagation = (runner.web_options.should_stop_propagation)(&egui_event);
+        let should_prevent_default = (runner.web_options.should_prevent_default)(&egui_event);
         runner.input.raw.events.push(egui_event);
 
+        runner.needs_repaint.repaint();
+
+        // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
+        if should_stop_propagation {
+            event.stop_propagation();
+        }
+
+        if should_prevent_default {
+            event.prevent_default();
+        }
+    })
+}
+
+fn install_gesture(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), JsValue> {
+    runner_ref.add_event_listener(target, "gesturestart", |event: web_sys::Event, runner| {
+        runner.input.accumulated_scale = 1.0;
+        runner.input.accumulated_rotation = 0.0;
+        handle_gesture(event, runner);
+    })?;
+    runner_ref.add_event_listener(target, "gesturechange", handle_gesture)?;
+    runner_ref.add_event_listener(target, "gestureend", |event: web_sys::Event, runner| {
+        handle_gesture(event, runner);
+        runner.input.accumulated_scale = 1.0;
+        runner.input.accumulated_rotation = 0.0;
+    })?;
+
+    Ok(())
+}
+
+#[expect(clippy::needless_pass_by_value)] // So that we can pass it directly to `add_event_listener`
+fn handle_gesture(event: web_sys::Event, runner: &mut AppRunner) {
+    // GestureEvent is a non-standard API, so this attempts to get the relevant fields if they exist.
+    let new_scale = Reflect::get(&event, &JsValue::from_str("scale"))
+        .ok()
+        .and_then(|scale| scale.as_f64())
+        .map_or(1.0, |scale| scale as f32);
+    let new_rotation = Reflect::get(&event, &JsValue::from_str("rotation"))
+        .ok()
+        .and_then(|rotation| rotation.as_f64())
+        .map_or(0.0, |rotation| rotation.to_radians() as f32);
+
+    let scale_delta = new_scale / runner.input.accumulated_scale;
+    let rotation_delta = new_rotation - runner.input.accumulated_rotation;
+    runner.input.accumulated_scale *= scale_delta;
+    runner.input.accumulated_rotation += rotation_delta;
+
+    let mut should_stop_propagation = true;
+    let mut should_prevent_default = true;
+
+    if scale_delta != 1.0 {
+        let zoom_event = egui::Event::Zoom(scale_delta);
+
+        should_stop_propagation &= (runner.web_options.should_stop_propagation)(&zoom_event);
+        should_prevent_default &= (runner.web_options.should_prevent_default)(&zoom_event);
+        runner.input.raw.events.push(zoom_event);
+    }
+
+    if rotation_delta != 0.0 {
+        let rotate_event = egui::Event::Rotate(rotation_delta);
+
+        should_stop_propagation &= (runner.web_options.should_stop_propagation)(&rotate_event);
+        should_prevent_default &= (runner.web_options.should_prevent_default)(&rotate_event);
+        runner.input.raw.events.push(rotate_event);
+    }
+
+    if scale_delta != 1.0 || rotation_delta != 0.0 {
         runner.needs_repaint.repaint_asap();
 
         // Use web options to tell if the web event should be propagated to parent elements based on the egui event.
-        if !should_propagate {
+        if should_stop_propagation {
             event.stop_propagation();
         }
-        event.prevent_default();
-    })
+
+        if should_prevent_default {
+            // Prevents a simulated ctrl-scroll event for zoom
+            event.prevent_default();
+        }
+    }
 }
 
 fn install_drag_and_drop(runner_ref: &WebRunner, target: &EventTarget) -> Result<(), JsValue> {
@@ -856,7 +999,10 @@ fn install_drag_and_drop(runner_ref: &WebRunner, target: &EventTarget) -> Result
                                         }
                                     }
                                     Err(err) => {
-                                        log::error!("Failed to read file: {:?}", err);
+                                        log::error!(
+                                            "Failed to read file: {}",
+                                            string_from_js_value(&err)
+                                        );
                                     }
                                 }
                             };
@@ -925,7 +1071,7 @@ impl ResizeObserverContext {
                     // we rely on the resize observer to trigger the first `request_animation_frame`:
                     if let Err(err) = runner_ref.request_animation_frame() {
                         log::error!("{}", super::string_from_js_value(&err));
-                    };
+                    }
                 } else {
                     log::warn!("ResizeObserverContext callback: failed to lock runner");
                 }
diff --git a/crates/eframe/src/web/input.rs b/crates/eframe/src/web/input.rs
index eecf7c1f5..c27897090 100644
--- a/crates/eframe/src/web/input.rs
+++ b/crates/eframe/src/web/input.rs
@@ -1,4 +1,4 @@
-use super::{canvas_content_rect, AppRunner};
+use super::{AppRunner, canvas_content_rect};
 
 pub fn pos_from_mouse_event(
     canvas: &web_sys::HtmlCanvasElement,
diff --git a/crates/eframe/src/web/mod.rs b/crates/eframe/src/web/mod.rs
index 3dc7d7f8b..ac4c637db 100644
--- a/crates/eframe/src/web/mod.rs
+++ b/crates/eframe/src/web/mod.rs
@@ -23,25 +23,22 @@ pub use panic_handler::{PanicHandler, PanicSummary};
 pub use web_logger::WebLogger;
 pub use web_runner::WebRunner;
 
-#[cfg(not(any(feature = "glow", feature = "wgpu")))]
+#[cfg(not(any(feature = "glow", feature = "wgpu_no_default_features")))]
 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")]
+#[cfg(feature = "wgpu_no_default_features")]
 mod web_painter_wgpu;
-#[cfg(all(feature = "wgpu", not(feature = "glow")))]
-pub(crate) type ActiveWebPainter = web_painter_wgpu::WebPainterWgpu;
 
 pub use backend::*;
 
+use egui::Theme;
 use wasm_bindgen::prelude::*;
-use web_sys::MediaQueryList;
+use web_sys::{Document, MediaQueryList, Node};
 
 use input::{
     button_from_mouse_event, modifiers_from_kb_event, modifiers_from_mouse_event,
@@ -64,18 +61,22 @@ pub(crate) fn string_from_js_value(value: &JsValue) -> String {
 /// - `<a>`/`<area>` with an `href` attribute
 /// - `<input>`/`<select>`/`<textarea>`/`<button>` which aren't `disabled`
 /// - any other element with a `tabindex` attribute
-pub(crate) fn focused_element() -> Option<web_sys::Element> {
-    web_sys::window()?
-        .document()?
-        .active_element()?
-        .dyn_into()
-        .ok()
+pub(crate) fn focused_element(root: &Node) -> Option<web_sys::Element> {
+    if let Some(document) = root.dyn_ref::<Document>() {
+        document.active_element()
+    } else if let Some(shadow) = root.dyn_ref::<web_sys::ShadowRoot>() {
+        shadow.active_element()
+    } else {
+        None
+    }
 }
 
 pub(crate) fn has_focus<T: JsCast>(element: &T) -> bool {
     fn try_has_focus<T: JsCast>(element: &T) -> Option<bool> {
         let element = element.dyn_ref::<web_sys::Element>()?;
-        let focused_element = focused_element()?;
+        let root = element.get_root_node();
+
+        let focused_element = focused_element(&root)?;
         Some(element == &focused_element)
     }
     try_has_focus(element).unwrap_or(false)
@@ -109,24 +110,31 @@ pub fn native_pixels_per_point() -> f32 {
 ///
 /// `None` means unknown.
 pub fn system_theme() -> Option<egui::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) -> egui::Theme {
-    if dark_mode {
-        egui::Theme::Dark
+    let window = web_sys::window()?;
+    if does_prefer_color_scheme(&window, Theme::Dark) == Some(true) {
+        Some(Theme::Dark)
+    } else if does_prefer_color_scheme(&window, Theme::Light) == Some(true) {
+        Some(Theme::Light)
     } else {
-        egui::Theme::Light
+        None
     }
 }
 
+fn does_prefer_color_scheme(window: &web_sys::Window, theme: Theme) -> Option<bool> {
+    Some(prefers_color_scheme(window, theme).ok()??.matches())
+}
+
+fn prefers_color_scheme(
+    window: &web_sys::Window,
+    theme: Theme,
+) -> Result<Option<MediaQueryList>, JsValue> {
+    let theme = match theme {
+        Theme::Dark => "dark",
+        Theme::Light => "light",
+    };
+    window.match_media(format!("(prefers-color-scheme: {theme})").as_str())
+}
+
 /// Returns the canvas in client coordinates.
 fn canvas_content_rect(canvas: &web_sys::HtmlCanvasElement) -> egui::Rect {
     let bounding_rect = canvas.get_bounding_client_rect();
@@ -277,7 +285,7 @@ fn create_clipboard_item(mime: &str, bytes: &[u8]) -> Result<web_sys::ClipboardI
     let items = js_sys::Object::new();
 
     // SAFETY: I hope so
-    #[allow(unsafe_code, unused_unsafe)] // Weird false positive
+    #[expect(unsafe_code, unused_unsafe)] // Weird false positive
     unsafe {
         js_sys::Reflect::set(&items, &JsValue::from_str(mime), &blob)?
     };
diff --git a/crates/eframe/src/web/text_agent.rs b/crates/eframe/src/web/text_agent.rs
index db47df2ae..ac917329f 100644
--- a/crates/eframe/src/web/text_agent.rs
+++ b/crates/eframe/src/web/text_agent.rs
@@ -4,6 +4,7 @@
 use std::cell::Cell;
 
 use wasm_bindgen::prelude::*;
+use web_sys::{Document, Node};
 
 use super::{AppRunner, WebRunner};
 
@@ -14,7 +15,7 @@ pub struct TextAgent {
 
 impl TextAgent {
     /// Attach the agent to the document.
-    pub fn attach(runner_ref: &WebRunner) -> Result<Self, JsValue> {
+    pub fn attach(runner_ref: &WebRunner, root: Node) -> Result<Self, JsValue> {
         let document = web_sys::window().unwrap().document().unwrap();
 
         // create an `<input>` element
@@ -37,7 +38,17 @@ impl TextAgent {
         style.set_property("position", "absolute")?;
         style.set_property("top", "0")?;
         style.set_property("left", "0")?;
-        document.body().unwrap().append_child(&input)?;
+
+        if root.has_type::<Document>() {
+            // root object is a document, append to its body
+            root.dyn_into::<Document>()?
+                .body()
+                .unwrap()
+                .append_child(&input)?;
+        } else {
+            // append input into root directly
+            root.append_child(&input)?;
+        }
 
         // attach event listeners
 
@@ -168,7 +179,7 @@ impl TextAgent {
 
         if let Err(err) = self.input.focus() {
             log::error!("failed to set focus: {}", super::string_from_js_value(&err));
-        };
+        }
     }
 
     pub fn blur(&self) {
@@ -180,7 +191,7 @@ impl TextAgent {
 
         if let Err(err) = self.input.blur() {
             log::error!("failed to set focus: {}", super::string_from_js_value(&err));
-        };
+        }
     }
 }
 
diff --git a/crates/eframe/src/web/web_logger.rs b/crates/eframe/src/web/web_logger.rs
index 650b2e530..01c347b7e 100644
--- a/crates/eframe/src/web/web_logger.rs
+++ b/crates/eframe/src/web/web_logger.rs
@@ -110,7 +110,7 @@ mod console {
 /// * `tokio-1.24.1/src/runtime/runtime.rs`
 /// * `rerun/src/main.rs`
 /// * `core/src/ops/function.rs`
-#[allow(dead_code)] // only used on web and in tests
+#[allow(dead_code, clippy::allow_attributes)] // only used on web and in tests
 fn shorten_file_path(file_path: &str) -> &str {
     if let Some(i) = file_path.rfind("/src/") {
         if let Some(prev_slash) = file_path[..i].rfind('/') {
@@ -126,12 +126,17 @@ fn shorten_file_path(file_path: &str) -> &str {
 #[test]
 fn test_shorten_file_path() {
     for (before, after) in [
-        ("/Users/emilk/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.24.1/src/runtime/runtime.rs", "tokio-1.24.1/src/runtime/runtime.rs"),
+        (
+            "/Users/emilk/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.24.1/src/runtime/runtime.rs",
+            "tokio-1.24.1/src/runtime/runtime.rs",
+        ),
         ("crates/rerun/src/main.rs", "rerun/src/main.rs"),
-        ("/rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/ops/function.rs", "core/src/ops/function.rs"),
+        (
+            "/rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/ops/function.rs",
+            "core/src/ops/function.rs",
+        ),
         ("/weird/path/file.rs", "/weird/path/file.rs"),
-        ]
-    {
+    ] {
         assert_eq!(shorten_file_path(before), after);
     }
 }
diff --git a/crates/eframe/src/web/web_painter_glow.rs b/crates/eframe/src/web/web_painter_glow.rs
index 876a6d78e..e2fc4a6f2 100644
--- a/crates/eframe/src/web/web_painter_glow.rs
+++ b/crates/eframe/src/web/web_painter_glow.rs
@@ -1,7 +1,7 @@
 use egui::{Event, UserData, ViewportId};
 use egui_glow::glow;
 use std::sync::Arc;
-use wasm_bindgen::JsCast;
+use wasm_bindgen::JsCast as _;
 use wasm_bindgen::JsValue;
 use web_sys::HtmlCanvasElement;
 
@@ -20,14 +20,15 @@ impl WebPainterGlow {
         self.painter.gl()
     }
 
-    pub async fn new(
+    pub fn new(
         _ctx: egui::Context,
         canvas: HtmlCanvasElement,
         options: &WebOptions,
     ) -> Result<Self, String> {
         let (gl, shader_prefix) =
             init_glow_context_from_canvas(&canvas, options.webgl_context_option)?;
-        #[allow(clippy::arc_with_non_send_sync)]
+
+        #[allow(clippy::arc_with_non_send_sync, clippy::allow_attributes)] // For wasm
         let gl = std::sync::Arc::new(gl);
 
         let painter = egui_glow::Painter::new(gl, shader_prefix, None, options.dithering)
diff --git a/crates/eframe/src/web/web_painter_wgpu.rs b/crates/eframe/src/web/web_painter_wgpu.rs
index f018c7316..efecd12ee 100644
--- a/crates/eframe/src/web/web_painter_wgpu.rs
+++ b/crates/eframe/src/web/web_painter_wgpu.rs
@@ -1,20 +1,22 @@
 use std::sync::Arc;
 
-use super::web_painter::WebPainter;
-use crate::WebOptions;
 use egui::{Event, UserData, ViewportId};
-use egui_wgpu::capture::{capture_channel, CaptureReceiver, CaptureSender, CaptureState};
-use egui_wgpu::{RenderState, SurfaceErrorAction};
+use egui_wgpu::{
+    RenderState, SurfaceErrorAction,
+    capture::{CaptureReceiver, CaptureSender, CaptureState, capture_channel},
+};
 use wasm_bindgen::JsValue;
 use web_sys::HtmlCanvasElement;
 
+use super::web_painter::WebPainter;
+
 pub(crate) struct WebPainterWgpu {
     canvas: HtmlCanvasElement,
     surface: wgpu::Surface<'static>,
     surface_configuration: wgpu::SurfaceConfiguration,
     render_state: Option<RenderState>,
     on_surface_error: Arc<dyn Fn(wgpu::SurfaceError) -> SurfaceErrorAction>,
-    depth_format: Option<wgpu::TextureFormat>,
+    depth_stencil_format: Option<wgpu::TextureFormat>,
     depth_texture_view: Option<wgpu::TextureView>,
     screen_capture_state: Option<CaptureState>,
     capture_tx: CaptureSender,
@@ -23,7 +25,6 @@ pub(crate) struct WebPainterWgpu {
 }
 
 impl WebPainterWgpu {
-    #[allow(unused)] // only used if `wgpu` is the only active feature.
     pub fn render_state(&self) -> Option<RenderState> {
         self.render_state.clone()
     }
@@ -35,7 +36,7 @@ impl WebPainterWgpu {
         height_in_pixels: u32,
     ) -> Option<wgpu::TextureView> {
         let device = &render_state.device;
-        self.depth_format.map(|depth_format| {
+        self.depth_stencil_format.map(|depth_stencil_format| {
             device
                 .create_texture(&wgpu::TextureDescriptor {
                     label: Some("egui_depth_texture"),
@@ -47,19 +48,18 @@ impl WebPainterWgpu {
                     mip_level_count: 1,
                     sample_count: 1,
                     dimension: wgpu::TextureDimension::D2,
-                    format: depth_format,
+                    format: depth_stencil_format,
                     usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-                    view_formats: &[depth_format],
+                    view_formats: &[depth_stencil_format],
                 })
                 .create_view(&wgpu::TextureViewDescriptor::default())
         })
     }
 
-    #[allow(unused)] // only used if `wgpu` is the only active feature.
     pub async fn new(
         ctx: egui::Context,
         canvas: web_sys::HtmlCanvasElement,
-        options: &WebOptions,
+        options: &crate::WebOptions,
     ) -> Result<Self, String> {
         log::debug!("Creating wgpu painter");
 
@@ -68,15 +68,17 @@ impl WebPainterWgpu {
             .create_surface(wgpu::SurfaceTarget::Canvas(canvas.clone()))
             .map_err(|err| format!("failed to create wgpu surface: {err}"))?;
 
-        let depth_format = egui_wgpu::depth_format_from_bits(options.depth_buffer, 0);
+        let depth_stencil_format = egui_wgpu::depth_format_from_bits(options.depth_buffer, 0);
 
         let render_state = RenderState::create(
             &options.wgpu_options,
             &instance,
             Some(&surface),
-            depth_format,
-            1,
-            options.dithering,
+            egui_wgpu::RendererOptions {
+                dithering: options.dithering,
+                depth_stencil_format,
+                ..Default::default()
+            },
         )
         .await
         .map_err(|err| err.to_string())?;
@@ -101,7 +103,7 @@ impl WebPainterWgpu {
             render_state: Some(render_state),
             surface,
             surface_configuration,
-            depth_format,
+            depth_stencil_format,
             depth_texture_view: None,
             on_surface_error: options.wgpu_options.on_surface_error.clone(),
             screen_capture_state: None,
@@ -236,6 +238,7 @@ impl WebPainter for WebPainterWgpu {
                             }),
                             store: wgpu::StoreOp::Store,
                         },
+                        depth_slice: None,
                     })],
                     depth_stencil_attachment: self.depth_texture_view.as_ref().map(|view| {
                         wgpu::RenderPassDepthStencilAttachment {
@@ -274,18 +277,11 @@ impl WebPainter for WebPainterWgpu {
                         &mut encoder,
                     ));
                 }
-            };
+            }
 
             Some((output_frame, capture_buffer))
         };
 
-        {
-            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
@@ -307,6 +303,16 @@ impl WebPainter for WebPainterWgpu {
             frame.present();
         }
 
+        // Free textures marked for destruction **after** queue submit since they might still be used in the current frame.
+        // Calling `wgpu::Texture::destroy` on a texture that is still in use would invalidate the command buffer(s) it is used in.
+        // However, once we called `wgpu::Queue::submit`, it is up for wgpu to determine how long the underlying gpu resource has to live.
+        {
+            let mut renderer = render_state.renderer.write();
+            for id in &textures_delta.free {
+                renderer.free_texture(id);
+            }
+        }
+
         Ok(())
     }
 
diff --git a/crates/eframe/src/web/web_runner.rs b/crates/eframe/src/web/web_runner.rs
index 9fea500bc..c9449ab99 100644
--- a/crates/eframe/src/web/web_runner.rs
+++ b/crates/eframe/src/web/web_runner.rs
@@ -2,12 +2,12 @@ use std::{cell::RefCell, rc::Rc};
 
 use wasm_bindgen::prelude::*;
 
-use crate::{epi, App};
+use crate::{App, epi};
 
 use super::{
+    AppRunner, PanicHandler,
     events::{self, ResizeObserverContext},
     text_agent::TextAgent,
-    AppRunner, PanicHandler,
 };
 
 /// This is how `eframe` runs your web application
@@ -37,7 +37,7 @@ pub struct WebRunner {
 
 impl WebRunner {
     /// Will install a panic handler that will catch and log any panics
-    #[allow(clippy::new_without_default)]
+    #[expect(clippy::new_without_default)]
     pub fn new() -> Self {
         let panic_handler = PanicHandler::install();
 
@@ -73,7 +73,7 @@ impl WebRunner {
 
         {
             // First set up the app runner:
-            let text_agent = TextAgent::attach(self)?;
+            let text_agent = TextAgent::attach(self, canvas.get_root_node())?;
             let app_runner =
                 AppRunner::new(canvas.clone(), web_options, app_creator, text_agent).await?;
             self.app_runner.replace(Some(app_runner));
@@ -280,7 +280,7 @@ struct TargetEvent {
     closure: Closure<dyn FnMut(web_sys::Event)>,
 }
 
-#[allow(unused)]
+#[expect(unused)]
 struct IntervalHandle {
     handle: i32,
     closure: Closure<dyn FnMut()>,
@@ -289,7 +289,7 @@ struct IntervalHandle {
 enum EventToUnsubscribe {
     TargetEvent(TargetEvent),
 
-    #[allow(unused)]
+    #[expect(unused)]
     IntervalHandle(IntervalHandle),
 }
 
diff --git a/crates/egui-wgpu/CHANGELOG.md b/crates/egui-wgpu/CHANGELOG.md
index a20cafa14..be00dd049 100644
--- a/crates/egui-wgpu/CHANGELOG.md
+++ b/crates/egui-wgpu/CHANGELOG.md
@@ -6,6 +6,42 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+* Fix jittering during window resize on MacOS for WGPU/Metal [#7641](https://github.com/emilk/egui/pull/7641) by [@aspcartman](https://github.com/aspcartman)
+
+
+## 0.33.0 - 2025-10-09
+### 🔧 Changed
+* Update wgpu to 26 and wasm-bindgen to 0.2.100 [#7540](https://github.com/emilk/egui/pull/7540) by [@Kumpelinus](https://github.com/Kumpelinus)
+* Warn if `DYLD_LIBRARY_PATH` is set and we find no wgpu adapter [#7572](https://github.com/emilk/egui/pull/7572) by [@emilk](https://github.com/emilk)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+* Update wgpu to 27.0.0 [#7580](https://github.com/emilk/egui/pull/7580) by [@Wumpf](https://github.com/Wumpf)
+* Create `egui_wgpu::RendererOptions` [#7601](https://github.com/emilk/egui/pull/7601) by [@emilk](https://github.com/emilk)
+* Use software texture filtering in kittest [#7602](https://github.com/emilk/egui/pull/7602) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+Nothing new
+
+
+## 0.32.1 - 2025-08-15
+* Enable wgpu default features in eframe / egui_wgpu default features [#7344](https://github.com/emilk/egui/pull/7344) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.32.0 - 2025-07-10
+* Update to wgpu 25 [#6744](https://github.com/emilk/egui/pull/6744) by [@torokati44](https://github.com/torokati44)
+* Free textures after submitting queue instead of before with wgpu renderer on Web [#7291](https://github.com/emilk/egui/pull/7291) by [@Wumpf](https://github.com/Wumpf)
+* Improve texture filtering by doing it in gamma space [#7311](https://github.com/emilk/egui/pull/7311) by [@emilk](https://github.com/emilk)
+
+
+## 0.31.1 - 2025-03-05
+Nothing new
+
+
 ## 0.31.0 - 2025-02-04
 * Upgrade to wgpu 24 [#5610](https://github.com/emilk/egui/pull/5610) by [@torokati44](https://github.com/torokati44)
 * Extend `WgpuSetup`, `egui_kittest` now prefers software rasterizers for testing [#5506](https://github.com/emilk/egui/pull/5506) by [@Wumpf](https://github.com/Wumpf)
diff --git a/crates/egui-wgpu/Cargo.toml b/crates/egui-wgpu/Cargo.toml
index 2f4330236..c514e0a49 100644
--- a/crates/egui-wgpu/Cargo.toml
+++ b/crates/egui-wgpu/Cargo.toml
@@ -9,19 +9,13 @@ authors = [
 ]
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/egui-wgpu"
+homepage = "https://github.com/emilk/egui/tree/main/crates/egui-wgpu"
 license.workspace = true
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/egui-wgpu"
+repository = "https://github.com/emilk/egui/tree/main/crates/egui-wgpu"
 categories = ["gui", "game-development"]
 keywords = ["wgpu", "egui", "gui", "gamedev"]
-include = [
-  "../LICENSE-APACHE",
-  "../LICENSE-MIT",
-  "**/*.rs",
-  "**/*.wgsl",
-  "Cargo.toml",
-]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "**/*.wgsl", "Cargo.toml"]
 
 [lints]
 workspace = true
@@ -31,10 +25,13 @@ all-features = true
 rustdoc-args = ["--generate-link-to-definition"]
 
 [features]
-default = ["fragile-send-sync-non-atomic-wasm"]
+default = ["fragile-send-sync-non-atomic-wasm", "macos-window-resize-jitter-fix", "wgpu/default"]
+
+## Enables the `capture` module for capturing screenshots.
+capture = ["dep:egui"]
 
 ## Enable [`winit`](https://docs.rs/winit) integration. On Linux, requires either `wayland` or `x11`
-winit = ["dep:winit", "winit/rwh_06"]
+winit = ["dep:winit", "winit/rwh_06", "dep:egui", "capture"]
 
 ## Enables Wayland support for winit.
 wayland = ["winit?/wayland"]
@@ -43,14 +40,16 @@ wayland = ["winit?/wayland"]
 x11 = ["winit?/x11"]
 
 ## Make the renderer `Sync` on wasm, exploiting that by default wasm isn't multithreaded.
-## It may make code easier, expecially when targeting both native and web.
+## It may make code easier, especially when targeting both native and web.
 ## On native most wgpu objects are send and sync, on the web they are not (by nature of the WebGPU specification).
 ## This is not supported in [multithreaded WASM](https://gpuweb.github.io/gpuweb/explainer/#multithreading-transfer).
 ## Thus that usage is guarded against with compiler errors in wgpu.
 fragile-send-sync-non-atomic-wasm = ["wgpu/fragile-send-sync-non-atomic-wasm"]
 
+## Enables `present_with_transaction` surface flag temporary during window resize on MacOS.
+macos-window-resize-jitter-fix = ["wgpu/metal"]
+
 [dependencies]
-egui = { workspace = true, default-features = false }
 epaint = { workspace = true, default-features = false, features = ["bytemuck"] }
 
 ahash.workspace = true
@@ -65,4 +64,5 @@ wgpu = { workspace = true, features = ["wgsl"] }
 
 # Optional dependencies:
 
+egui = { workspace = true, optional = true, default-features = false }
 winit = { workspace = true, optional = true, default-features = false }
diff --git a/crates/egui-wgpu/src/capture.rs b/crates/egui-wgpu/src/capture.rs
index 40cf5484f..cd42b838c 100644
--- a/crates/egui-wgpu/src/capture.rs
+++ b/crates/egui-wgpu/src/capture.rs
@@ -1,9 +1,10 @@
 use egui::{UserData, ViewportId};
 use epaint::ColorImage;
-use std::sync::{mpsc, Arc};
+use std::sync::{Arc, mpsc};
 use wgpu::{BindGroupLayout, MultisampleState, StoreOp};
 
 /// A texture and a buffer for reading the rendered frame back to the cpu.
+///
 /// The texture is required since [`wgpu::TextureUsages::COPY_SRC`] 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
@@ -125,7 +126,7 @@ impl CaptureState {
         // It would be more efficient to reuse the Buffer, e.g. via some kind of ring buffer, but
         // for most screenshot use cases this should be fine. When taking many screenshots (e.g. for a video)
         // it might make sense to revisit this and implement a more efficient solution.
-        #[allow(clippy::arc_with_non_send_sync)]
+        #[allow(clippy::arc_with_non_send_sync, clippy::allow_attributes)] // For wasm
         let buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("egui_screen_capture_buffer"),
             size: (self.padding.padded_bytes_per_row * self.texture.height()) as u64,
@@ -159,6 +160,7 @@ impl CaptureState {
                     load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                     store: StoreOp::Store,
                 },
+                depth_slice: None,
             })],
             depth_stencil_attachment: None,
             occlusion_query_set: None,
@@ -184,7 +186,7 @@ impl CaptureState {
         tx: CaptureSender,
         viewport_id: ViewportId,
     ) {
-        #[allow(clippy::arc_with_non_send_sync)]
+        #[allow(clippy::arc_with_non_send_sync, clippy::allow_attributes)] // For wasm
         let buffer = Arc::new(buffer);
         let buffer_clone = buffer.clone();
         let buffer_slice = buffer_clone.slice(..);
@@ -195,13 +197,15 @@ impl CaptureState {
             wgpu::TextureFormat::Rgba8Unorm => [0, 1, 2, 3],
             wgpu::TextureFormat::Bgra8Unorm => [2, 1, 0, 3],
             _ => {
-                log::error!("Screen can't be captured unless the surface format is Rgba8Unorm or Bgra8Unorm. Current surface format is {:?}", format);
+                log::error!(
+                    "Screen can't be captured unless the surface format is Rgba8Unorm or Bgra8Unorm. Current surface format is {format:?}"
+                );
                 return;
             }
         };
         buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
             if let Err(err) = result {
-                log::error!("Failed to map buffer for reading: {:?}", err);
+                log::error!("Failed to map buffer for reading: {err}");
                 return;
             }
             let buffer_slice = buffer.slice(..);
@@ -226,10 +230,10 @@ impl CaptureState {
             tx.send((
                 viewport_id,
                 data,
-                ColorImage {
-                    size: [tex_extent.width as usize, tex_extent.height as usize],
+                ColorImage::new(
+                    [tex_extent.width as usize, tex_extent.height as usize],
                     pixels,
-                },
+                ),
             ))
             .ok();
             ctx.request_repaint();
diff --git a/crates/egui-wgpu/src/egui.wgsl b/crates/egui-wgpu/src/egui.wgsl
index b60d9de9e..39210841b 100644
--- a/crates/egui-wgpu/src/egui.wgsl
+++ b/crates/egui-wgpu/src/egui.wgsl
@@ -8,10 +8,13 @@ struct VertexOutput {
 
 struct Locals {
     screen_size: vec2<f32>,
-    dithering: u32, // 1 if dithering is enabled, 0 otherwise
-    // Uniform buffers need to be at least 16 bytes in WebGL.
-    // See https://github.com/gfx-rs/wgpu/issues/2072
-    _padding: u32,
+
+    /// 1 if dithering is enabled, 0 otherwise
+    dithering: u32,
+
+    /// 1 to do manual filtering for more predictable kittest snapshot images.
+    /// See also https://github.com/emilk/egui/issues/5295
+    predictable_texture_filtering: u32,
 };
 @group(0) @binding(0) var<uniform> r_locals: Locals;
 
@@ -95,11 +98,42 @@ fn vs_main(
 @group(1) @binding(0) var r_tex_color: texture_2d<f32>;
 @group(1) @binding(1) var r_tex_sampler: sampler;
 
+fn sample_texture(in: VertexOutput) -> vec4<f32> {
+    if r_locals.predictable_texture_filtering == 0 {
+        // Hardware filtering: fast, but varies across GPUs and drivers.
+        return textureSample(r_tex_color, r_tex_sampler, in.tex_coord);
+    } else {
+        // Manual bilinear filtering with four taps at pixel centers using textureLoad
+        let texture_size = vec2<i32>(textureDimensions(r_tex_color, 0));
+        let texture_size_f = vec2<f32>(texture_size);
+        let pixel_coord = in.tex_coord * texture_size_f - 0.5;
+        let pixel_fract = fract(pixel_coord);
+        let pixel_floor = vec2<i32>(floor(pixel_coord));
+
+        // Manual texture clamping
+        let max_coord = texture_size - vec2<i32>(1, 1);
+        let p00 = clamp(pixel_floor + vec2<i32>(0, 0), vec2<i32>(0, 0), max_coord);
+        let p10 = clamp(pixel_floor + vec2<i32>(1, 0), vec2<i32>(0, 0), max_coord);
+        let p01 = clamp(pixel_floor + vec2<i32>(0, 1), vec2<i32>(0, 0), max_coord);
+        let p11 = clamp(pixel_floor + vec2<i32>(1, 1), vec2<i32>(0, 0), max_coord);
+
+        // Load at pixel centers
+        let tl = textureLoad(r_tex_color, p00, 0);
+        let tr = textureLoad(r_tex_color, p10, 0);
+        let bl = textureLoad(r_tex_color, p01, 0);
+        let br = textureLoad(r_tex_color, p11, 0);
+
+        // Manual bilinear interpolation
+        let top = mix(tl, tr, pixel_fract.x);
+        let bottom = mix(bl, br, pixel_fract.x);
+        return mix(top, bottom, pixel_fract.y);
+    }
+}
+
 @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);
+    // We expect "normal" textures that are NOT sRGB-aware.
+    let tex_gamma = sample_texture(in);
     var out_color_gamma = in.color * tex_gamma;
     // Dither the float color down to eight bits to reduce banding.
     // This step is optional for egui backends.
@@ -115,9 +149,8 @@ fn fs_main_linear_framebuffer(in: VertexOutput) -> @location(0) vec4<f32> {
 
 @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);
+    // We expect "normal" textures that are NOT sRGB-aware.
+    let tex_gamma = sample_texture(in);
     var out_color_gamma = in.color * tex_gamma;
     // Dither the float color down to eight bits to reduce banding.
     // This step is optional for egui backends.
diff --git a/crates/egui-wgpu/src/lib.rs b/crates/egui-wgpu/src/lib.rs
index e19c26574..d340526af 100644
--- a/crates/egui-wgpu/src/lib.rs
+++ b/crates/egui-wgpu/src/lib.rs
@@ -29,6 +29,7 @@ pub use renderer::*;
 pub use setup::{NativeAdapterSelectorMethod, WgpuSetup, WgpuSetupCreateNew, WgpuSetupExisting};
 
 /// Helpers for capturing screenshots of the UI.
+#[cfg(feature = "capture")]
 pub mod capture;
 
 /// Module for painting [`egui`](https://github.com/emilk/egui) with [`wgpu`] on [`winit`].
@@ -42,8 +43,11 @@ use epaint::mutex::RwLock;
 /// An error produced by egui-wgpu.
 #[derive(thiserror::Error, Debug)]
 pub enum WgpuError {
-    #[error("Failed to create wgpu adapter, no suitable adapter found: {0}")]
-    NoSuitableAdapterFound(String),
+    #[error(transparent)]
+    RequestAdapterError(#[from] wgpu::RequestAdapterError),
+
+    #[error("Adapter selection failed: {0}")]
+    CustomNativeAdapterSelectionError(String),
 
     #[error("There was no valid format for the surface at all.")]
     NoSurfaceFormatsAvailable,
@@ -89,7 +93,7 @@ async fn request_adapter(
     instance: &wgpu::Instance,
     power_preference: wgpu::PowerPreference,
     compatible_surface: Option<&wgpu::Surface<'_>>,
-    _available_adapters: &[wgpu::Adapter],
+    available_adapters: &[wgpu::Adapter],
 ) -> Result<wgpu::Adapter, WgpuError> {
     profiling::function_scope!();
 
@@ -104,48 +108,58 @@ async fn request_adapter(
             force_fallback_adapter: false,
         })
         .await
-        .ok_or_else(|| {
-            #[cfg(not(target_arch = "wasm32"))]
-            if _available_adapters.is_empty() {
-                log::info!("No wgpu adapters found");
-            } else if _available_adapters.len() == 1 {
+        .inspect_err(|_err| {
+            if cfg!(target_arch = "wasm32") {
+                // Nothing to add here
+            } else if available_adapters.is_empty() {
+                if std::env::var("DYLD_LIBRARY_PATH").is_ok() {
+                    // DYLD_LIBRARY_PATH can sometimes lead to loading dylibs that cause
+                    // us to find zero adapters. Very strange.
+                    // I don't want to debug this again.
+                    // See https://github.com/rerun-io/rerun/issues/11351 for more
+                    log::warn!(
+                        "No wgpu adapter found. This could be because DYLD_LIBRARY_PATH causes dylibs to be loaded that interfere with Metal device creation. Try restarting with DYLD_LIBRARY_PATH=''"
+                    );
+                } else {
+                    log::info!("No wgpu adapter found");
+                }
+            } else if available_adapters.len() == 1 {
                 log::info!(
                     "The only available wgpu adapter was not suitable: {}",
-                    adapter_info_summary(&_available_adapters[0].get_info())
+                    adapter_info_summary(&available_adapters[0].get_info())
                 );
             } else {
                 log::info!(
                     "No suitable wgpu adapter found out of the {} available ones: {}",
-                    _available_adapters.len(),
-                    describe_adapters(_available_adapters)
+                    available_adapters.len(),
+                    describe_adapters(available_adapters)
                 );
             }
-
-            WgpuError::NoSuitableAdapterFound("`request_adapters` returned `None`".to_owned())
         })?;
 
-    #[cfg(target_arch = "wasm32")]
-    log::debug!(
-        "Picked wgpu adapter: {}",
-        adapter_info_summary(&adapter.get_info())
-    );
-
-    #[cfg(not(target_arch = "wasm32"))]
-    if _available_adapters.len() == 1 {
-        log::debug!(
-            "Picked the only available wgpu adapter: {}",
-            adapter_info_summary(&adapter.get_info())
-        );
-    } else {
-        log::info!(
-            "There were {} available wgpu adapters: {}",
-            _available_adapters.len(),
-            describe_adapters(_available_adapters)
-        );
+    if cfg!(target_arch = "wasm32") {
         log::debug!(
             "Picked wgpu adapter: {}",
             adapter_info_summary(&adapter.get_info())
         );
+    } else {
+        // native:
+        if available_adapters.len() == 1 {
+            log::debug!(
+                "Picked the only available wgpu adapter: {}",
+                adapter_info_summary(&adapter.get_info())
+            );
+        } else {
+            log::info!(
+                "There were {} available wgpu adapters: {}",
+                available_adapters.len(),
+                describe_adapters(available_adapters)
+            );
+            log::debug!(
+                "Picked wgpu adapter: {}",
+                adapter_info_summary(&adapter.get_info())
+            );
+        }
     }
 
     Ok(adapter)
@@ -160,9 +174,7 @@ impl RenderState {
         config: &WgpuConfiguration,
         instance: &wgpu::Instance,
         compatible_surface: Option<&wgpu::Surface<'static>>,
-        depth_format: Option<wgpu::TextureFormat>,
-        msaa_samples: u32,
-        dithering: bool,
+        options: RendererOptions,
     ) -> Result<Self, WgpuError> {
         profiling::scope!("RenderState::create"); // async yield give bad names using `profile_function`
 
@@ -184,7 +196,6 @@ impl RenderState {
                 power_preference,
                 native_adapter_selector: _native_adapter_selector,
                 device_descriptor,
-                trace_path,
             }) => {
                 let adapter = {
                     #[cfg(target_arch = "wasm32")]
@@ -194,7 +205,7 @@ impl RenderState {
                     #[cfg(not(target_arch = "wasm32"))]
                     if let Some(native_adapter_selector) = _native_adapter_selector {
                         native_adapter_selector(&available_adapters, compatible_surface)
-                            .map_err(WgpuError::NoSuitableAdapterFound)
+                            .map_err(WgpuError::CustomNativeAdapterSelectionError)
                     } else {
                         request_adapter(
                             instance,
@@ -209,7 +220,7 @@ impl RenderState {
                 let (device, queue) = {
                     profiling::scope!("request_device");
                     adapter
-                        .request_device(&(*device_descriptor)(&adapter), trace_path.as_deref())
+                        .request_device(&(*device_descriptor)(&adapter))
                         .await?
                 };
 
@@ -232,17 +243,11 @@ impl RenderState {
         };
         let target_format = crate::preferred_framebuffer_format(&surface_formats)?;
 
-        let renderer = Renderer::new(
-            &device,
-            target_format,
-            depth_format,
-            msaa_samples,
-            dithering,
-        );
+        let renderer = Renderer::new(&device, target_format, options);
 
         // On wasm, depending on feature flags, wgpu objects may or may not implement sync.
         // It doesn't make sense to switch to Rc for that special usecase, so simply disable the lint.
-        #[allow(clippy::arc_with_non_send_sync)]
+        #[allow(clippy::arc_with_non_send_sync, clippy::allow_attributes)] // For wasm
         Ok(Self {
             adapter,
             #[cfg(not(target_arch = "wasm32"))]
@@ -255,7 +260,6 @@ impl RenderState {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 fn describe_adapters(adapters: &[wgpu::Adapter]) -> String {
     if adapters.is_empty() {
         "(none)".to_owned()
diff --git a/crates/egui-wgpu/src/renderer.rs b/crates/egui-wgpu/src/renderer.rs
index 5a5c953bb..108aa31c3 100644
--- a/crates/egui-wgpu/src/renderer.rs
+++ b/crates/egui-wgpu/src/renderer.rs
@@ -3,7 +3,8 @@
 use std::{borrow::Cow, num::NonZeroU64, ops::Range};
 
 use ahash::HashMap;
-use epaint::{emath::NumExt, PaintCallbackInfo, Primitive, Vertex};
+use bytemuck::Zeroable as _;
+use epaint::{PaintCallbackInfo, Primitive, Vertex, emath::NumExt as _};
 
 use wgpu::util::DeviceExt as _;
 
@@ -84,7 +85,7 @@ impl Callback {
 ///
 /// # 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.
+/// See the [`custom3d_wgpu`](https://github.com/emilk/egui/blob/main/crates/egui_demo_app/src/apps/custom3d_wgpu.rs) demo source for a detailed usage example.
 pub trait CallbackTrait: Send + Sync {
     fn prepare(
         &self,
@@ -140,21 +141,16 @@ impl ScreenDescriptor {
 }
 
 /// Uniform buffer used when rendering.
-#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+#[derive(Clone, Copy, Debug, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
 #[repr(C)]
 struct UniformBuffer {
     screen_size_in_points: [f32; 2],
     dithering: u32,
-    // Uniform buffers need to be at least 16 bytes in WebGL.
-    // See https://github.com/gfx-rs/wgpu/issues/2072
-    _padding: u32,
-}
 
-impl PartialEq for UniformBuffer {
-    fn eq(&self, other: &Self) -> bool {
-        self.screen_size_in_points == other.screen_size_in_points
-            && self.dithering == other.dithering
-    }
+    /// 1 to do manual filtering for more predictable kittest snapshot images.
+    ///
+    /// See also <https://github.com/emilk/egui/issues/5295>.
+    predictable_texture_filtering: u32,
 }
 
 struct SlicedBuffer {
@@ -175,6 +171,69 @@ pub struct Texture {
     pub options: Option<epaint::textures::TextureOptions>,
 }
 
+/// Ways to configure [`Renderer`] during creation.
+#[derive(Clone, Copy, Debug)]
+pub struct RendererOptions {
+    /// Set the level of the multisampling anti-aliasing (MSAA).
+    ///
+    /// Must be a power-of-two. Higher = more smooth 3D.
+    ///
+    /// A value of `0` or `1` 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 msaa_samples: u32,
+
+    /// What format to use for the depth and stencil buffers,
+    /// e.g. [`wgpu::TextureFormat::Depth32FloatStencil8`].
+    ///
+    /// egui doesn't need depth/stencil, so the default value is `None` (no depth or stancil buffers).
+    pub depth_stencil_format: Option<wgpu::TextureFormat>,
+
+    /// Controls whether to apply dithering to minimize banding artifacts.
+    ///
+    /// Dithering assumes an sRGB output and thus will apply noise to any input value that lies between
+    /// two 8bit values after applying the sRGB OETF function, i.e. if it's not a whole 8bit value in "gamma space".
+    /// This means that only inputs from texture interpolation and vertex colors should be affected in practice.
+    ///
+    /// Defaults to true.
+    pub dithering: bool,
+
+    /// Perform texture filtering in software?
+    ///
+    /// This is useful when you want predictable rendering across
+    /// different hardware, e.g. for kittest snapshots.
+    ///
+    /// Default is `false`.
+    ///
+    /// See also <https://github.com/emilk/egui/issues/5295>.
+    pub predictable_texture_filtering: bool,
+}
+
+impl RendererOptions {
+    /// Set options that produce the most predicatable output.
+    ///
+    /// Useful for image snapshot tests.
+    pub const PREDICTABLE: Self = Self {
+        msaa_samples: 1,
+        depth_stencil_format: None,
+        dithering: false,
+        predictable_texture_filtering: true,
+    };
+}
+
+impl Default for RendererOptions {
+    fn default() -> Self {
+        Self {
+            msaa_samples: 0,
+            depth_stencil_format: None,
+            dithering: true,
+            predictable_texture_filtering: false,
+        }
+    }
+}
+
 /// Renderer for a egui based GUI.
 pub struct Renderer {
     pipeline: wgpu::RenderPipeline,
@@ -194,7 +253,7 @@ pub struct Renderer {
     next_user_texture_id: u64,
     samplers: HashMap<epaint::textures::TextureOptions, wgpu::Sampler>,
 
-    dithering: bool,
+    options: RendererOptions,
 
     /// Storage for resources shared with all invocations of [`CallbackTrait`]'s methods.
     ///
@@ -210,9 +269,7 @@ impl Renderer {
     pub fn new(
         device: &wgpu::Device,
         output_color_format: wgpu::TextureFormat,
-        output_depth_format: Option<wgpu::TextureFormat>,
-        msaa_samples: u32,
-        dithering: bool,
+        options: RendererOptions,
     ) -> Self {
         profiling::function_scope!();
 
@@ -229,8 +286,8 @@ impl Renderer {
             label: Some("egui_uniform_buffer"),
             contents: bytemuck::cast_slice(&[UniformBuffer {
                 screen_size_in_points: [0.0, 0.0],
-                dithering: u32::from(dithering),
-                _padding: Default::default(),
+                dithering: u32::from(options.dithering),
+                predictable_texture_filtering: u32::from(options.predictable_texture_filtering),
             }]),
             usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
         });
@@ -299,13 +356,15 @@ impl Renderer {
             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 depth_stencil = options
+            .depth_stencil_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 = {
             profiling::scope!("create_render_pipeline");
@@ -337,14 +396,14 @@ impl Renderer {
                 depth_stencil,
                 multisample: wgpu::MultisampleState {
                     alpha_to_coverage_enabled: false,
-                    count: msaa_samples,
+                    count: options.msaa_samples.max(1),
                     mask: !0,
                 },
 
                 fragment: Some(wgpu::FragmentState {
                     module: &module,
                     entry_point: Some(if output_color_format.is_srgb() {
-                        log::warn!("Detected a linear (sRGBA aware) framebuffer {:?}. egui prefers Rgba8Unorm or Bgra8Unorm", output_color_format);
+                        log::warn!("Detected a linear (sRGBA aware) framebuffer {output_color_format:?}. egui prefers Rgba8Unorm or Bgra8Unorm");
                         "fs_main_linear_framebuffer"
                     } else {
                         "fs_main_gamma_framebuffer" // this is what we prefer
@@ -392,17 +451,13 @@ impl Renderer {
             },
             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],
-                dithering: 0,
-                _padding: 0,
-            },
+            previous_uniform_buffer_content: UniformBuffer::zeroed(),
             uniform_bind_group,
             texture_bind_group_layout,
             textures: HashMap::default(),
             next_user_texture_id: 0,
             samplers: HashMap::default(),
-            dithering,
+            options,
             callback_resources: CallbackResources::default(),
         }
     }
@@ -564,15 +619,6 @@ impl Renderer {
                 );
                 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"
-                );
-                profiling::scope!("font -> sRGBA");
-                Cow::Owned(image.srgba_pixels(None).collect::<Vec<epaint::Color32>>())
-            }
         };
         let data_bytes: &[u8] = bytemuck::cast_slice(data_color32.as_slice());
 
@@ -638,9 +684,9 @@ impl Renderer {
                     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.
+                    format: wgpu::TextureFormat::Rgba8Unorm,
                     usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-                    view_formats: &[wgpu::TextureFormat::Rgba8UnormSrgb],
+                    view_formats: &[wgpu::TextureFormat::Rgba8Unorm],
                 })
             };
             let origin = wgpu::Origin3d::ZERO;
@@ -699,7 +745,7 @@ impl Renderer {
     ///
     /// 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 [`wgpu::TextureFormat::Rgba8UnormSrgb`].
+    /// the texture format [`wgpu::TextureFormat::Rgba8Unorm`].
     pub fn register_native_texture(
         &mut self,
         device: &wgpu::Device,
@@ -747,9 +793,9 @@ impl Renderer {
     /// This allows applications to specify individual minification/magnification filters as well as
     /// custom mipmap and tiling options.
     ///
-    /// The texture must have the format [`wgpu::TextureFormat::Rgba8UnormSrgb`].
+    /// The texture must have the format [`wgpu::TextureFormat::Rgba8Unorm`].
     /// Any compare function supplied in the [`wgpu::SamplerDescriptor`] will be ignored.
-    #[allow(clippy::needless_pass_by_value)] // false positive
+    #[expect(clippy::needless_pass_by_value)] // false positive
     pub fn register_native_texture_with_sampler_options(
         &mut self,
         device: &wgpu::Device,
@@ -796,7 +842,7 @@ impl Renderer {
     /// [`wgpu::SamplerDescriptor`] options.
     ///
     /// This allows applications to reuse [`epaint::TextureId`]s created with custom sampler options.
-    #[allow(clippy::needless_pass_by_value)] // false positive
+    #[expect(clippy::needless_pass_by_value)] // false positive
     pub fn update_egui_texture_from_wgpu_texture_with_sampler_options(
         &mut self,
         device: &wgpu::Device,
@@ -855,8 +901,8 @@ impl Renderer {
 
         let uniform_buffer_content = UniformBuffer {
             screen_size_in_points,
-            dithering: u32::from(self.dithering),
-            _padding: Default::default(),
+            dithering: u32::from(self.options.dithering),
+            predictable_texture_filtering: u32::from(self.options.predictable_texture_filtering),
         };
         if uniform_buffer_content != self.previous_uniform_buffer_content {
             profiling::scope!("update uniforms");
@@ -882,7 +928,7 @@ impl Renderer {
                             callbacks.push(c.0.as_ref());
                         } else {
                             log::warn!("Unknown paint callback: expected `egui_wgpu::Callback`");
-                        };
+                        }
                         acc
                     }
                 }
@@ -909,7 +955,11 @@ impl Renderer {
             );
 
             let Some(mut index_buffer_staging) = index_buffer_staging else {
-                panic!("Failed to create staging buffer for index data. Index count: {index_count}. Required index buffer size: {required_index_buffer_size}. Actual size {} and capacity: {} (bytes)", self.index_buffer.buffer.size(), self.index_buffer.capacity);
+                panic!(
+                    "Failed to create staging buffer for index data. Index count: {index_count}. Required index buffer size: {required_index_buffer_size}. Actual size {} and capacity: {} (bytes)",
+                    self.index_buffer.buffer.size(),
+                    self.index_buffer.capacity
+                );
             };
 
             let mut index_offset = 0;
@@ -948,7 +998,11 @@ impl Renderer {
             );
 
             let Some(mut vertex_buffer_staging) = vertex_buffer_staging else {
-                panic!("Failed to create staging buffer for vertex data. Vertex count: {vertex_count}. Required vertex buffer size: {required_vertex_buffer_size}. Actual size {} and capacity: {} (bytes)", self.vertex_buffer.buffer.size(), self.vertex_buffer.capacity);
+                panic!(
+                    "Failed to create staging buffer for vertex data. Vertex count: {vertex_count}. Required vertex buffer size: {required_vertex_buffer_size}. Actual size {} and capacity: {} (bytes)",
+                    self.vertex_buffer.buffer.size(),
+                    self.vertex_buffer.capacity
+                );
             };
 
             let mut vertex_offset = 0;
diff --git a/crates/egui-wgpu/src/setup.rs b/crates/egui-wgpu/src/setup.rs
index 1f70b6bb7..bd587350e 100644
--- a/crates/egui-wgpu/src/setup.rs
+++ b/crates/egui-wgpu/src/setup.rs
@@ -48,7 +48,7 @@ impl WgpuSetup {
     pub async fn new_instance(&self) -> wgpu::Instance {
         match self {
             Self::CreateNew(create_new) => {
-                #[allow(unused_mut)]
+                #[allow(unused_mut, clippy::allow_attributes)]
                 let mut backends = create_new.instance_descriptor.backends;
 
                 // Don't try WebGPU if we're not in a secure context.
@@ -64,7 +64,7 @@ impl WgpuSetup {
                     }
                 }
 
-                log::debug!("Creating wgpu instance with backends {:?}", backends);
+                log::debug!("Creating wgpu instance with backends {backends:?}");
                 wgpu::util::new_instance_with_webgpu_detection(&create_new.instance_descriptor)
                     .await
             }
@@ -126,13 +126,6 @@ pub struct WgpuSetupCreateNew {
     /// Configuration passed on device request, given an adapter
     pub device_descriptor:
         Arc<dyn Fn(&wgpu::Adapter) -> wgpu::DeviceDescriptor<'static> + Send + Sync>,
-
-    /// Option path to output a wgpu trace file.
-    ///
-    /// This only works if this feature is enabled in `wgpu-core`.
-    /// Does not work when running with WebGPU.
-    /// Defaults to the path set in the `WGPU_TRACE` environment variable.
-    pub trace_path: Option<std::path::PathBuf>,
 }
 
 impl Clone for WgpuSetupCreateNew {
@@ -142,7 +135,6 @@ impl Clone for WgpuSetupCreateNew {
             power_preference: self.power_preference,
             native_adapter_selector: self.native_adapter_selector.clone(),
             device_descriptor: self.device_descriptor.clone(),
-            trace_path: self.trace_path.clone(),
         }
     }
 }
@@ -156,7 +148,6 @@ impl std::fmt::Debug for WgpuSetupCreateNew {
                 "native_adapter_selector",
                 &self.native_adapter_selector.is_some(),
             )
-            .field("trace_path", &self.trace_path)
             .finish()
     }
 }
@@ -171,6 +162,7 @@ impl Default for WgpuSetupCreateNew {
                     .unwrap_or(wgpu::Backends::PRIMARY | wgpu::Backends::GL),
                 flags: wgpu::InstanceFlags::from_build_config().with_env(),
                 backend_options: wgpu::BackendOptions::from_env_or_default(),
+                memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),
             },
 
             power_preference: wgpu::PowerPreference::from_env()
@@ -187,20 +179,15 @@ impl Default for WgpuSetupCreateNew {
 
                 wgpu::DeviceDescriptor {
                     label: Some("egui wgpu device"),
-                    required_features: wgpu::Features::default(),
                     required_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,
                         ..base_limits
                     },
-                    memory_hints: wgpu::MemoryHints::default(),
+                    ..Default::default()
                 }
             }),
-
-            trace_path: std::env::var("WGPU_TRACE")
-                .ok()
-                .map(std::path::PathBuf::from),
         }
     }
 }
diff --git a/crates/egui-wgpu/src/winit.rs b/crates/egui-wgpu/src/winit.rs
index cc3a7db2c..3a286cc9e 100644
--- a/crates/egui-wgpu/src/winit.rs
+++ b/crates/egui-wgpu/src/winit.rs
@@ -1,8 +1,11 @@
 #![allow(clippy::missing_errors_doc)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use crate::capture::{capture_channel, CaptureReceiver, CaptureSender, CaptureState};
-use crate::{renderer, RenderState, SurfaceErrorAction, WgpuConfiguration};
+use crate::{RenderState, SurfaceErrorAction, WgpuConfiguration, renderer};
+use crate::{
+    RendererOptions,
+    capture::{CaptureReceiver, CaptureSender, CaptureState, capture_channel},
+};
 use egui::{Context, Event, UserData, ViewportId, ViewportIdMap, ViewportIdSet};
 use std::{num::NonZeroU32, sync::Arc};
 
@@ -11,6 +14,7 @@ struct SurfaceState {
     alpha_mode: wgpu::CompositeAlphaMode,
     width: u32,
     height: u32,
+    resizing: bool,
 }
 
 /// Everything you need to paint egui with [`wgpu`] on [`winit`].
@@ -21,10 +25,8 @@ struct SurfaceState {
 pub struct Painter {
     context: Context,
     configuration: WgpuConfiguration,
-    msaa_samples: u32,
+    options: RendererOptions,
     support_transparent_backbuffer: bool,
-    dithering: bool,
-    depth_format: Option<wgpu::TextureFormat>,
     screen_capture_state: Option<CaptureState>,
 
     instance: wgpu::Instance,
@@ -54,10 +56,8 @@ impl Painter {
     pub async fn new(
         context: Context,
         configuration: WgpuConfiguration,
-        msaa_samples: u32,
-        depth_format: Option<wgpu::TextureFormat>,
         support_transparent_backbuffer: bool,
-        dithering: bool,
+        options: RendererOptions,
     ) -> Self {
         let (capture_tx, capture_rx) = capture_channel();
         let instance = configuration.wgpu_setup.new_instance().await;
@@ -65,10 +65,8 @@ impl Painter {
         Self {
             context,
             configuration,
-            msaa_samples,
+            options,
             support_transparent_backbuffer,
-            dithering,
-            depth_format,
             screen_capture_state: None,
 
             instance,
@@ -204,9 +202,7 @@ impl Painter {
                 &self.configuration,
                 &self.instance,
                 Some(&surface),
-                self.depth_format,
-                self.msaa_samples,
-                self.dithering,
+                self.options,
             )
             .await?;
             self.render_state.get_or_insert(render_state)
@@ -220,7 +216,9 @@ impl Painter {
             } else if supported_alpha_modes.contains(&wgpu::CompositeAlphaMode::PostMultiplied) {
                 wgpu::CompositeAlphaMode::PostMultiplied
             } else {
-                log::warn!("Transparent window was requested, but the active wgpu surface does not support a `CompositeAlphaMode` with transparency.");
+                log::warn!(
+                    "Transparent window was requested, but the active wgpu surface does not support a `CompositeAlphaMode` with transparency."
+                );
                 wgpu::CompositeAlphaMode::Auto
             }
         } else {
@@ -233,6 +231,7 @@ impl Painter {
                 width: size.width,
                 height: size.height,
                 alpha_mode,
+                resizing: false,
             },
         );
         let Some(width) = NonZeroU32::new(size.width) else {
@@ -277,7 +276,7 @@ impl Painter {
 
         Self::configure_surface(surface_state, render_state, &self.configuration);
 
-        if let Some(depth_format) = self.depth_format {
+        if let Some(depth_format) = self.options.depth_stencil_format {
             self.depth_texture_view.insert(
                 viewport_id,
                 render_state
@@ -290,7 +289,7 @@ impl Painter {
                             depth_or_array_layers: 1,
                         },
                         mip_level_count: 1,
-                        sample_count: self.msaa_samples,
+                        sample_count: self.options.msaa_samples.max(1),
                         dimension: wgpu::TextureDimension::D2,
                         format: depth_format,
                         usage: wgpu::TextureUsages::RENDER_ATTACHMENT
@@ -301,7 +300,7 @@ impl Painter {
             );
         }
 
-        if let Some(render_state) = (self.msaa_samples > 1)
+        if let Some(render_state) = (self.options.msaa_samples > 1)
             .then_some(self.render_state.as_ref())
             .flatten()
         {
@@ -318,7 +317,7 @@ impl Painter {
                             depth_or_array_layers: 1,
                         },
                         mip_level_count: 1,
-                        sample_count: self.msaa_samples,
+                        sample_count: self.options.msaa_samples.max(1),
                         dimension: wgpu::TextureDimension::D2,
                         format: texture_format,
                         usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
@@ -326,7 +325,60 @@ impl Painter {
                     })
                     .create_view(&wgpu::TextureViewDescriptor::default()),
             );
+        }
+    }
+
+    /// Handles changes of the resizing state.
+    ///
+    /// Should be called prior to the first [`Painter::on_window_resized`] call and after the last in
+    /// the chain. Used to apply platform-specific logic, e.g. OSX Metal window resize jitter fix.
+    pub fn on_window_resize_state_change(&mut self, viewport_id: ViewportId, resizing: bool) {
+        profiling::function_scope!();
+
+        let Some(state) = self.surfaces.get_mut(&viewport_id) else {
+            return;
         };
+        if state.resizing == resizing {
+            if resizing {
+                log::debug!(
+                    "Painter::on_window_resize_state_change() redundant call while resizing"
+                );
+            } else {
+                log::debug!(
+                    "Painter::on_window_resize_state_change() redundant call after resizing"
+                );
+            }
+            return;
+        }
+
+        // Resizing is a bit tricky on macOS.
+        // It requires enabling ["present_with_transaction"](https://developer.apple.com/documentation/quartzcore/cametallayer/presentswithtransaction)
+        // flag to avoid jittering during the resize. Even though resize jittering on macOS
+        // is common across rendering backends, the solution for wgpu/metal is known.
+        //
+        // See https://github.com/emilk/egui/issues/903
+        #[cfg(all(target_os = "macos", feature = "macos-window-resize-jitter-fix"))]
+        {
+            // SAFETY: The cast is checked with if condition. If the used backend is not metal
+            // it gracefully fails. The pointer casts are valid as it's 1-to-1 type mapping.
+            // This is how wgpu currently exposes this backend-specific flag.
+            unsafe {
+                if let Some(hal_surface) = state.surface.as_hal::<wgpu::hal::api::Metal>() {
+                    let raw =
+                        std::ptr::from_ref::<wgpu::hal::metal::Surface>(&*hal_surface).cast_mut();
+
+                    (*raw).present_with_transaction = resizing;
+
+                    Self::configure_surface(
+                        state,
+                        self.render_state.as_ref().unwrap(),
+                        &self.configuration,
+                    );
+                }
+            }
+        }
+
+        state.resizing = resizing;
     }
 
     pub fn on_window_resized(
@@ -344,7 +396,9 @@ impl Painter {
                 height_in_pixels,
             );
         } else {
-            log::warn!("Ignoring window resize notification with no surface created via Painter::set_window()");
+            log::warn!(
+                "Ignoring window resize notification with no surface created via Painter::set_window()"
+            );
         }
     }
 
@@ -446,7 +500,7 @@ impl Painter {
             };
             let target_view = target_texture.create_view(&wgpu::TextureViewDescriptor::default());
 
-            let (view, resolve_target) = (self.msaa_samples > 1)
+            let (view, resolve_target) = (self.options.msaa_samples > 1)
                 .then_some(self.msaa_texture_view.get(&viewport_id))
                 .flatten()
                 .map_or((&target_view, None), |texture_view| {
@@ -467,6 +521,7 @@ impl Painter {
                         }),
                         store: wgpu::StoreOp::Store,
                     },
+                    depth_slice: None,
                 })],
                 depth_stencil_attachment: self.depth_texture_view.get(&viewport_id).map(|view| {
                     wgpu::RenderPassDepthStencilAttachment {
@@ -493,14 +548,12 @@ impl Painter {
                 &screen_descriptor,
             );
 
-            if capture {
-                if let Some(capture_state) = &mut self.screen_capture_state {
-                    capture_buffer = Some(capture_state.copy_textures(
-                        &render_state.device,
-                        &output_frame,
-                        &mut encoder,
-                    ));
-                }
+            if capture && let Some(capture_state) = &mut self.screen_capture_state {
+                capture_buffer = Some(capture_state.copy_textures(
+                    &render_state.device,
+                    &output_frame,
+                    &mut encoder,
+                ));
             }
         }
 
@@ -530,16 +583,16 @@ impl Painter {
             }
         }
 
-        if let Some(capture_buffer) = capture_buffer {
-            if let Some(screen_capture_state) = &mut self.screen_capture_state {
-                screen_capture_state.read_screen_rgba(
-                    self.context.clone(),
-                    capture_buffer,
-                    capture_data,
-                    self.capture_tx.clone(),
-                    viewport_id,
-                );
-            }
+        if let Some(capture_buffer) = capture_buffer
+            && let Some(screen_capture_state) = &mut self.screen_capture_state
+        {
+            screen_capture_state.read_screen_rgba(
+                self.context.clone(),
+                capture_buffer,
+                capture_data,
+                self.capture_tx.clone(),
+                viewport_id,
+            );
         }
 
         {
@@ -575,7 +628,7 @@ impl Painter {
             .retain(|id, _| active_viewports.contains(id));
     }
 
-    #[allow(clippy::needless_pass_by_ref_mut, clippy::unused_self)]
+    #[expect(clippy::needless_pass_by_ref_mut, clippy::unused_self)]
     pub fn destroy(&mut self) {
         // TODO(emilk): something here?
     }
diff --git a/crates/egui-winit/CHANGELOG.md b/crates/egui-winit/CHANGELOG.md
index 7cc8667c5..8e555a7bc 100644
--- a/crates/egui-winit/CHANGELOG.md
+++ b/crates/egui-winit/CHANGELOG.md
@@ -5,6 +5,49 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+* Don't enable `arboard` on iOS [#7663](https://github.com/emilk/egui/pull/7663) by [@irh](https://github.com/irh)
+
+
+## 0.33.0 - 2025-10-09
+### ⭐ Added
+* Add rotation gesture support for trackpad sources [#7453](https://github.com/emilk/egui/pull/7453) by [@thatcomputerguy0101](https://github.com/thatcomputerguy0101)
+* Add support for the safe area on iOS [#7578](https://github.com/emilk/egui/pull/7578) by [@irh](https://github.com/irh)
+
+### 🔧 Changed
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+* Create `egui_wgpu::RendererOptions` [#7601](https://github.com/emilk/egui/pull/7601) by [@emilk](https://github.com/emilk)
+
+### 🐛 Fixed
+* Fix build error in egui-winit with profiling enabled [#7557](https://github.com/emilk/egui/pull/7557) by [@torokati44](https://github.com/torokati44)
+* Properly end winit event loop [#7565](https://github.com/emilk/egui/pull/7565) by [@tye-exe](https://github.com/tye-exe)
+* Fix eframe window not being focused on mac on startup [#7593](https://github.com/emilk/egui/pull/7593) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+Nothing new
+
+
+## 0.32.1 - 2025-08-15
+* Update to winit 0.30.12 [#7420](https://github.com/emilk/egui/pull/7420) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.0 - 2025-07-10
+* Mark all keys as released if the app loses focus [#5743](https://github.com/emilk/egui/pull/5743) by [@emilk](https://github.com/emilk)
+* Fix text input on Android [#5759](https://github.com/emilk/egui/pull/5759) by [@StratusFearMe21](https://github.com/StratusFearMe21)
+* Add macOS-specific `has_shadow` and `with_has_shadow` to ViewportBuilder [#6850](https://github.com/emilk/egui/pull/6850) by [@gaelanmcmillan](https://github.com/gaelanmcmillan)
+* Support for back-button on Android [#7073](https://github.com/emilk/egui/pull/7073) by [@ardocrat](https://github.com/ardocrat)
+* Fix incorrect window sizes for non-resizable windows on Wayland [#7103](https://github.com/emilk/egui/pull/7103) by [@GoldsteinE](https://github.com/GoldsteinE)
+
+
+## 0.31.1 - 2025-03-05
+Nothing new
+
+
 ## 0.31.0 - 2025-02-04
 * Re-enable IME support on Linux [#5198](https://github.com/emilk/egui/pull/5198) by [@YgorSouza](https://github.com/YgorSouza)
 * Update to winit 0.30.7 [#5516](https://github.com/emilk/egui/pull/5516) by [@emilk](https://github.com/emilk)
diff --git a/crates/egui-winit/Cargo.toml b/crates/egui-winit/Cargo.toml
index e4a837823..d1b2ab220 100644
--- a/crates/egui-winit/Cargo.toml
+++ b/crates/egui-winit/Cargo.toml
@@ -5,10 +5,10 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Bindings for using egui with winit"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/egui-winit"
+homepage = "https://github.com/emilk/egui/tree/main/crates/egui-winit"
 license.workspace = true
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/egui-winit"
+repository = "https://github.com/emilk/egui/tree/main/crates/egui-winit"
 categories = ["gui", "game-development"]
 keywords = ["winit", "egui", "gui", "gamedev"]
 include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
@@ -24,7 +24,7 @@ rustdoc-args = ["--generate-link-to-definition"]
 default = ["clipboard", "links", "wayland", "winit/default", "x11"]
 
 ## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
-accesskit = ["dep:accesskit_winit", "egui/accesskit"]
+accesskit = ["dep:accesskit_winit"]
 
 # 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
@@ -55,9 +55,8 @@ wayland = ["winit/wayland", "bytemuck"]
 x11 = ["winit/x11", "bytemuck"]
 
 [dependencies]
-egui = { workspace = true, default-features = false, features = ["log"] }
+egui = { workspace = true, default-features = false }
 
-ahash.workspace = true
 log.workspace = true
 profiling.workspace = true
 raw-window-handle.workspace = true
@@ -67,7 +66,7 @@ winit = { workspace = true, default-features = false }
 #! ### Optional dependencies
 
 # feature accesskit
-accesskit_winit = { version = "0.23", optional = true }
+accesskit_winit = { workspace = true, optional = true }
 
 bytemuck = { workspace = true, optional = true }
 
@@ -75,17 +74,30 @@ bytemuck = { workspace = true, optional = true }
 document-features = { workspace = true, optional = true }
 
 serde = { workspace = true, optional = true }
-webbrowser = { version = "1.0.0", optional = true }
+webbrowser = { workspace = true, optional = true }
+
+[target.'cfg(target_os = "ios")'.dependencies]
+objc2.workspace = true
+objc2-foundation = { workspace = true, features = ["std", "NSThread"] }
+objc2-ui-kit = { workspace = true, features = [
+  "std",
+  "UIApplication",
+  "UIGeometry",
+  "UIResponder",
+  "UIScene",
+  "UISceneDefinitions",
+  "UIView",
+  "UIWindow",
+  "UIWindowScene",
+] }
 
 [target.'cfg(any(target_os="linux", target_os="dragonfly", target_os="freebsd", target_os="netbsd", target_os="openbsd"))'.dependencies]
-smithay-clipboard = { version = "0.7.2", optional = true }
+smithay-clipboard = { workspace = true, optional = true }
 
 # The wayland-cursor normally selected doesn't properly enable all the features it uses
 # and thus doesn't compile as it is used in egui-winit. This is fixed upstream, so force
 # a slightly newer version. Remove this when winit upgrades past this version.
-wayland-cursor = { version = "0.31.1", default-features = false, optional = true }
+wayland-cursor = { workspace = true, optional = true }
 
 [target.'cfg(not(target_os = "android"))'.dependencies]
-arboard = { version = "3.3", optional = true, default-features = false, features = [
-    "image-data",
-] }
+arboard = { workspace = true, optional = true, features = ["image-data"] }
diff --git a/crates/egui-winit/src/clipboard.rs b/crates/egui-winit/src/clipboard.rs
index c8adcad21..fc7334388 100644
--- a/crates/egui-winit/src/clipboard.rs
+++ b/crates/egui-winit/src/clipboard.rs
@@ -5,7 +5,10 @@ use raw_window_handle::RawDisplayHandle;
 /// If the "clipboard" feature is off, or we cannot connect to the OS clipboard,
 /// then a fallback clipboard that just works within the same app is used instead.
 pub struct Clipboard {
-    #[cfg(all(feature = "arboard", not(target_os = "android")))]
+    #[cfg(all(
+        not(any(target_os = "android", target_os = "ios")),
+        feature = "arboard",
+    ))]
     arboard: Option<arboard::Clipboard>,
 
     #[cfg(all(
@@ -28,7 +31,10 @@ impl Clipboard {
     /// Construct a new instance
     pub fn new(_raw_display_handle: Option<RawDisplayHandle>) -> Self {
         Self {
-            #[cfg(all(feature = "arboard", not(target_os = "android")))]
+            #[cfg(all(
+                not(any(target_os = "android", target_os = "ios")),
+                feature = "arboard",
+            ))]
             arboard: init_arboard(),
 
             #[cfg(all(
@@ -68,7 +74,10 @@ impl Clipboard {
             };
         }
 
-        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        #[cfg(all(
+            not(any(target_os = "android", target_os = "ios")),
+            feature = "arboard",
+        ))]
         if let Some(clipboard) = &mut self.arboard {
             return match clipboard.get_text() {
                 Ok(text) => Some(text),
@@ -98,7 +107,10 @@ impl Clipboard {
             return;
         }
 
-        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        #[cfg(all(
+            not(any(target_os = "android", target_os = "ios")),
+            feature = "arboard",
+        ))]
         if let Some(clipboard) = &mut self.arboard {
             if let Err(err) = clipboard.set_text(text) {
                 log::error!("arboard copy/cut error: {err}");
@@ -110,7 +122,10 @@ impl Clipboard {
     }
 
     pub fn set_image(&mut self, image: &egui::ColorImage) {
-        #[cfg(all(feature = "arboard", not(target_os = "android")))]
+        #[cfg(all(
+            not(any(target_os = "android", target_os = "ios")),
+            feature = "arboard",
+        ))]
         if let Some(clipboard) = &mut self.arboard {
             if let Err(err) = clipboard.set_image(arboard::ImageData {
                 width: image.width(),
@@ -123,12 +138,17 @@ impl Clipboard {
             return;
         }
 
-        log::error!("Copying images is not supported. Enable the 'clipboard' feature of `egui-winit` to enable it.");
+        log::error!(
+            "Copying images is not supported. Enable the 'clipboard' feature of `egui-winit` to enable it."
+        );
         _ = image;
     }
 }
 
-#[cfg(all(feature = "arboard", not(target_os = "android")))]
+#[cfg(all(
+    not(any(target_os = "android", target_os = "ios")),
+    feature = "arboard",
+))]
 fn init_arboard() -> Option<arboard::Clipboard> {
     profiling::function_scope!();
 
@@ -161,7 +181,7 @@ fn init_smithay_clipboard(
 
     if let Some(RawDisplayHandle::Wayland(display)) = raw_display_handle {
         log::trace!("Initializing smithay clipboard…");
-        #[allow(unsafe_code)]
+        #[expect(unsafe_code)]
         Some(unsafe { smithay_clipboard::Clipboard::new(display.display.as_ptr()) })
     } else {
         #[cfg(feature = "wayland")]
diff --git a/crates/egui-winit/src/lib.rs b/crates/egui-winit/src/lib.rs
index 147ab7186..7660e3cef 100644
--- a/crates/egui-winit/src/lib.rs
+++ b/crates/egui-winit/src/lib.rs
@@ -18,11 +18,11 @@ use egui::{Pos2, Rect, Theme, Vec2, ViewportBuilder, ViewportCommand, ViewportId
 pub use winit;
 
 pub mod clipboard;
+mod safe_area;
 mod window_settings;
 
 pub use window_settings::WindowSettings;
 
-use ahash::HashSet;
 use raw_window_handle::HasDisplayHandle;
 
 use winit::{
@@ -166,12 +166,14 @@ impl State {
     #[cfg(feature = "accesskit")]
     pub fn init_accesskit<T: From<accesskit_winit::Event> + Send>(
         &mut self,
+        event_loop: &ActiveEventLoop,
         window: &Window,
         event_loop_proxy: winit::event_loop::EventLoopProxy<T>,
     ) {
         profiling::function_scope!();
 
         self.accesskit = Some(accesskit_winit::Adapter::with_event_loop_proxy(
+            event_loop,
             window,
             event_loop_proxy,
         ));
@@ -273,6 +275,21 @@ impl State {
         }
 
         use winit::event::WindowEvent;
+
+        #[cfg(target_os = "ios")]
+        match &event {
+            WindowEvent::Resized(_)
+            | WindowEvent::ScaleFactorChanged { .. }
+            | WindowEvent::Focused(true)
+            | WindowEvent::Occluded(false) => {
+                // Once winit v0.31 has been released this can be reworked to get the safe area from
+                // `Window::safe_area`, and updated from a new event which is being discussed in
+                // https://github.com/rust-windowing/winit/issues/3911.
+                self.egui_input_mut().safe_area_insets = Some(safe_area::get_safe_area_insets());
+            }
+            _ => {}
+        }
+
         match event {
             WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
                 let native_pixels_per_point = *scale_factor as f32;
@@ -295,8 +312,8 @@ impl State {
                     consumed: self.egui_ctx.wants_pointer_input(),
                 }
             }
-            WindowEvent::MouseWheel { delta, .. } => {
-                self.on_mouse_wheel(window, *delta);
+            WindowEvent::MouseWheel { delta, phase, .. } => {
+                self.on_mouse_wheel(window, *delta, *phase);
                 EventResponse {
                     repaint: true,
                     consumed: self.egui_ctx.wants_pointer_input(),
@@ -371,7 +388,7 @@ impl State {
                     winit::event::Ime::Disabled | winit::event::Ime::Preedit(_, None) => {
                         self.ime_event_disable();
                     }
-                };
+                }
 
                 EventResponse {
                     repaint: true,
@@ -406,10 +423,19 @@ impl State {
                 }
             }
             WindowEvent::Focused(focused) => {
-                self.egui_input.focused = *focused;
+                let focused = if cfg!(target_os = "macos") {
+                    // TODO(emilk): remove this work-around once we update winit
+                    // https://github.com/rust-windowing/winit/issues/4371
+                    // https://github.com/emilk/egui/issues/7588
+                    window.has_focus()
+                } else {
+                    *focused
+                };
+
+                self.egui_input.focused = focused;
                 self.egui_input
                     .events
-                    .push(egui::Event::WindowFocused(*focused));
+                    .push(egui::Event::WindowFocused(focused));
                 EventResponse {
                     repaint: true,
                     consumed: false,
@@ -490,9 +516,7 @@ impl State {
             // Things we completely ignore:
             WindowEvent::ActivationTokenDone { .. }
             | WindowEvent::AxisMotion { .. }
-            | WindowEvent::DoubleTapGesture { .. }
-            | WindowEvent::RotationGesture { .. }
-            | WindowEvent::PanGesture { .. } => EventResponse {
+            | WindowEvent::DoubleTapGesture { .. } => EventResponse {
                 repaint: false,
                 consumed: false,
             },
@@ -507,6 +531,34 @@ impl State {
                     consumed: self.egui_ctx.wants_pointer_input(),
                 }
             }
+
+            WindowEvent::RotationGesture { delta, .. } => {
+                // Positive delta values indicate counterclockwise rotation
+                // Negative delta values indicate clockwise rotation
+                // This is opposite of egui's sign convention for angles
+                self.egui_input
+                    .events
+                    .push(egui::Event::Rotate(-delta.to_radians()));
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.wants_pointer_input(),
+                }
+            }
+
+            WindowEvent::PanGesture { delta, phase, .. } => {
+                let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
+
+                self.egui_input.events.push(egui::Event::MouseWheel {
+                    unit: egui::MouseWheelUnit::Point,
+                    delta: Vec2::new(delta.x, delta.y) / pixels_per_point,
+                    phase: to_egui_touch_phase(*phase),
+                    modifiers: self.egui_input.modifiers,
+                });
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.wants_pointer_input(),
+                }
+            }
         }
     }
 
@@ -548,41 +600,41 @@ impl State {
         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;
+        if let Some(pos) = self.pointer_pos_in_points
+            && 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,
-                });
+            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;
+            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: None,
-                        });
-                    } else {
-                        self.any_pointer_button_down = false;
+                    self.egui_input.events.push(egui::Event::Touch {
+                        device_id: egui::TouchDeviceId(0),
+                        id: egui::TouchId(0),
+                        phase: egui::TouchPhase::Start,
+                        pos,
+                        force: None,
+                    });
+                } else {
+                    self.any_pointer_button_down = false;
 
-                        self.egui_input.events.push(egui::Event::PointerGone);
+                    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: None,
-                        });
-                    };
+                    self.egui_input.events.push(egui::Event::Touch {
+                        device_id: egui::TouchDeviceId(0),
+                        id: egui::TouchId(0),
+                        phase: egui::TouchPhase::End,
+                        pos,
+                        force: None,
+                    });
                 }
             }
         }
@@ -629,12 +681,7 @@ impl State {
         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,
-            },
+            phase: to_egui_touch_phase(touch.phase),
             pos: egui::pos2(
                 touch.location.x as f32 / pixels_per_point,
                 touch.location.y as f32 / pixels_per_point,
@@ -687,7 +734,12 @@ impl State {
         }
     }
 
-    fn on_mouse_wheel(&mut self, window: &Window, delta: winit::event::MouseScrollDelta) {
+    fn on_mouse_wheel(
+        &mut self,
+        window: &Window,
+        delta: winit::event::MouseScrollDelta,
+        phase: winit::event::TouchPhase,
+    ) {
         let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
 
         {
@@ -703,10 +755,12 @@ impl State {
                     egui::vec2(x as f32, y as f32) / pixels_per_point,
                 ),
             };
+            let phase = to_egui_touch_phase(phase);
             let modifiers = self.egui_input.modifiers;
             self.egui_input.events.push(egui::Event::MouseWheel {
                 unit,
                 delta,
+                phase,
                 modifiers,
             });
         }
@@ -727,7 +781,7 @@ impl State {
             // When telling users "Press Ctrl-F to find", this is where we should
             // look for the "F" key, because they may have a dvorak layout on
             // a qwerty keyboard, and so the logical "F" character may not be located on the physical `KeyCode::KeyF` position.
-            logical_key,
+            logical_key: winit_logical_key,
 
             text,
 
@@ -746,7 +800,7 @@ impl State {
             None
         };
 
-        let logical_key = key_from_winit_key(logical_key);
+        let logical_key = key_from_winit_key(winit_logical_key);
 
         // Helpful logging to enable when adding new key support
         log::trace!(
@@ -789,7 +843,11 @@ impl State {
             });
         }
 
-        if let Some(text) = &text {
+        if let Some(text) = text
+            .as_ref()
+            .map(|t| t.as_str())
+            .or_else(|| winit_logical_key.to_text())
+        {
             // Make sure there is text, and that it is not control characters
             // (e.g. delete is sent as "\u{f728}" on macOS).
             if !text.is_empty() && text.chars().all(is_printable_char) {
@@ -803,7 +861,7 @@ impl State {
                 if pressed && !is_cmd {
                     self.egui_input
                         .events
-                        .push(egui::Event::Text(text.to_string()));
+                        .push(egui::Event::Text(text.to_owned()));
                 }
             }
         }
@@ -822,18 +880,14 @@ impl State {
         window: &Window,
         platform_output: egui::PlatformOutput,
     ) {
-        #![allow(deprecated)]
         profiling::function_scope!();
 
         let egui::PlatformOutput {
             commands,
             cursor_icon,
-            open_url,
-            copied_text,
             events: _,                    // handled elsewhere
             mutable_text_under_cursor: _, // only used in eframe web
             ime,
-            #[cfg(feature = "accesskit")]
             accesskit_update,
             num_completed_passes: _,    // `egui::Context::run` handles this
             request_discard_reasons: _, // `egui::Context::run` handles this
@@ -855,14 +909,6 @@ impl State {
 
         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_text(copied_text);
-        }
-
         let allow_ime = ime.is_some();
         if self.allow_ime != allow_ime {
             self.allow_ime = allow_ime;
@@ -894,12 +940,15 @@ impl State {
         }
 
         #[cfg(feature = "accesskit")]
-        if let Some(accesskit) = self.accesskit.as_mut() {
-            if let Some(update) = accesskit_update {
-                profiling::scope!("accesskit");
-                accesskit.update_if_active(|| update);
-            }
+        if let Some(accesskit) = self.accesskit.as_mut()
+            && let Some(update) = accesskit_update
+        {
+            profiling::scope!("accesskit");
+            accesskit.update_if_active(|| update);
         }
+
+        #[cfg(not(feature = "accesskit"))]
+        let _ = accesskit_update;
     }
 
     fn set_cursor_icon(&mut self, window: &Window, cursor_icon: egui::CursorIcon) {
@@ -926,6 +975,15 @@ impl State {
     }
 }
 
+fn to_egui_touch_phase(phase: winit::event::TouchPhase) -> egui::TouchPhase {
+    match 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,
+    }
+}
+
 fn to_egui_theme(theme: winit::window::Theme) -> Theme {
     match theme {
         winit::window::Theme::Dark => Theme::Dark,
@@ -1020,7 +1078,7 @@ pub fn update_viewport_info(
 fn open_url_in_browser(_url: &str) {
     #[cfg(feature = "webbrowser")]
     if let Err(err) = webbrowser::open(_url) {
-        log::warn!("Failed to open url: {}", err);
+        log::warn!("Failed to open url: {err}");
     }
 
     #[cfg(not(feature = "webbrowser"))]
@@ -1138,6 +1196,8 @@ fn key_from_named_key(named_key: winit::keyboard::NamedKey) -> Option<egui::Key>
         NamedKey::F33 => Key::F33,
         NamedKey::F34 => Key::F34,
         NamedKey::F35 => Key::F35,
+
+        NamedKey::BrowserBack => Key::BrowserBack,
         _ => {
             log::trace!("Unknown key: {named_key:?}");
             return None;
@@ -1326,7 +1386,7 @@ pub fn process_viewport_commands(
     info: &mut ViewportInfo,
     commands: impl IntoIterator<Item = ViewportCommand>,
     window: &Window,
-    actions_requested: &mut HashSet<ActionRequested>,
+    actions_requested: &mut Vec<ActionRequested>,
 ) {
     for command in commands {
         process_viewport_command(egui_ctx, window, command, info, actions_requested);
@@ -1338,9 +1398,9 @@ fn process_viewport_command(
     window: &Window,
     command: ViewportCommand,
     info: &mut ViewportInfo,
-    actions_requested: &mut HashSet<ActionRequested>,
+    actions_requested: &mut Vec<ActionRequested>,
 ) {
-    profiling::function_scope!();
+    profiling::function_scope!(&format!("{command:?}"));
 
     use winit::window::ResizeDirection;
 
@@ -1357,10 +1417,10 @@ fn process_viewport_command(
         }
         ViewportCommand::StartDrag => {
             // If `.has_focus()` is not checked on x11 the input will be permanently taken until the app is killed!
-            if window.has_focus() {
-                if let Err(err) = window.drag_window() {
-                    log::warn!("{command:?}: {err}");
-                }
+            if window.has_focus()
+                && let Err(err) = window.drag_window()
+            {
+                log::warn!("{command:?}: {err}");
             }
         }
         ViewportCommand::InnerSize(size) => {
@@ -1531,16 +1591,16 @@ fn process_viewport_command(
             }
         }
         ViewportCommand::Screenshot(user_data) => {
-            actions_requested.insert(ActionRequested::Screenshot(user_data));
+            actions_requested.push(ActionRequested::Screenshot(user_data));
         }
         ViewportCommand::RequestCut => {
-            actions_requested.insert(ActionRequested::Cut);
+            actions_requested.push(ActionRequested::Cut);
         }
         ViewportCommand::RequestCopy => {
-            actions_requested.insert(ActionRequested::Copy);
+            actions_requested.push(ActionRequested::Copy);
         }
         ViewportCommand::RequestPaste => {
-            actions_requested.insert(ActionRequested::Paste);
+            actions_requested.push(ActionRequested::Paste);
         }
     }
 }
@@ -1558,8 +1618,7 @@ pub fn create_window(
 ) -> Result<Window, winit::error::OsError> {
     profiling::function_scope!();
 
-    let window_attributes =
-        create_winit_window_attributes(egui_ctx, event_loop, viewport_builder.clone());
+    let window_attributes = create_winit_window_attributes(egui_ctx, viewport_builder.clone());
     let window = event_loop.create_window(window_attributes)?;
     apply_viewport_builder_to_window(egui_ctx, &window, viewport_builder);
     Ok(window)
@@ -1567,28 +1626,10 @@ pub fn create_window(
 
 pub fn create_winit_window_attributes(
     egui_ctx: &egui::Context,
-    event_loop: &ActiveEventLoop,
     viewport_builder: ViewportBuilder,
 ) -> winit::window::WindowAttributes {
     profiling::function_scope!();
 
-    // We set sizes and positions in egui:s own ui points, which depends on the egui
-    // zoom_factor and the native pixels per point, so we need to know that here.
-    // We don't know what monitor the window will appear on though, but
-    // we'll try to fix that after the window is created in the call to `apply_viewport_builder_to_window`.
-    let native_pixels_per_point = event_loop
-        .primary_monitor()
-        .or_else(|| event_loop.available_monitors().next())
-        .map_or_else(
-            || {
-                log::debug!("Failed to find a monitor - assuming native_pixels_per_point of 1.0");
-                1.0
-            },
-            |m| m.scale_factor() as f32,
-        );
-    let zoom_factor = egui_ctx.zoom_factor();
-    let pixels_per_point = zoom_factor * native_pixels_per_point;
-
     let ViewportBuilder {
         title,
         position,
@@ -1610,9 +1651,11 @@ pub fn create_winit_window_attributes(
 
         // macOS:
         fullsize_content_view: _fullsize_content_view,
+        movable_by_window_background: _movable_by_window_background,
         title_shown: _title_shown,
         titlebar_buttons_shown: _titlebar_buttons_shown,
         titlebar_shown: _titlebar_shown,
+        has_shadow: _has_shadow,
 
         // Windows:
         drag_and_drop: _drag_and_drop,
@@ -1662,40 +1705,46 @@ pub fn create_winit_window_attributes(
         })
         .with_active(active.unwrap_or(true));
 
+    // Here and below: we create `LogicalSize` / `LogicalPosition` taking
+    // zoom factor into account. We don't have a good way to get physical size here,
+    // and trying to do it anyway leads to weird bugs on Wayland, see:
+    // https://github.com/emilk/egui/issues/7095#issuecomment-2920545377
+    // https://github.com/rust-windowing/winit/issues/4266
+    #[expect(
+        clippy::disallowed_types,
+        reason = "zoom factor is manually accounted for"
+    )]
     #[cfg(not(target_os = "ios"))]
-    if let Some(size) = inner_size {
-        window_attributes = window_attributes.with_inner_size(PhysicalSize::new(
-            pixels_per_point * size.x,
-            pixels_per_point * size.y,
-        ));
-    }
+    {
+        use winit::dpi::{LogicalPosition, LogicalSize};
+        let zoom_factor = egui_ctx.zoom_factor();
 
-    #[cfg(not(target_os = "ios"))]
-    if let Some(size) = min_inner_size {
-        window_attributes = window_attributes.with_min_inner_size(PhysicalSize::new(
-            pixels_per_point * size.x,
-            pixels_per_point * size.y,
-        ));
-    }
+        if let Some(size) = inner_size {
+            window_attributes = window_attributes
+                .with_inner_size(LogicalSize::new(zoom_factor * size.x, zoom_factor * size.y));
+        }
 
-    #[cfg(not(target_os = "ios"))]
-    if let Some(size) = max_inner_size {
-        window_attributes = window_attributes.with_max_inner_size(PhysicalSize::new(
-            pixels_per_point * size.x,
-            pixels_per_point * size.y,
-        ));
-    }
+        if let Some(size) = min_inner_size {
+            window_attributes = window_attributes
+                .with_min_inner_size(LogicalSize::new(zoom_factor * size.x, zoom_factor * size.y));
+        }
 
-    #[cfg(not(target_os = "ios"))]
-    if let Some(pos) = position {
-        window_attributes = window_attributes.with_position(PhysicalPosition::new(
-            pixels_per_point * pos.x,
-            pixels_per_point * pos.y,
-        ));
+        if let Some(size) = max_inner_size {
+            window_attributes = window_attributes
+                .with_max_inner_size(LogicalSize::new(zoom_factor * size.x, zoom_factor * size.y));
+        }
+
+        if let Some(pos) = position {
+            window_attributes = window_attributes.with_position(LogicalPosition::new(
+                zoom_factor * pos.x,
+                zoom_factor * pos.y,
+            ));
+        }
     }
     #[cfg(target_os = "ios")]
     {
         // Unused:
+        _ = egui_ctx;
         _ = pixels_per_point;
         _ = position;
         _ = inner_size;
@@ -1756,7 +1805,9 @@ pub fn create_winit_window_attributes(
             .with_title_hidden(!_title_shown.unwrap_or(true))
             .with_titlebar_buttons_hidden(!_titlebar_buttons_shown.unwrap_or(true))
             .with_titlebar_transparent(!_titlebar_shown.unwrap_or(true))
-            .with_fullsize_content_view(_fullsize_content_view.unwrap_or(false));
+            .with_fullsize_content_view(_fullsize_content_view.unwrap_or(false))
+            .with_movable_by_window_background(_movable_by_window_background.unwrap_or(false))
+            .with_has_shadow(_has_shadow.unwrap_or(true));
     }
 
     window_attributes
@@ -1783,10 +1834,10 @@ pub fn apply_viewport_builder_to_window(
     window: &Window,
     builder: &ViewportBuilder,
 ) {
-    if let Some(mouse_passthrough) = builder.mouse_passthrough {
-        if let Err(err) = window.set_cursor_hittest(!mouse_passthrough) {
-            log::warn!("set_cursor_hittest failed: {err}");
-        }
+    if let Some(mouse_passthrough) = builder.mouse_passthrough
+        && let Err(err) = window.set_cursor_hittest(!mouse_passthrough)
+    {
+        log::warn!("set_cursor_hittest failed: {err}");
     }
 
     {
@@ -1797,16 +1848,15 @@ pub fn apply_viewport_builder_to_window(
 
         let pixels_per_point = pixels_per_point(egui_ctx, window);
 
-        if let Some(size) = builder.inner_size {
-            if window
+        if let Some(size) = builder.inner_size
+            && window
                 .request_inner_size(PhysicalSize::new(
                     pixels_per_point * size.x,
                     pixels_per_point * size.y,
                 ))
                 .is_some()
-            {
-                log::debug!("Failed to set window size");
-            }
+        {
+            log::debug!("Failed to set window size");
         }
         if let Some(size) = builder.min_inner_size {
             window.set_min_inner_size(Some(PhysicalSize::new(
@@ -1838,8 +1888,8 @@ pub fn short_device_event_description(event: &winit::event::DeviceEvent) -> &'st
     use winit::event::DeviceEvent;
 
     match event {
-        DeviceEvent::Added { .. } => "DeviceEvent::Added",
-        DeviceEvent::Removed { .. } => "DeviceEvent::Removed",
+        DeviceEvent::Added => "DeviceEvent::Added",
+        DeviceEvent::Removed => "DeviceEvent::Removed",
         DeviceEvent::MouseMotion { .. } => "DeviceEvent::MouseMotion",
         DeviceEvent::MouseWheel { .. } => "DeviceEvent::MouseWheel",
         DeviceEvent::Motion { .. } => "DeviceEvent::Motion",
@@ -1857,11 +1907,11 @@ pub fn short_window_event_description(event: &winit::event::WindowEvent) -> &'st
         WindowEvent::ActivationTokenDone { .. } => "WindowEvent::ActivationTokenDone",
         WindowEvent::Resized { .. } => "WindowEvent::Resized",
         WindowEvent::Moved { .. } => "WindowEvent::Moved",
-        WindowEvent::CloseRequested { .. } => "WindowEvent::CloseRequested",
-        WindowEvent::Destroyed { .. } => "WindowEvent::Destroyed",
+        WindowEvent::CloseRequested => "WindowEvent::CloseRequested",
+        WindowEvent::Destroyed => "WindowEvent::Destroyed",
         WindowEvent::DroppedFile { .. } => "WindowEvent::DroppedFile",
         WindowEvent::HoveredFile { .. } => "WindowEvent::HoveredFile",
-        WindowEvent::HoveredFileCancelled { .. } => "WindowEvent::HoveredFileCancelled",
+        WindowEvent::HoveredFileCancelled => "WindowEvent::HoveredFileCancelled",
         WindowEvent::Focused { .. } => "WindowEvent::Focused",
         WindowEvent::KeyboardInput { .. } => "WindowEvent::KeyboardInput",
         WindowEvent::ModifiersChanged { .. } => "WindowEvent::ModifiersChanged",
@@ -1872,7 +1922,7 @@ pub fn short_window_event_description(event: &winit::event::WindowEvent) -> &'st
         WindowEvent::MouseWheel { .. } => "WindowEvent::MouseWheel",
         WindowEvent::MouseInput { .. } => "WindowEvent::MouseInput",
         WindowEvent::PinchGesture { .. } => "WindowEvent::PinchGesture",
-        WindowEvent::RedrawRequested { .. } => "WindowEvent::RedrawRequested",
+        WindowEvent::RedrawRequested => "WindowEvent::RedrawRequested",
         WindowEvent::DoubleTapGesture { .. } => "WindowEvent::DoubleTapGesture",
         WindowEvent::RotationGesture { .. } => "WindowEvent::RotationGesture",
         WindowEvent::TouchpadPressure { .. } => "WindowEvent::TouchpadPressure",
diff --git a/crates/egui-winit/src/safe_area.rs b/crates/egui-winit/src/safe_area.rs
new file mode 100644
index 000000000..d29d654a3
--- /dev/null
+++ b/crates/egui-winit/src/safe_area.rs
@@ -0,0 +1,56 @@
+#[cfg(target_os = "ios")]
+pub use ios::get_safe_area_insets;
+
+#[cfg(target_os = "ios")]
+mod ios {
+    use egui::{SafeAreaInsets, epaint::MarginF32};
+    use objc2::{ClassType, rc::Retained};
+    use objc2_foundation::{MainThreadMarker, NSObjectProtocol};
+    use objc2_ui_kit::{UIApplication, UISceneActivationState, UIWindowScene};
+
+    /// Gets the ios safe area insets.
+    ///
+    /// A safe area defines the area within a view that isn’t covered by a navigation bar, tab bar,
+    /// toolbar, or other views a window might provide. Safe areas are essential for avoiding a
+    /// device’s interactive and display features, like Dynamic Island on iPhone or the camera
+    /// housing on some Mac models.
+    ///
+    /// Once winit v0.31 has been released this can be removed in favor of
+    /// `winit::Window::safe_area`.
+    pub fn get_safe_area_insets() -> SafeAreaInsets {
+        let Some(main_thread_marker) = MainThreadMarker::new() else {
+            log::error!("Getting safe area insets needs to be performed on the main thread");
+            return SafeAreaInsets::default();
+        };
+
+        let app = UIApplication::sharedApplication(main_thread_marker);
+
+        #[allow(unsafe_code)]
+        unsafe {
+            // Look for the first window scene that's in the foreground
+            for scene in app.connectedScenes() {
+                if scene.isKindOfClass(UIWindowScene::class())
+                    && matches!(
+                        scene.activationState(),
+                        UISceneActivationState::ForegroundActive
+                            | UISceneActivationState::ForegroundInactive
+                    )
+                {
+                    // Safe to cast, the class kind was checked above
+                    let window_scene = Retained::cast::<UIWindowScene>(scene.clone());
+                    if let Some(window) = window_scene.keyWindow() {
+                        let insets = window.safeAreaInsets();
+                        return SafeAreaInsets(MarginF32 {
+                            top: insets.top as f32,
+                            left: insets.left as f32,
+                            right: insets.right as f32,
+                            bottom: insets.bottom as f32,
+                        });
+                    }
+                }
+            }
+        }
+
+        SafeAreaInsets::default()
+    }
+}
diff --git a/crates/egui/Cargo.toml b/crates/egui/Cargo.toml
index d0407b1c3..764d2401e 100644
--- a/crates/egui/Cargo.toml
+++ b/crates/egui/Cargo.toml
@@ -26,10 +26,6 @@ rustdoc-args = ["--generate-link-to-definition"]
 [features]
 default = ["default_fonts"]
 
-## Exposes detailed accessibility implementation required by platform
-## accessibility APIs. Also requires support in the egui integration.
-accesskit = ["dep:accesskit"]
-
 ## [`bytemuck`](https://docs.rs/bytemuck) enables you to cast [`epaint::Vertex`], [`emath::Vec2`] etc to `&[u8]`.
 bytemuck = ["epaint/bytemuck"]
 
@@ -44,18 +40,10 @@ 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"]
 
-## Turn on the `log` feature, that makes egui log some errors using the [`log`](https://docs.rs/log) crate.
-log = ["dep:log", "epaint/log"]
-
 ## [`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"]
 
@@ -69,7 +57,7 @@ persistence = ["serde", "epaint/serde", "ron"]
 rayon = ["epaint/rayon"]
 
 ## Allow serialization using [`serde`](https://docs.rs/serde).
-serde = ["dep:serde", "epaint/serde", "accesskit?/serde"]
+serde = ["dep:serde", "epaint/serde", "accesskit/serde"]
 
 ## Change Vertex layout to be compatible with unity
 unity = ["epaint/unity"]
@@ -83,19 +71,21 @@ _override_unity = ["epaint/_override_unity"]
 emath = { workspace = true, default-features = false }
 epaint = { workspace = true, default-features = false }
 
+accesskit.workspace = true
 ahash.workspace = true
 bitflags.workspace = true
+log.workspace = true
 nohash-hasher.workspace = true
 profiling.workspace = true
+smallvec.workspace = true
+unicode-segmentation.workspace = true
 
 #! ### Optional dependencies
-accesskit = { version = "0.17.0", optional = true }
 
 backtrace = { workspace = true, optional = true }
 
 ## Enable this when generating docs.
 document-features = { workspace = true, optional = true }
 
-log = { workspace = true, optional = true }
 ron = { workspace = true, optional = true }
 serde = { workspace = true, optional = true, features = ["derive", "rc"] }
diff --git a/crates/egui/examples/README.md b/crates/egui/examples/README.md
index e4d19c83d..357c97d21 100644
--- a/crates/egui/examples/README.md
+++ b/crates/egui/examples/README.md
@@ -1,7 +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.
+See the top-level [examples](https://github.com/emilk/egui/tree/main/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>.
+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/main/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/crates/egui/src/animation_manager.rs b/crates/egui/src/animation_manager.rs
index 15002141f..50f97e992 100644
--- a/crates/egui/src/animation_manager.rs
+++ b/crates/egui/src/animation_manager.rs
@@ -1,6 +1,6 @@
 use crate::{
-    emath::{remap_clamp, NumExt as _},
     Id, IdMap, InputState,
+    emath::{NumExt as _, remap_clamp},
 };
 
 #[derive(Clone, Default)]
diff --git a/crates/egui/src/atomics/atom.rs b/crates/egui/src/atomics/atom.rs
new file mode 100644
index 000000000..6425ac724
--- /dev/null
+++ b/crates/egui/src/atomics/atom.rs
@@ -0,0 +1,112 @@
+use crate::{AtomKind, FontSelection, Id, SizedAtom, Ui};
+use emath::{NumExt as _, Vec2};
+use epaint::text::TextWrapMode;
+
+/// A low-level ui building block.
+///
+/// Implements [`From`] for [`String`], [`str`], [`crate::Image`] and much more for convenience.
+/// You can directly call the `atom_*` methods on anything that implements `Into<Atom>`.
+/// ```
+/// # use egui::{Image, emath::Vec2};
+/// use egui::AtomExt as _;
+/// let string_atom = "Hello".atom_grow(true);
+/// let image_atom = Image::new("some_image_url").atom_size(Vec2::splat(20.0));
+/// ```
+#[derive(Clone, Debug)]
+pub struct Atom<'a> {
+    /// See [`crate::AtomExt::atom_size`]
+    pub size: Option<Vec2>,
+
+    /// See [`crate::AtomExt::atom_max_size`]
+    pub max_size: Vec2,
+
+    /// See [`crate::AtomExt::atom_grow`]
+    pub grow: bool,
+
+    /// See [`crate::AtomExt::atom_shrink`]
+    pub shrink: bool,
+
+    /// The atom type
+    pub kind: AtomKind<'a>,
+}
+
+impl Default for Atom<'_> {
+    fn default() -> Self {
+        Atom {
+            size: None,
+            max_size: Vec2::INFINITY,
+            grow: false,
+            shrink: false,
+            kind: AtomKind::Empty,
+        }
+    }
+}
+
+impl<'a> Atom<'a> {
+    /// Create an empty [`Atom`] marked as `grow`.
+    ///
+    /// This will expand in size, allowing all preceding atoms to be left-aligned,
+    /// and all following atoms to be right-aligned
+    pub fn grow() -> Self {
+        Atom {
+            grow: true,
+            ..Default::default()
+        }
+    }
+
+    /// Create a [`AtomKind::Custom`] with a specific size.
+    pub fn custom(id: Id, size: impl Into<Vec2>) -> Self {
+        Atom {
+            size: Some(size.into()),
+            kind: AtomKind::Custom(id),
+            ..Default::default()
+        }
+    }
+
+    /// Turn this into a [`SizedAtom`].
+    pub fn into_sized(
+        self,
+        ui: &Ui,
+        mut available_size: Vec2,
+        mut wrap_mode: Option<TextWrapMode>,
+        fallback_font: FontSelection,
+    ) -> SizedAtom<'a> {
+        if !self.shrink && self.max_size.x.is_infinite() {
+            wrap_mode = Some(TextWrapMode::Extend);
+        }
+        available_size = available_size.at_most(self.max_size);
+        if let Some(size) = self.size {
+            available_size = available_size.at_most(size);
+        }
+        if self.max_size.x.is_finite() {
+            wrap_mode = Some(TextWrapMode::Truncate);
+        }
+
+        let (intrinsic, kind) = self
+            .kind
+            .into_sized(ui, available_size, wrap_mode, fallback_font);
+
+        let size = self
+            .size
+            .map_or_else(|| kind.size(), |s| s.at_most(self.max_size));
+
+        SizedAtom {
+            size,
+            intrinsic_size: intrinsic.at_least(self.size.unwrap_or_default()),
+            grow: self.grow,
+            kind,
+        }
+    }
+}
+
+impl<'a, T> From<T> for Atom<'a>
+where
+    T: Into<AtomKind<'a>>,
+{
+    fn from(value: T) -> Self {
+        Atom {
+            kind: value.into(),
+            ..Default::default()
+        }
+    }
+}
diff --git a/crates/egui/src/atomics/atom_ext.rs b/crates/egui/src/atomics/atom_ext.rs
new file mode 100644
index 000000000..6d008b84b
--- /dev/null
+++ b/crates/egui/src/atomics/atom_ext.rs
@@ -0,0 +1,107 @@
+use crate::{Atom, FontSelection, Ui};
+use emath::Vec2;
+
+/// A trait for conveniently building [`Atom`]s.
+///
+/// The functions are prefixed with `atom_` to avoid conflicts with e.g. [`crate::RichText::size`].
+pub trait AtomExt<'a> {
+    /// Set the atom to a fixed size.
+    ///
+    /// If [`Atom::grow`] is `true`, this will be the minimum width.
+    /// If [`Atom::shrink`] is `true`, this will be the maximum width.
+    /// If both are true, the width will have no effect.
+    ///
+    /// [`Self::atom_max_size`] will limit size.
+    ///
+    /// See [`crate::AtomKind`] docs to see how the size affects the different types.
+    fn atom_size(self, size: Vec2) -> Atom<'a>;
+
+    /// Grow this atom to the available space.
+    ///
+    /// This will affect the size of the [`Atom`] in the main direction. Since
+    /// [`crate::AtomLayout`] today only supports horizontal layout, it will affect the width.
+    ///
+    /// You can also combine this with [`Self::atom_shrink`] to make it always take exactly the
+    /// remaining space.
+    fn atom_grow(self, grow: bool) -> Atom<'a>;
+
+    /// Shrink this atom if there isn't enough space.
+    ///
+    /// This will affect the size of the [`Atom`] in the main direction. Since
+    /// [`crate::AtomLayout`] today only supports horizontal layout, it will affect the width.
+    ///
+    /// NOTE: Only a single [`Atom`] may shrink for each widget.
+    ///
+    /// If no atom was set to shrink and `wrap_mode != TextWrapMode::Extend`, the first
+    /// `AtomKind::Text` is set to shrink.
+    fn atom_shrink(self, shrink: bool) -> Atom<'a>;
+
+    /// Set the maximum size of this atom.
+    ///
+    /// Will not affect the space taken by `grow` (All atoms marked as grow will always grow
+    /// equally to fill the available space).
+    fn atom_max_size(self, max_size: Vec2) -> Atom<'a>;
+
+    /// Set the maximum width of this atom.
+    ///
+    /// Will not affect the space taken by `grow` (All atoms marked as grow will always grow
+    /// equally to fill the available space).
+    fn atom_max_width(self, max_width: f32) -> Atom<'a>;
+
+    /// Set the maximum height of this atom.
+    fn atom_max_height(self, max_height: f32) -> Atom<'a>;
+
+    /// Set the max height of this atom to match the font size.
+    ///
+    /// This is useful for e.g. limiting the height of icons in buttons.
+    fn atom_max_height_font_size(self, ui: &Ui) -> Atom<'a>
+    where
+        Self: Sized,
+    {
+        let font_selection = FontSelection::default();
+        let font_id = font_selection.resolve(ui.style());
+        let height = ui.fonts_mut(|f| f.row_height(&font_id));
+        self.atom_max_height(height)
+    }
+}
+
+impl<'a, T> AtomExt<'a> for T
+where
+    T: Into<Atom<'a>> + Sized,
+{
+    fn atom_size(self, size: Vec2) -> Atom<'a> {
+        let mut atom = self.into();
+        atom.size = Some(size);
+        atom
+    }
+
+    fn atom_grow(self, grow: bool) -> Atom<'a> {
+        let mut atom = self.into();
+        atom.grow = grow;
+        atom
+    }
+
+    fn atom_shrink(self, shrink: bool) -> Atom<'a> {
+        let mut atom = self.into();
+        atom.shrink = shrink;
+        atom
+    }
+
+    fn atom_max_size(self, max_size: Vec2) -> Atom<'a> {
+        let mut atom = self.into();
+        atom.max_size = max_size;
+        atom
+    }
+
+    fn atom_max_width(self, max_width: f32) -> Atom<'a> {
+        let mut atom = self.into();
+        atom.max_size.x = max_width;
+        atom
+    }
+
+    fn atom_max_height(self, max_height: f32) -> Atom<'a> {
+        let mut atom = self.into();
+        atom.max_size.y = max_height;
+        atom
+    }
+}
diff --git a/crates/egui/src/atomics/atom_kind.rs b/crates/egui/src/atomics/atom_kind.rs
new file mode 100644
index 000000000..3c54c496b
--- /dev/null
+++ b/crates/egui/src/atomics/atom_kind.rs
@@ -0,0 +1,119 @@
+use crate::{FontSelection, Id, Image, ImageSource, SizedAtomKind, Ui, WidgetText};
+use emath::Vec2;
+use epaint::text::TextWrapMode;
+
+/// The different kinds of [`crate::Atom`]s.
+#[derive(Clone, Default, Debug)]
+pub enum AtomKind<'a> {
+    /// Empty, that can be used with [`crate::AtomExt::atom_grow`] to reserve space.
+    #[default]
+    Empty,
+
+    /// Text atom.
+    ///
+    /// Truncation within [`crate::AtomLayout`] works like this:
+    /// -
+    /// - if `wrap_mode` is not Extend
+    ///   - if no atom is `shrink`
+    ///     - the first text atom is selected and will be marked as `shrink`
+    ///   - the atom marked as `shrink` will shrink / wrap based on the selected wrap mode
+    ///   - any other text atoms will have `wrap_mode` extend
+    /// - if `wrap_mode` is extend, Text will extend as expected.
+    ///
+    /// Unless [`crate::AtomExt::atom_max_width`] is set, `wrap_mode` should only be set via [`crate::Style`] or
+    /// [`crate::AtomLayout::wrap_mode`], as setting a wrap mode on a [`WidgetText`] atom
+    /// that is not `shrink` will have unexpected results.
+    ///
+    /// The size is determined by converting the [`WidgetText`] into a galley and using the galleys
+    /// size. You can use [`crate::AtomExt::atom_size`] to override this, and [`crate::AtomExt::atom_max_width`]
+    /// to limit the width (Causing the text to wrap or truncate, depending on the `wrap_mode`.
+    /// [`crate::AtomExt::atom_max_height`] has no effect on text.
+    Text(WidgetText),
+
+    /// Image atom.
+    ///
+    /// By default the size is determined via [`Image::calc_size`].
+    /// You can use [`crate::AtomExt::atom_max_size`] or [`crate::AtomExt::atom_size`] to customize the size.
+    /// There is also a helper [`crate::AtomExt::atom_max_height_font_size`] to set the max height to the
+    /// default font height, which is convenient for icons.
+    Image(Image<'a>),
+
+    /// For custom rendering.
+    ///
+    /// You can get the [`crate::Rect`] with the [`Id`] from [`crate::AtomLayoutResponse`] and use a
+    /// [`crate::Painter`] or [`Ui::place`] to add/draw some custom content.
+    ///
+    /// Example:
+    /// ```
+    /// # use egui::{AtomExt, AtomKind, Atom, Button, Id, __run_test_ui};
+    /// # use emath::Vec2;
+    /// # __run_test_ui(|ui| {
+    /// let id = Id::new("my_button");
+    /// let response = Button::new(("Hi!", Atom::custom(id, Vec2::splat(18.0)))).atom_ui(ui);
+    ///
+    /// let rect = response.rect(id);
+    /// if let Some(rect) = rect {
+    ///     ui.place(rect, Button::new("⏵"));
+    /// }
+    /// # });
+    /// ```
+    Custom(Id),
+}
+
+impl<'a> AtomKind<'a> {
+    pub fn text(text: impl Into<WidgetText>) -> Self {
+        AtomKind::Text(text.into())
+    }
+
+    pub fn image(image: impl Into<Image<'a>>) -> Self {
+        AtomKind::Image(image.into())
+    }
+
+    /// Turn this [`AtomKind`] into a [`SizedAtomKind`].
+    ///
+    /// This converts [`WidgetText`] into [`crate::Galley`] and tries to load and size [`Image`].
+    /// The first returned argument is the preferred size.
+    pub fn into_sized(
+        self,
+        ui: &Ui,
+        available_size: Vec2,
+        wrap_mode: Option<TextWrapMode>,
+        fallback_font: FontSelection,
+    ) -> (Vec2, SizedAtomKind<'a>) {
+        match self {
+            AtomKind::Text(text) => {
+                let wrap_mode = wrap_mode.unwrap_or(ui.wrap_mode());
+                let galley = text.into_galley(ui, Some(wrap_mode), available_size.x, fallback_font);
+                (galley.intrinsic_size(), SizedAtomKind::Text(galley))
+            }
+            AtomKind::Image(image) => {
+                let size = image.load_and_calc_size(ui, available_size);
+                let size = size.unwrap_or(Vec2::ZERO);
+                (size, SizedAtomKind::Image(image, size))
+            }
+            AtomKind::Custom(id) => (Vec2::ZERO, SizedAtomKind::Custom(id)),
+            AtomKind::Empty => (Vec2::ZERO, SizedAtomKind::Empty),
+        }
+    }
+}
+
+impl<'a> From<ImageSource<'a>> for AtomKind<'a> {
+    fn from(value: ImageSource<'a>) -> Self {
+        AtomKind::Image(value.into())
+    }
+}
+
+impl<'a> From<Image<'a>> for AtomKind<'a> {
+    fn from(value: Image<'a>) -> Self {
+        AtomKind::Image(value)
+    }
+}
+
+impl<T> From<T> for AtomKind<'_>
+where
+    T: Into<WidgetText>,
+{
+    fn from(value: T) -> Self {
+        AtomKind::Text(value.into())
+    }
+}
diff --git a/crates/egui/src/atomics/atom_layout.rs b/crates/egui/src/atomics/atom_layout.rs
new file mode 100644
index 000000000..1df890250
--- /dev/null
+++ b/crates/egui/src/atomics/atom_layout.rs
@@ -0,0 +1,515 @@
+use crate::atomics::ATOMS_SMALL_VEC_SIZE;
+use crate::{
+    AtomKind, Atoms, FontSelection, Frame, Id, Image, IntoAtoms, Response, Sense, SizedAtom,
+    SizedAtomKind, Ui, Widget,
+};
+use emath::{Align2, GuiRounding as _, NumExt as _, Rect, Vec2};
+use epaint::text::TextWrapMode;
+use epaint::{Color32, Galley};
+use smallvec::SmallVec;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+/// Intra-widget layout utility.
+///
+/// Used to lay out and paint [`crate::Atom`]s.
+/// This is used internally by widgets like [`crate::Button`] and [`crate::Checkbox`].
+/// You can use it to make your own widgets.
+///
+/// Painting the atoms can be split in two phases:
+/// - [`AtomLayout::allocate`]
+///   - calculates sizes
+///   - converts texts to [`Galley`]s
+///   - allocates a [`Response`]
+///   - returns a [`AllocatedAtomLayout`]
+/// - [`AllocatedAtomLayout::paint`]
+///   - paints the [`Frame`]
+///   - calculates individual [`crate::Atom`] positions
+///   - paints each single atom
+///
+/// You can use this to first allocate a response and then modify, e.g., the [`Frame`] on the
+/// [`AllocatedAtomLayout`] for interaction styling.
+pub struct AtomLayout<'a> {
+    id: Option<Id>,
+    pub atoms: Atoms<'a>,
+    gap: Option<f32>,
+    pub(crate) frame: Frame,
+    pub(crate) sense: Sense,
+    fallback_text_color: Option<Color32>,
+    fallback_font: Option<FontSelection>,
+    min_size: Vec2,
+    wrap_mode: Option<TextWrapMode>,
+    align2: Option<Align2>,
+}
+
+impl Default for AtomLayout<'_> {
+    fn default() -> Self {
+        Self::new(())
+    }
+}
+
+impl<'a> AtomLayout<'a> {
+    pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
+        Self {
+            id: None,
+            atoms: atoms.into_atoms(),
+            gap: None,
+            frame: Frame::default(),
+            sense: Sense::hover(),
+            fallback_text_color: None,
+            fallback_font: None,
+            min_size: Vec2::ZERO,
+            wrap_mode: None,
+            align2: None,
+        }
+    }
+
+    /// Set the gap between atoms.
+    ///
+    /// Default: `Spacing::icon_spacing`
+    #[inline]
+    pub fn gap(mut self, gap: f32) -> Self {
+        self.gap = Some(gap);
+        self
+    }
+
+    /// Set the [`Frame`].
+    #[inline]
+    pub fn frame(mut self, frame: Frame) -> Self {
+        self.frame = frame;
+        self
+    }
+
+    /// Set the [`Sense`] used when allocating the [`Response`].
+    #[inline]
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = sense;
+        self
+    }
+
+    /// Set the fallback (default) text color.
+    ///
+    /// Default: [`crate::Visuals::text_color`]
+    #[inline]
+    pub fn fallback_text_color(mut self, color: Color32) -> Self {
+        self.fallback_text_color = Some(color);
+        self
+    }
+
+    /// Set the fallback (default) font.
+    #[inline]
+    pub fn fallback_font(mut self, font: impl Into<FontSelection>) -> Self {
+        self.fallback_font = Some(font.into());
+        self
+    }
+
+    /// Set the minimum size of the Widget.
+    ///
+    /// This will find and expand atoms with `grow: true`.
+    /// If there are no growable atoms then everything will be left-aligned.
+    #[inline]
+    pub fn min_size(mut self, size: Vec2) -> Self {
+        self.min_size = size;
+        self
+    }
+
+    /// Set the [`Id`] used to allocate a [`Response`].
+    #[inline]
+    pub fn id(mut self, id: Id) -> Self {
+        self.id = Some(id);
+        self
+    }
+
+    /// Set the [`TextWrapMode`] for the [`crate::Atom`] marked as `shrink`.
+    ///
+    /// Only a single [`crate::Atom`] may shrink. If this (or `ui.wrap_mode()`) is not
+    /// [`TextWrapMode::Extend`] and no item is set to shrink, the first (left-most)
+    /// [`AtomKind::Text`] will be set to shrink.
+    #[inline]
+    pub fn wrap_mode(mut self, wrap_mode: TextWrapMode) -> Self {
+        self.wrap_mode = Some(wrap_mode);
+        self
+    }
+
+    /// Set the [`Align2`].
+    ///
+    /// This will align the [`crate::Atom`]s within the [`Rect`] returned by [`Ui::allocate_space`].
+    ///
+    /// The default is chosen based on the [`Ui`]s [`crate::Layout`]. See
+    /// [this snapshot](https://github.com/emilk/egui/blob/master/tests/egui_tests/tests/snapshots/layout/button.png)
+    /// for info on how the [`crate::Layout`] affects the alignment.
+    #[inline]
+    pub fn align2(mut self, align2: Align2) -> Self {
+        self.align2 = Some(align2);
+        self
+    }
+
+    /// [`AtomLayout::allocate`] and [`AllocatedAtomLayout::paint`] in one go.
+    pub fn show(self, ui: &mut Ui) -> AtomLayoutResponse {
+        self.allocate(ui).paint(ui)
+    }
+
+    /// Calculate sizes, create [`Galley`]s and allocate a [`Response`].
+    ///
+    /// Use the returned [`AllocatedAtomLayout`] for painting.
+    pub fn allocate(self, ui: &mut Ui) -> AllocatedAtomLayout<'a> {
+        let Self {
+            id,
+            mut atoms,
+            gap,
+            frame,
+            sense,
+            fallback_text_color,
+            min_size,
+            wrap_mode,
+            align2,
+            fallback_font,
+        } = self;
+
+        let fallback_font = fallback_font.unwrap_or_default();
+
+        let wrap_mode = wrap_mode.unwrap_or(ui.wrap_mode());
+
+        // If the TextWrapMode is not Extend, ensure there is some item marked as `shrink`.
+        // If none is found, mark the first text item as `shrink`.
+        if wrap_mode != TextWrapMode::Extend {
+            let any_shrink = atoms.iter().any(|a| a.shrink);
+            if !any_shrink {
+                let first_text = atoms
+                    .iter_mut()
+                    .find(|a| matches!(a.kind, AtomKind::Text(..)));
+                if let Some(atom) = first_text {
+                    atom.shrink = true; // Will make the text truncate or shrink depending on wrap_mode
+                }
+            }
+        }
+
+        let id = id.unwrap_or_else(|| ui.next_auto_id());
+
+        let fallback_text_color =
+            fallback_text_color.unwrap_or_else(|| ui.style().visuals.text_color());
+        let gap = gap.unwrap_or(ui.spacing().icon_spacing);
+
+        // The size available for the content
+        let available_inner_size = ui.available_size() - frame.total_margin().sum();
+
+        let mut desired_width = 0.0;
+
+        // intrinsic width / height is the ideal size of the widget, e.g. the size where the
+        // text is not wrapped. Used to set Response::intrinsic_size.
+        let mut intrinsic_width = 0.0;
+        let mut intrinsic_height = 0.0;
+
+        let mut height: f32 = 0.0;
+
+        let mut sized_items = SmallVec::new();
+
+        let mut grow_count = 0;
+
+        let mut shrink_item = None;
+
+        let align2 = align2.unwrap_or_else(|| {
+            Align2([ui.layout().horizontal_align(), ui.layout().vertical_align()])
+        });
+
+        if atoms.len() > 1 {
+            let gap_space = gap * (atoms.len() as f32 - 1.0);
+            desired_width += gap_space;
+            intrinsic_width += gap_space;
+        }
+
+        for (idx, item) in atoms.into_iter().enumerate() {
+            if item.grow {
+                grow_count += 1;
+            }
+            if item.shrink {
+                debug_assert!(
+                    shrink_item.is_none(),
+                    "Only one atomic may be marked as shrink. {item:?}"
+                );
+                if shrink_item.is_none() {
+                    shrink_item = Some((idx, item));
+                    continue;
+                }
+            }
+            let sized = item.into_sized(
+                ui,
+                available_inner_size,
+                Some(wrap_mode),
+                fallback_font.clone(),
+            );
+            let size = sized.size;
+
+            desired_width += size.x;
+            intrinsic_width += sized.intrinsic_size.x;
+
+            height = height.at_least(size.y);
+            intrinsic_height = intrinsic_height.at_least(sized.intrinsic_size.y);
+
+            sized_items.push(sized);
+        }
+
+        if let Some((index, item)) = shrink_item {
+            // The `shrink` item gets the remaining space
+            let available_size_for_shrink_item = Vec2::new(
+                available_inner_size.x - desired_width,
+                available_inner_size.y,
+            );
+
+            let sized = item.into_sized(
+                ui,
+                available_size_for_shrink_item,
+                Some(wrap_mode),
+                fallback_font,
+            );
+            let size = sized.size;
+
+            desired_width += size.x;
+            intrinsic_width += sized.intrinsic_size.x;
+
+            height = height.at_least(size.y);
+            intrinsic_height = intrinsic_height.at_least(sized.intrinsic_size.y);
+
+            sized_items.insert(index, sized);
+        }
+
+        let margin = frame.total_margin();
+        let desired_size = Vec2::new(desired_width, height);
+        let frame_size = (desired_size + margin.sum()).at_least(min_size);
+
+        let (_, rect) = ui.allocate_space(frame_size);
+        let mut response = ui.interact(rect, id, sense);
+
+        response.intrinsic_size =
+            Some((Vec2::new(intrinsic_width, intrinsic_height) + margin.sum()).at_least(min_size));
+
+        AllocatedAtomLayout {
+            sized_atoms: sized_items,
+            frame,
+            fallback_text_color,
+            response,
+            grow_count,
+            desired_size,
+            align2,
+            gap,
+        }
+    }
+}
+
+/// Instructions for painting an [`AtomLayout`].
+#[derive(Clone, Debug)]
+pub struct AllocatedAtomLayout<'a> {
+    pub sized_atoms: SmallVec<[SizedAtom<'a>; ATOMS_SMALL_VEC_SIZE]>,
+    pub frame: Frame,
+    pub fallback_text_color: Color32,
+    pub response: Response,
+    grow_count: usize,
+    // The size of the inner content, before any growing.
+    desired_size: Vec2,
+    align2: Align2,
+    gap: f32,
+}
+
+impl<'atom> AllocatedAtomLayout<'atom> {
+    pub fn iter_kinds(&self) -> impl Iterator<Item = &SizedAtomKind<'atom>> {
+        self.sized_atoms.iter().map(|atom| &atom.kind)
+    }
+
+    pub fn iter_kinds_mut(&mut self) -> impl Iterator<Item = &mut SizedAtomKind<'atom>> {
+        self.sized_atoms.iter_mut().map(|atom| &mut atom.kind)
+    }
+
+    pub fn iter_images(&self) -> impl Iterator<Item = &Image<'atom>> {
+        self.iter_kinds().filter_map(|kind| {
+            if let SizedAtomKind::Image(image, _) = kind {
+                Some(image)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn iter_images_mut(&mut self) -> impl Iterator<Item = &mut Image<'atom>> {
+        self.iter_kinds_mut().filter_map(|kind| {
+            if let SizedAtomKind::Image(image, _) = kind {
+                Some(image)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn iter_texts(&self) -> impl Iterator<Item = &Arc<Galley>> + use<'atom, '_> {
+        self.iter_kinds().filter_map(|kind| {
+            if let SizedAtomKind::Text(text) = kind {
+                Some(text)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn iter_texts_mut(&mut self) -> impl Iterator<Item = &mut Arc<Galley>> + use<'atom, '_> {
+        self.iter_kinds_mut().filter_map(|kind| {
+            if let SizedAtomKind::Text(text) = kind {
+                Some(text)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn map_kind<F>(&mut self, mut f: F)
+    where
+        F: FnMut(SizedAtomKind<'atom>) -> SizedAtomKind<'atom>,
+    {
+        for kind in self.iter_kinds_mut() {
+            *kind = f(std::mem::take(kind));
+        }
+    }
+
+    pub fn map_images<F>(&mut self, mut f: F)
+    where
+        F: FnMut(Image<'atom>) -> Image<'atom>,
+    {
+        self.map_kind(|kind| {
+            if let SizedAtomKind::Image(image, size) = kind {
+                SizedAtomKind::Image(f(image), size)
+            } else {
+                kind
+            }
+        });
+    }
+
+    /// Paint the [`Frame`] and individual [`crate::Atom`]s.
+    pub fn paint(self, ui: &Ui) -> AtomLayoutResponse {
+        let Self {
+            sized_atoms,
+            frame,
+            fallback_text_color,
+            response,
+            grow_count,
+            desired_size,
+            align2,
+            gap,
+        } = self;
+
+        let inner_rect = response.rect - self.frame.total_margin();
+
+        ui.painter().add(frame.paint(inner_rect));
+
+        let width_to_fill = inner_rect.width();
+        let extra_space = f32::max(width_to_fill - desired_size.x, 0.0);
+        let grow_width = f32::max(extra_space / grow_count as f32, 0.0).floor_ui();
+
+        let aligned_rect = if grow_count > 0 {
+            align2.align_size_within_rect(Vec2::new(width_to_fill, desired_size.y), inner_rect)
+        } else {
+            align2.align_size_within_rect(desired_size, inner_rect)
+        };
+
+        let mut cursor = aligned_rect.left();
+
+        let mut response = AtomLayoutResponse::empty(response);
+
+        for sized in sized_atoms {
+            let size = sized.size;
+            // TODO(lucasmerlin): This is not ideal, since this might lead to accumulated rounding errors
+            // https://github.com/emilk/egui/pull/5830#discussion_r2079627864
+            let growth = if sized.is_grow() { grow_width } else { 0.0 };
+
+            let frame = aligned_rect
+                .with_min_x(cursor)
+                .with_max_x(cursor + size.x + growth);
+            cursor = frame.right() + gap;
+
+            let align = Align2::CENTER_CENTER;
+            let rect = align.align_size_within_rect(size, frame);
+
+            match sized.kind {
+                SizedAtomKind::Text(galley) => {
+                    ui.painter().galley(rect.min, galley, fallback_text_color);
+                }
+                SizedAtomKind::Image(image, _) => {
+                    image.paint_at(ui, rect);
+                }
+                SizedAtomKind::Custom(id) => {
+                    debug_assert!(
+                        !response.custom_rects.iter().any(|(i, _)| *i == id),
+                        "Duplicate custom id"
+                    );
+                    response.custom_rects.push((id, rect));
+                }
+                SizedAtomKind::Empty => {}
+            }
+        }
+
+        response
+    }
+}
+
+/// Response from a [`AtomLayout::show`] or [`AllocatedAtomLayout::paint`].
+///
+/// Use [`AtomLayoutResponse::rect`] to get the response rects from [`AtomKind::Custom`].
+#[derive(Clone, Debug)]
+pub struct AtomLayoutResponse {
+    pub response: Response,
+    // There should rarely be more than one custom rect.
+    custom_rects: SmallVec<[(Id, Rect); 1]>,
+}
+
+impl AtomLayoutResponse {
+    pub fn empty(response: Response) -> Self {
+        Self {
+            response,
+            custom_rects: Default::default(),
+        }
+    }
+
+    pub fn custom_rects(&self) -> impl Iterator<Item = (Id, Rect)> + '_ {
+        self.custom_rects.iter().copied()
+    }
+
+    /// Use this together with [`AtomKind::Custom`] to add custom painting / child widgets.
+    ///
+    /// NOTE: Don't `unwrap` rects, they might be empty when the widget is not visible.
+    pub fn rect(&self, id: Id) -> Option<Rect> {
+        self.custom_rects
+            .iter()
+            .find_map(|(i, r)| if *i == id { Some(*r) } else { None })
+    }
+}
+
+impl Widget for AtomLayout<'_> {
+    fn ui(self, ui: &mut Ui) -> Response {
+        self.show(ui).response
+    }
+}
+
+impl<'a> Deref for AtomLayout<'a> {
+    type Target = Atoms<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.atoms
+    }
+}
+
+impl DerefMut for AtomLayout<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.atoms
+    }
+}
+
+impl<'a> Deref for AllocatedAtomLayout<'a> {
+    type Target = [SizedAtom<'a>];
+
+    fn deref(&self) -> &Self::Target {
+        &self.sized_atoms
+    }
+}
+
+impl DerefMut for AllocatedAtomLayout<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.sized_atoms
+    }
+}
diff --git a/crates/egui/src/atomics/atoms.rs b/crates/egui/src/atomics/atoms.rs
new file mode 100644
index 000000000..4b19c9e26
--- /dev/null
+++ b/crates/egui/src/atomics/atoms.rs
@@ -0,0 +1,259 @@
+use crate::{Atom, AtomKind, Image, WidgetText};
+use smallvec::SmallVec;
+use std::borrow::Cow;
+use std::ops::{Deref, DerefMut};
+
+// Rarely there should be more than 2 atoms in one Widget.
+// I guess it could happen in a menu button with Image and right text...
+pub(crate) const ATOMS_SMALL_VEC_SIZE: usize = 2;
+
+/// A list of [`Atom`]s.
+#[derive(Clone, Debug, Default)]
+pub struct Atoms<'a>(SmallVec<[Atom<'a>; ATOMS_SMALL_VEC_SIZE]>);
+
+impl<'a> Atoms<'a> {
+    pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
+        atoms.into_atoms()
+    }
+
+    /// Insert a new [`Atom`] at the end of the list (right side).
+    pub fn push_right(&mut self, atom: impl Into<Atom<'a>>) {
+        self.0.push(atom.into());
+    }
+
+    /// Insert a new [`Atom`] at the beginning of the list (left side).
+    pub fn push_left(&mut self, atom: impl Into<Atom<'a>>) {
+        self.0.insert(0, atom.into());
+    }
+
+    /// Concatenate and return the text contents.
+    // TODO(lucasmerlin): It might not always make sense to return the concatenated text, e.g.
+    // in a submenu button there is a right text '⏵' which is now passed to the screen reader.
+    pub fn text(&self) -> Option<Cow<'_, str>> {
+        let mut string: Option<Cow<'_, str>> = None;
+        for atom in &self.0 {
+            if let AtomKind::Text(text) = &atom.kind {
+                if let Some(string) = &mut string {
+                    let string = string.to_mut();
+                    string.push(' ');
+                    string.push_str(text.text());
+                } else {
+                    string = Some(Cow::Borrowed(text.text()));
+                }
+            }
+        }
+
+        // If there is no text, try to find an image with alt text.
+        if string.is_none() {
+            string = self.iter().find_map(|a| match &a.kind {
+                AtomKind::Image(image) => image.alt_text.as_deref().map(Cow::Borrowed),
+                _ => None,
+            });
+        }
+
+        string
+    }
+
+    pub fn iter_kinds(&self) -> impl Iterator<Item = &AtomKind<'a>> {
+        self.0.iter().map(|atom| &atom.kind)
+    }
+
+    pub fn iter_kinds_mut(&mut self) -> impl Iterator<Item = &mut AtomKind<'a>> {
+        self.0.iter_mut().map(|atom| &mut atom.kind)
+    }
+
+    pub fn iter_images(&self) -> impl Iterator<Item = &Image<'a>> {
+        self.iter_kinds().filter_map(|kind| {
+            if let AtomKind::Image(image) = kind {
+                Some(image)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn iter_images_mut(&mut self) -> impl Iterator<Item = &mut Image<'a>> {
+        self.iter_kinds_mut().filter_map(|kind| {
+            if let AtomKind::Image(image) = kind {
+                Some(image)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn iter_texts(&self) -> impl Iterator<Item = &WidgetText> + use<'_, 'a> {
+        self.iter_kinds().filter_map(|kind| {
+            if let AtomKind::Text(text) = kind {
+                Some(text)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn iter_texts_mut(&mut self) -> impl Iterator<Item = &mut WidgetText> + use<'a, '_> {
+        self.iter_kinds_mut().filter_map(|kind| {
+            if let AtomKind::Text(text) = kind {
+                Some(text)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn map_atoms(&mut self, mut f: impl FnMut(Atom<'a>) -> Atom<'a>) {
+        self.iter_mut()
+            .for_each(|atom| *atom = f(std::mem::take(atom)));
+    }
+
+    pub fn map_kind<F>(&mut self, mut f: F)
+    where
+        F: FnMut(AtomKind<'a>) -> AtomKind<'a>,
+    {
+        for kind in self.iter_kinds_mut() {
+            *kind = f(std::mem::take(kind));
+        }
+    }
+
+    pub fn map_images<F>(&mut self, mut f: F)
+    where
+        F: FnMut(Image<'a>) -> Image<'a>,
+    {
+        self.map_kind(|kind| {
+            if let AtomKind::Image(image) = kind {
+                AtomKind::Image(f(image))
+            } else {
+                kind
+            }
+        });
+    }
+
+    pub fn map_texts<F>(&mut self, mut f: F)
+    where
+        F: FnMut(WidgetText) -> WidgetText,
+    {
+        self.map_kind(|kind| {
+            if let AtomKind::Text(text) = kind {
+                AtomKind::Text(f(text))
+            } else {
+                kind
+            }
+        });
+    }
+}
+
+impl<'a> IntoIterator for Atoms<'a> {
+    type Item = Atom<'a>;
+    type IntoIter = smallvec::IntoIter<[Atom<'a>; ATOMS_SMALL_VEC_SIZE]>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+/// Helper trait to convert a tuple of atoms into [`Atoms`].
+///
+/// ```
+/// use egui::{Atoms, Image, IntoAtoms, RichText};
+/// let atoms: Atoms = (
+///     "Some text",
+///     RichText::new("Some RichText"),
+///     Image::new("some_image_url"),
+/// ).into_atoms();
+/// ```
+impl<'a, T> IntoAtoms<'a> for T
+where
+    T: Into<Atom<'a>>,
+{
+    fn collect(self, atoms: &mut Atoms<'a>) {
+        atoms.push_right(self);
+    }
+}
+
+/// Trait for turning a tuple of [`Atom`]s into [`Atoms`].
+pub trait IntoAtoms<'a> {
+    fn collect(self, atoms: &mut Atoms<'a>);
+
+    fn into_atoms(self) -> Atoms<'a>
+    where
+        Self: Sized,
+    {
+        let mut atoms = Atoms::default();
+        self.collect(&mut atoms);
+        atoms
+    }
+}
+
+impl<'a> IntoAtoms<'a> for Atoms<'a> {
+    fn collect(self, atoms: &mut Self) {
+        atoms.0.extend(self.0);
+    }
+}
+
+macro_rules! all_the_atoms {
+    ($($T:ident),*) => {
+        impl<'a, $($T),*> IntoAtoms<'a> for ($($T),*)
+        where
+            $($T: IntoAtoms<'a>),*
+        {
+            fn collect(self, _atoms: &mut Atoms<'a>) {
+                #[allow(clippy::allow_attributes)]
+                #[allow(non_snake_case)]
+                let ($($T),*) = self;
+                $($T.collect(_atoms);)*
+            }
+        }
+    };
+}
+
+all_the_atoms!();
+all_the_atoms!(T0, T1);
+all_the_atoms!(T0, T1, T2);
+all_the_atoms!(T0, T1, T2, T3);
+all_the_atoms!(T0, T1, T2, T3, T4);
+all_the_atoms!(T0, T1, T2, T3, T4, T5);
+
+impl<'a> Deref for Atoms<'a> {
+    type Target = [Atom<'a>];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Atoms<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<'a, T: Into<Atom<'a>>> From<Vec<T>> for Atoms<'a> {
+    fn from(vec: Vec<T>) -> Self {
+        Atoms(vec.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<'a, T: Into<Atom<'a>> + Clone> From<&[T]> for Atoms<'a> {
+    fn from(slice: &[T]) -> Self {
+        Atoms(slice.iter().cloned().map(Into::into).collect())
+    }
+}
+
+impl<'a, Item: Into<Atom<'a>>> FromIterator<Item> for Atoms<'a> {
+    fn from_iter<T: IntoIterator<Item = Item>>(iter: T) -> Self {
+        Atoms(iter.into_iter().map(Into::into).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Atoms;
+
+    #[test]
+    fn collect_atoms() {
+        let _: Atoms<'_> = ["Hello", "World"].into_iter().collect();
+        let _ = Atoms::from(vec!["Hi"]);
+        let _ = Atoms::from(["Hi"].as_slice());
+    }
+}
diff --git a/crates/egui/src/atomics/mod.rs b/crates/egui/src/atomics/mod.rs
new file mode 100644
index 000000000..7c8922c97
--- /dev/null
+++ b/crates/egui/src/atomics/mod.rs
@@ -0,0 +1,15 @@
+mod atom;
+mod atom_ext;
+mod atom_kind;
+mod atom_layout;
+mod atoms;
+mod sized_atom;
+mod sized_atom_kind;
+
+pub use atom::*;
+pub use atom_ext::*;
+pub use atom_kind::*;
+pub use atom_layout::*;
+pub use atoms::*;
+pub use sized_atom::*;
+pub use sized_atom_kind::*;
diff --git a/crates/egui/src/atomics/sized_atom.rs b/crates/egui/src/atomics/sized_atom.rs
new file mode 100644
index 000000000..f1ae0f81b
--- /dev/null
+++ b/crates/egui/src/atomics/sized_atom.rs
@@ -0,0 +1,26 @@
+use crate::SizedAtomKind;
+use emath::Vec2;
+
+/// A [`crate::Atom`] which has been sized.
+#[derive(Clone, Debug)]
+pub struct SizedAtom<'a> {
+    pub(crate) grow: bool,
+
+    /// The size of the atom.
+    ///
+    /// Used for placing this atom in [`crate::AtomLayout`], the cursor will advance by
+    /// size.x + gap.
+    pub size: Vec2,
+
+    /// Intrinsic size of the atom. This is used to calculate `Response::intrinsic_size`.
+    pub intrinsic_size: Vec2,
+
+    pub kind: SizedAtomKind<'a>,
+}
+
+impl SizedAtom<'_> {
+    /// Was this [`crate::Atom`] marked as `grow`?
+    pub fn is_grow(&self) -> bool {
+        self.grow
+    }
+}
diff --git a/crates/egui/src/atomics/sized_atom_kind.rs b/crates/egui/src/atomics/sized_atom_kind.rs
new file mode 100644
index 000000000..ff8da1631
--- /dev/null
+++ b/crates/egui/src/atomics/sized_atom_kind.rs
@@ -0,0 +1,25 @@
+use crate::{Id, Image};
+use emath::Vec2;
+use epaint::Galley;
+use std::sync::Arc;
+
+/// A sized [`crate::AtomKind`].
+#[derive(Clone, Default, Debug)]
+pub enum SizedAtomKind<'a> {
+    #[default]
+    Empty,
+    Text(Arc<Galley>),
+    Image(Image<'a>, Vec2),
+    Custom(Id),
+}
+
+impl SizedAtomKind<'_> {
+    /// Get the calculated size.
+    pub fn size(&self) -> Vec2 {
+        match self {
+            SizedAtomKind::Text(galley) => galley.size(),
+            SizedAtomKind::Image(_, size) => *size,
+            SizedAtomKind::Empty | SizedAtomKind::Custom(_) => Vec2::ZERO,
+        }
+    }
+}
diff --git a/crates/egui/src/cache/cache_trait.rs b/crates/egui/src/cache/cache_trait.rs
index 73cb61f38..fc00a9880 100644
--- a/crates/egui/src/cache/cache_trait.rs
+++ b/crates/egui/src/cache/cache_trait.rs
@@ -1,5 +1,5 @@
 /// A cache, storing some value for some length of time.
-#[allow(clippy::len_without_is_empty)]
+#[expect(clippy::len_without_is_empty)]
 pub trait CacheTrait: 'static + Send + Sync {
     /// Call once per frame to evict cache.
     fn update(&mut self);
diff --git a/crates/egui/src/callstack.rs b/crates/egui/src/callstack.rs
index 03eeaf5fc..fef9b2166 100644
--- a/crates/egui/src/callstack.rs
+++ b/crates/egui/src/callstack.rs
@@ -20,10 +20,10 @@ pub fn capture() -> String {
         backtrace::resolve_frame(frame, |symbol| {
             let mut file_and_line = symbol.filename().map(shorten_source_file_path);
 
-            if let Some(file_and_line) = &mut file_and_line {
-                if let Some(line_nr) = symbol.lineno() {
-                    file_and_line.push_str(&format!(":{line_nr}"));
-                }
+            if let Some(file_and_line) = &mut file_and_line
+                && let Some(line_nr) = symbol.lineno()
+            {
+                file_and_line.push_str(&format!(":{line_nr}"));
             }
             let file_and_line = file_and_line.unwrap_or_default();
 
@@ -204,12 +204,17 @@ fn shorten_source_file_path(path: &std::path::Path) -> String {
 #[test]
 fn test_shorten_path() {
     for (before, after) in [
-        ("/Users/emilk/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.24.1/src/runtime/runtime.rs", "tokio-1.24.1/src/runtime/runtime.rs"),
+        (
+            "/Users/emilk/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.24.1/src/runtime/runtime.rs",
+            "tokio-1.24.1/src/runtime/runtime.rs",
+        ),
         ("crates/rerun/src/main.rs", "rerun/src/main.rs"),
-        ("/rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/ops/function.rs", "core/src/ops/function.rs"),
+        (
+            "/rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/ops/function.rs",
+            "core/src/ops/function.rs",
+        ),
         ("/weird/path/file.rs", "/weird/path/file.rs"),
-        ]
-        {
+    ] {
         use std::str::FromStr as _;
         let before = std::path::PathBuf::from_str(before).unwrap();
         assert_eq!(shorten_source_file_path(&before), after);
diff --git a/crates/egui/src/containers/area.rs b/crates/egui/src/containers/area.rs
index 6af762561..3ebac1d65 100644
--- a/crates/egui/src/containers/area.rs
+++ b/crates/egui/src/containers/area.rs
@@ -5,8 +5,8 @@
 use emath::GuiRounding as _;
 
 use crate::{
-    emath, pos2, Align2, Context, Id, InnerResponse, LayerId, NumExt, Order, Pos2, Rect, Response,
-    Sense, Ui, UiBuilder, UiKind, UiStackInfo, Vec2, WidgetRect, WidgetWithState,
+    Align2, Context, Id, InnerResponse, LayerId, Layout, NumExt as _, Order, Pos2, Rect, Response,
+    Sense, Ui, UiBuilder, UiKind, UiStackInfo, Vec2, WidgetRect, WidgetWithState, emath, pos2,
 };
 
 /// State of an [`Area`] that is persisted between frames.
@@ -103,10 +103,10 @@ impl AreaState {
 ///
 /// The previous rectangle used by this area can be obtained through [`crate::Memory::area_rect()`].
 #[must_use = "You should call .show()"]
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub struct Area {
     pub(crate) id: Id,
-    kind: UiKind,
+    info: UiStackInfo,
     sense: Option<Sense>,
     movable: bool,
     interactable: bool,
@@ -120,6 +120,8 @@ pub struct Area {
     anchor: Option<(Align2, Vec2)>,
     new_pos: Option<Pos2>,
     fade_in: bool,
+    layout: Layout,
+    sizing_pass: bool,
 }
 
 impl WidgetWithState for Area {
@@ -131,7 +133,7 @@ impl Area {
     pub fn new(id: Id) -> Self {
         Self {
             id,
-            kind: UiKind::GenericArea,
+            info: UiStackInfo::new(UiKind::GenericArea),
             sense: None,
             movable: true,
             interactable: true,
@@ -145,6 +147,8 @@ impl Area {
             pivot: Align2::LEFT_TOP,
             anchor: None,
             fade_in: true,
+            layout: Layout::default(),
+            sizing_pass: false,
         }
     }
 
@@ -162,7 +166,16 @@ impl Area {
     /// Default to [`UiKind::GenericArea`].
     #[inline]
     pub fn kind(mut self, kind: UiKind) -> Self {
-        self.kind = kind;
+        self.info = UiStackInfo::new(kind);
+        self
+    }
+
+    /// Set the [`UiStackInfo`] of the area's [`Ui`].
+    ///
+    /// Default to [`UiStackInfo::new(UiKind::GenericArea)`].
+    #[inline]
+    pub fn info(mut self, info: UiStackInfo) -> Self {
+        self.info = info;
         self
     }
 
@@ -339,10 +352,38 @@ impl Area {
         self.fade_in = fade_in;
         self
     }
+
+    /// Set the layout for the child Ui.
+    #[inline]
+    pub fn layout(mut self, layout: Layout) -> Self {
+        self.layout = layout;
+        self
+    }
+
+    /// While true, a sizing pass will be done. This means the area will be invisible
+    /// and the contents will be laid out to estimate the proper containing size of the area.
+    /// If false, there will be no change to the default area behavior. This is useful if the
+    /// area contents area dynamic and you need to need to make sure the area adjusts its size
+    /// accordingly.
+    ///
+    /// This should only be set to true during the specific frames you want force a sizing pass.
+    /// Do NOT hard-code this as `.sizing_pass(true)`, as it will cause the area to never be
+    /// visible.
+    ///
+    /// # Arguments
+    /// - resize: If true, the area will be resized to fit its contents. False will keep the
+    ///   default area resizing behavior.
+    ///
+    /// Default: `false`.
+    #[inline]
+    pub fn sizing_pass(mut self, resize: bool) -> Self {
+        self.sizing_pass = resize;
+        self
+    }
 }
 
 pub(crate) struct Prepared {
-    kind: UiKind,
+    info: Option<UiStackInfo>,
     layer_id: LayerId,
     state: AreaState,
     move_response: Response,
@@ -358,6 +399,7 @@ pub(crate) struct Prepared {
     sizing_pass: bool,
 
     fade_in: bool,
+    layout: Layout,
 }
 
 impl Area {
@@ -366,7 +408,7 @@ impl Area {
         ctx: &Context,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
-        let prepared = self.begin(ctx);
+        let mut 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);
@@ -376,7 +418,7 @@ impl Area {
     pub(crate) fn begin(self, ctx: &Context) -> Prepared {
         let Self {
             id,
-            kind,
+            info,
             sense,
             movable,
             order,
@@ -390,9 +432,11 @@ impl Area {
             constrain,
             constrain_rect,
             fade_in,
+            layout,
+            sizing_pass: force_sizing_pass,
         } = self;
 
-        let constrain_rect = constrain_rect.unwrap_or_else(|| ctx.screen_rect());
+        let constrain_rect = constrain_rect.unwrap_or_else(|| ctx.content_rect());
 
         let layer_id = LayerId::new(order, id);
 
@@ -405,6 +449,10 @@ impl Area {
             interactable,
             last_became_visible_at: None,
         });
+        if force_sizing_pass {
+            sizing_pass = true;
+            state.size = None;
+        }
         state.pivot = pivot;
         state.interactable = interactable;
         if let Some(new_pos) = new_pos {
@@ -477,10 +525,21 @@ impl Area {
                 true,
             );
 
-            if movable && move_response.dragged() {
-                if let Some(pivot_pos) = &mut state.pivot_pos {
-                    *pivot_pos += move_response.drag_delta();
-                }
+            // Used to prevent drift
+            let pivot_at_start_of_drag_id = id.with("pivot_at_drag_start");
+
+            if movable
+                && move_response.dragged()
+                && let Some(pivot_pos) = &mut state.pivot_pos
+            {
+                let pivot_at_start_of_drag = ctx.data_mut(|data| {
+                    *data.get_temp_mut_or::<Pos2>(pivot_at_start_of_drag_id, *pivot_pos)
+                });
+
+                *pivot_pos =
+                    pivot_at_start_of_drag + move_response.total_drag_delta().unwrap_or_default();
+            } else {
+                ctx.data_mut(|data| data.remove::<Pos2>(pivot_at_start_of_drag_id));
             }
 
             if (move_response.dragged() || move_response.clicked())
@@ -494,20 +553,21 @@ impl Area {
             move_response
         };
 
-        if constrain {
-            state.set_left_top_pos(
-                Context::constrain_window_rect_to_area(state.rect(), constrain_rect).min,
-            );
-        }
-
-        state.set_left_top_pos(state.left_top_pos());
+        state.set_left_top_pos(round_area_position(
+            ctx,
+            if constrain {
+                Context::constrain_window_rect_to_area(state.rect(), constrain_rect).min
+            } else {
+                state.left_top_pos()
+            },
+        ));
 
         // Update response with possibly moved/constrained rect:
         move_response.rect = state.rect();
         move_response.interact_rect = state.rect();
 
         Prepared {
-            kind,
+            info: Some(info),
             layer_id,
             state,
             move_response,
@@ -516,10 +576,21 @@ impl Area {
             constrain_rect,
             sizing_pass,
             fade_in,
+            layout,
         }
     }
 }
 
+fn round_area_position(ctx: &Context, pos: Pos2) -> Pos2 {
+    // We round a lot of rendering to pixels, so we round the whole
+    // area positions to pixels too, so avoid widgets appearing to float
+    // around independently of each other when the area is dragged.
+    // But just in case pixels_per_point is irrational,
+    // we then also round to ui coordinates:
+
+    pos.round_to_pixels(ctx.pixels_per_point()).round_ui()
+}
+
 impl Prepared {
     pub(crate) fn state(&self) -> &AreaState {
         &self.state
@@ -537,13 +608,16 @@ impl Prepared {
         self.constrain_rect
     }
 
-    pub(crate) fn content_ui(&self, ctx: &Context) -> Ui {
+    pub(crate) fn content_ui(&mut self, ctx: &Context) -> Ui {
         let max_rect = self.state.rect();
 
         let mut ui_builder = UiBuilder::new()
-            .ui_stack_info(UiStackInfo::new(self.kind))
+            .ui_stack_info(self.info.take().unwrap_or_default())
             .layer_id(self.layer_id)
-            .max_rect(max_rect);
+            .max_rect(max_rect)
+            .layout(self.layout)
+            .accessibility_parent(self.move_response.id)
+            .closable();
 
         if !self.enabled {
             ui_builder = ui_builder.disabled();
@@ -555,16 +629,16 @@ impl Prepared {
         let mut ui = Ui::new(ctx.clone(), self.layer_id.id, ui_builder);
         ui.set_clip_rect(self.constrain_rect); // Don't paint outside our bounds
 
-        if self.fade_in {
-            if let Some(last_became_visible_at) = self.state.last_became_visible_at {
-                let age =
-                    ctx.input(|i| (i.time - last_became_visible_at) as f32 + i.predicted_dt / 2.0);
-                let opacity = crate::remap_clamp(age, 0.0..=ctx.style().animation_time, 0.0..=1.0);
-                let opacity = emath::easing::quadratic_out(opacity); // slow fade-out = quick fade-in
-                ui.multiply_opacity(opacity);
-                if opacity < 1.0 {
-                    ctx.request_repaint();
-                }
+        if self.fade_in
+            && let Some(last_became_visible_at) = self.state.last_became_visible_at
+        {
+            let age =
+                ctx.input(|i| (i.time - last_became_visible_at) as f32 + i.predicted_dt / 2.0);
+            let opacity = crate::remap_clamp(age, 0.0..=ctx.style().animation_time, 0.0..=1.0);
+            let opacity = emath::easing::quadratic_out(opacity); // slow fade-out = quick fade-in
+            ui.multiply_opacity(opacity);
+            if opacity < 1.0 {
+                ctx.request_repaint();
             }
         }
 
@@ -579,10 +653,10 @@ impl Prepared {
         self.move_response.id
     }
 
-    #[allow(clippy::needless_pass_by_value)] // intentional to swallow up `content_ui`.
+    #[expect(clippy::needless_pass_by_value)] // intentional to swallow up `content_ui`.
     pub(crate) fn end(self, ctx: &Context, content_ui: Ui) -> Response {
         let Self {
-            kind: _,
+            info: _,
             layer_id,
             mut state,
             move_response: mut response,
@@ -598,6 +672,12 @@ impl Prepared {
         response.rect = final_rect;
         response.interact_rect = final_rect;
 
+        // TODO(lucasmerlin): Can the area response be based on Ui::response? Then this won't be needed
+        // Bubble up the close event
+        if content_ui.should_close() {
+            response.set_close();
+        }
+
         ctx.memory_mut(|m| m.areas_mut().set_state(layer_id, state));
 
         if sizing_pass {
@@ -648,7 +728,7 @@ fn automatic_area_position(ctx: &Context, layer_id: LayerId) -> Pos2 {
         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);
+            *current_column_bb |= rect;
         } else {
             // new column
             column_bbs.push(rect);
diff --git a/crates/egui/src/containers/close_tag.rs b/crates/egui/src/containers/close_tag.rs
new file mode 100644
index 000000000..3e93dbbd2
--- /dev/null
+++ b/crates/egui/src/containers/close_tag.rs
@@ -0,0 +1,28 @@
+#[expect(unused_imports)]
+use crate::{Ui, UiBuilder};
+use std::sync::atomic::AtomicBool;
+
+/// A tag to mark a container as closable.
+///
+/// Usually set via [`UiBuilder::closable`].
+///
+/// [`Ui::close`] will find the closest parent [`ClosableTag`] and set its `close` field to `true`.
+/// Use [`Ui::should_close`] to check if close has been called.
+#[derive(Debug, Default)]
+pub struct ClosableTag {
+    pub close: AtomicBool,
+}
+
+impl ClosableTag {
+    pub const NAME: &'static str = "egui_close_tag";
+
+    /// Set close to `true`
+    pub fn set_close(&self) {
+        self.close.store(true, std::sync::atomic::Ordering::Relaxed);
+    }
+
+    /// Returns `true` if [`ClosableTag::set_close`] has been called.
+    pub fn should_close(&self) -> bool {
+        self.close.load(std::sync::atomic::Ordering::Relaxed)
+    }
+}
diff --git a/crates/egui/src/containers/collapsing_header.rs b/crates/egui/src/containers/collapsing_header.rs
index 1ed2a27fb..3afb77682 100644
--- a/crates/egui/src/containers/collapsing_header.rs
+++ b/crates/egui/src/containers/collapsing_header.rs
@@ -1,8 +1,9 @@
 use std::hash::Hash;
 
 use crate::{
-    emath, epaint, pos2, remap, remap_clamp, vec2, Context, Id, InnerResponse, NumExt, Rect,
-    Response, Sense, Stroke, TextStyle, TextWrapMode, Ui, Vec2, WidgetInfo, WidgetText, WidgetType,
+    Context, Id, InnerResponse, NumExt as _, Rect, Response, Sense, Stroke, TextStyle,
+    TextWrapMode, Ui, UiBuilder, UiKind, UiStackInfo, Vec2, WidgetInfo, WidgetText, WidgetType,
+    emath, epaint, pos2, remap, remap_clamp, vec2,
 };
 use emath::GuiRounding as _;
 use epaint::{Shape, StrokeKind};
@@ -203,11 +204,16 @@ impl CollapsingState {
         add_body: impl FnOnce(&mut Ui) -> R,
     ) -> Option<InnerResponse<R>> {
         let openness = self.openness(ui.ctx());
+
+        let builder = UiBuilder::new()
+            .ui_stack_info(UiStackInfo::new(UiKind::Collapsible))
+            .closable();
+
         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| {
+            Some(ui.scope_builder(builder, |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.
@@ -226,6 +232,9 @@ impl CollapsingState {
 
                 let mut min_rect = child_ui.min_rect();
                 self.state.open_height = Some(min_rect.height());
+                if child_ui.should_close() {
+                    self.state.open = false;
+                }
                 self.store(child_ui.ctx()); // remember the height
 
                 // Pretend children took up at most `max_height` space:
@@ -234,7 +243,10 @@ impl CollapsingState {
                 ret
             }))
         } else {
-            let ret_response = ui.scope(add_body);
+            let ret_response = ui.scope_builder(builder, add_body);
+            if ret_response.response.should_close() {
+                self.state.open = false;
+            }
             let full_size = ret_response.response.rect.size();
             self.state.open_height = Some(full_size.y);
             self.store(ui.ctx()); // remember the height
diff --git a/crates/egui/src/containers/combo_box.rs b/crates/egui/src/containers/combo_box.rs
index 98cf0182e..c4097f803 100644
--- a/crates/egui/src/containers/combo_box.rs
+++ b/crates/egui/src/containers/combo_box.rs
@@ -1,31 +1,25 @@
 use epaint::Shape;
 
 use crate::{
-    epaint, style::WidgetVisuals, vec2, Align2, Context, Id, InnerResponse, NumExt, Painter,
-    PopupCloseBehavior, Rect, Response, ScrollArea, Sense, Stroke, TextStyle, TextWrapMode, Ui,
-    UiBuilder, Vec2, WidgetInfo, WidgetText, WidgetType,
+    Align2, Context, Id, InnerResponse, NumExt as _, Painter, Popup, PopupCloseBehavior, Rect,
+    Response, ScrollArea, Sense, Stroke, TextStyle, TextWrapMode, Ui, UiBuilder, Vec2, WidgetInfo,
+    WidgetText, WidgetType, epaint, style::StyleModifier, style::WidgetVisuals, vec2,
 };
 
-#[allow(unused_imports)] // Documentation
+#[expect(unused_imports)] // Documentation
 use crate::style::Spacing;
 
-/// Indicate whether 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)>;
+pub type IconPainter = Box<dyn FnOnce(&Ui, Rect, &WidgetVisuals, bool)>;
 
 /// A drop-down selection menu with a descriptive label.
 ///
 /// ```
 /// # egui::__run_test_ui(|ui| {
-/// # #[derive(Debug, PartialEq)]
+/// # #[derive(Debug, PartialEq, Copy, Clone)]
 /// # enum Enum { First, Second, Third }
 /// # let mut selected = Enum::First;
+/// let before = selected;
 /// egui::ComboBox::from_label("Select one!")
 ///     .selected_text(format!("{:?}", selected))
 ///     .show_ui(ui, |ui| {
@@ -34,6 +28,10 @@ pub type IconPainter = Box<dyn FnOnce(&Ui, Rect, &WidgetVisuals, bool, AboveOrBe
 ///         ui.selectable_value(&mut selected, Enum::Third, "Third");
 ///     }
 /// );
+///
+/// if selected != before {
+///     // Handle selection change
+/// }
 /// # });
 /// ```
 #[must_use = "You should call .show*"]
@@ -46,6 +44,7 @@ pub struct ComboBox {
     icon: Option<IconPainter>,
     wrap_mode: Option<TextWrapMode>,
     close_behavior: Option<PopupCloseBehavior>,
+    popup_style: StyleModifier,
 }
 
 impl ComboBox {
@@ -60,6 +59,7 @@ impl ComboBox {
             icon: None,
             wrap_mode: None,
             close_behavior: None,
+            popup_style: StyleModifier::default(),
         }
     }
 
@@ -75,6 +75,7 @@ impl ComboBox {
             icon: None,
             wrap_mode: None,
             close_behavior: None,
+            popup_style: StyleModifier::default(),
         }
     }
 
@@ -89,11 +90,12 @@ impl ComboBox {
             icon: None,
             wrap_mode: None,
             close_behavior: None,
+            popup_style: StyleModifier::default(),
         }
     }
 
     /// Without label.
-    #[deprecated = "Renamed id_salt"]
+    #[deprecated = "Renamed from_id_salt"]
     pub fn from_id_source(id_salt: impl std::hash::Hash) -> Self {
         Self::from_id_salt(id_salt)
     }
@@ -135,7 +137,6 @@ impl ComboBox {
     ///     rect: egui::Rect,
     ///     visuals: &egui::style::WidgetVisuals,
     ///     _is_open: bool,
-    ///     _above_or_below: egui::AboveOrBelow,
     /// ) {
     ///     let rect = egui::Rect::from_center_size(
     ///         rect.center(),
@@ -154,10 +155,8 @@ impl ComboBox {
     ///     .show_ui(ui, |_ui| {});
     /// # });
     /// ```
-    pub fn icon(
-        mut self,
-        icon_fn: impl FnOnce(&Ui, Rect, &WidgetVisuals, bool, AboveOrBelow) + 'static,
-    ) -> Self {
+    #[inline]
+    pub fn icon(mut self, icon_fn: impl FnOnce(&Ui, Rect, &WidgetVisuals, bool) + 'static) -> Self {
         self.icon = Some(Box::new(icon_fn));
         self
     }
@@ -196,6 +195,16 @@ impl ComboBox {
         self
     }
 
+    /// Set the style of the popup menu.
+    ///
+    /// Could for example be used with [`crate::containers::menu::menu_style`] to get the frame-less
+    /// menu button style.
+    #[inline]
+    pub fn popup_style(mut self, popup_style: StyleModifier) -> Self {
+        self.popup_style = popup_style;
+        self
+    }
+
     /// Show the combo box, with the given ui code for the menu contents.
     ///
     /// Returns `InnerResponse { inner: None }` if the combo box is closed.
@@ -221,6 +230,7 @@ impl ComboBox {
             icon,
             wrap_mode,
             close_behavior,
+            popup_style,
         } = self;
 
         let button_id = ui.make_persistent_id(id_salt);
@@ -229,21 +239,24 @@ impl ComboBox {
             let mut ir = combo_box_dyn(
                 ui,
                 button_id,
-                selected_text,
+                selected_text.clone(),
                 menu_contents,
                 icon,
                 wrap_mode,
                 close_behavior,
+                popup_style,
                 (width, height),
             );
+            ir.response.widget_info(|| {
+                let mut info = WidgetInfo::new(WidgetType::ComboBox);
+                info.enabled = ui.is_enabled();
+                info.current_text_value = Some(selected_text.text().to_owned());
+                info
+            });
             if let Some(label) = label {
-                ir.response.widget_info(|| {
-                    WidgetInfo::labeled(WidgetType::ComboBox, ui.is_enabled(), label.text())
-                });
-                ir.response |= ui.label(label);
-            } else {
-                ir.response
-                    .widget_info(|| WidgetInfo::labeled(WidgetType::ComboBox, ui.is_enabled(), ""));
+                let label_response = ui.label(label);
+                ir.response = ir.response.labelled_by(label_response.id);
+                ir.response |= label_response;
             }
             ir
         })
@@ -298,7 +311,7 @@ impl ComboBox {
 
     /// Check if the [`ComboBox`] with the given id has its popup menu currently opened.
     pub fn is_open(ctx: &Context, id: Id) -> bool {
-        ctx.memory(|m| m.is_popup_open(Self::widget_to_popup_id(id)))
+        Popup::is_id_open(ctx, Self::widget_to_popup_id(id))
     }
 
     /// Convert a [`ComboBox`] id to the id used to store it's popup state.
@@ -307,7 +320,7 @@ impl ComboBox {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn combo_box_dyn<'c, R>(
     ui: &mut Ui,
     button_id: Id,
@@ -316,27 +329,12 @@ fn combo_box_dyn<'c, R>(
     icon: Option<IconPainter>,
     wrap_mode: Option<TextWrapMode>,
     close_behavior: Option<PopupCloseBehavior>,
+    popup_style: StyleModifier,
     (width, height): (Option<f32>, Option<f32>),
 ) -> InnerResponse<Option<R>> {
     let popup_id = ComboBox::widget_to_popup_id(button_id);
 
-    let is_popup_open = ui.memory(|m| m.is_popup_open(popup_id));
-
-    let popup_height = ui.memory(|m| {
-        m.areas()
-            .get(popup_id)
-            .and_then(|state| state.size)
-            .map_or(100.0, |size| 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 is_popup_open = Popup::is_id_open(ui.ctx(), popup_id);
 
     let wrap_mode = wrap_mode.unwrap_or_else(|| ui.wrap_mode());
 
@@ -385,15 +383,9 @@ fn combo_box_dyn<'c, R>(
                     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,
-                );
+                paint_default_icon(ui.painter(), icon_rect.expand(visuals.expansion), visuals);
             }
 
             let text_rect = Align2::LEFT_CENTER.align_size_within_rect(galley.size(), rect);
@@ -402,19 +394,16 @@ fn combo_box_dyn<'c, R>(
         }
     });
 
-    if button_response.clicked() {
-        ui.memory_mut(|mem| mem.toggle_popup(popup_id));
-    }
-
     let height = height.unwrap_or_else(|| ui.spacing().combo_height);
 
-    let inner = crate::popup::popup_above_or_below_widget(
-        ui,
-        popup_id,
-        &button_response,
-        above_or_below,
-        close_behavior,
-        |ui| {
+    let inner = Popup::menu(&button_response)
+        .id(popup_id)
+        .width(button_response.rect.width())
+        .close_behavior(close_behavior)
+        .style(popup_style)
+        .show(|ui| {
+            ui.set_min_width(ui.available_width());
+
             ScrollArea::vertical()
                 .max_height(height)
                 .show(ui, |ui| {
@@ -427,8 +416,8 @@ fn combo_box_dyn<'c, R>(
                     menu_contents(ui)
                 })
                 .inner
-        },
-    );
+        })
+        .map(|r| r.inner);
 
     InnerResponse {
         inner,
@@ -484,33 +473,19 @@ fn button_frame(
     response
 }
 
-fn paint_default_icon(
-    painter: &Painter,
-    rect: Rect,
-    visuals: &WidgetVisuals,
-    above_or_below: AboveOrBelow,
-) {
+fn paint_default_icon(painter: &Painter, rect: Rect, visuals: &WidgetVisuals) {
     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,
-            ));
-        }
-    }
+    // Downward pointing triangle
+    // Previously, we would show an up arrow when we expected the popup to open upwards
+    // (due to lack of space below the button), but this could look weird in edge cases, so this
+    // feature was removed. (See https://github.com/emilk/egui/pull/5713#issuecomment-2654420245)
+    painter.add(Shape::convex_polygon(
+        vec![rect.left_top(), rect.right_top(), rect.center_bottom()],
+        visuals.fg_stroke.color,
+        Stroke::NONE,
+    ));
 }
diff --git a/crates/egui/src/containers/frame.rs b/crates/egui/src/containers/frame.rs
index 343897dcc..e4de2ca48 100644
--- a/crates/egui/src/containers/frame.rs
+++ b/crates/egui/src/containers/frame.rs
@@ -1,10 +1,10 @@
 //! Frame container
 
 use crate::{
-    epaint, layers::ShapeIdx, InnerResponse, Response, Sense, Style, Ui, UiBuilder, UiKind,
-    UiStackInfo,
+    InnerResponse, Response, Sense, Style, Ui, UiBuilder, UiKind, UiStackInfo, epaint,
+    layers::ShapeIdx,
 };
-use epaint::{Color32, CornerRadius, Margin, Marginf, Rect, Shadow, Shape, Stroke};
+use epaint::{Color32, CornerRadius, Margin, MarginF32, Rect, Shadow, Shape, Stroke};
 
 /// A frame around some content, including margin, colors, etc.
 ///
@@ -46,7 +46,7 @@ use epaint::{Color32, CornerRadius, Margin, Marginf, Rect, Shadow, Shape, Stroke
 ///
 /// ```
 /// # egui::__run_test_ui(|ui| {
-/// egui::Frame::none()
+/// egui::Frame::NONE
 ///     .fill(egui::Color32::RED)
 ///     .show(ui, |ui| {
 ///         ui.label("Label with red background");
@@ -143,7 +143,8 @@ pub struct Frame {
 #[test]
 fn frame_size() {
     assert_eq!(
-        std::mem::size_of::<Frame>(), 32,
+        std::mem::size_of::<Frame>(),
+        32,
         "Frame changed size! If it shrank - good! Update this test. If it grew - bad! Try to find a way to avoid it."
     );
     assert!(
@@ -337,10 +338,10 @@ impl Frame {
     ///
     /// [`Self::inner_margin`] + [`Self.stroke`]`.width` + [`Self::outer_margin`].
     #[inline]
-    pub fn total_margin(&self) -> Marginf {
-        Marginf::from(self.inner_margin)
-            + Marginf::from(self.stroke.width)
-            + Marginf::from(self.outer_margin)
+    pub fn total_margin(&self) -> MarginF32 {
+        MarginF32::from(self.inner_margin)
+            + MarginF32::from(self.stroke.width)
+            + MarginF32::from(self.outer_margin)
     }
 
     /// Calculate the `fill_rect` from the `content_rect`.
@@ -354,14 +355,14 @@ impl Frame {
     ///
     /// This is the visible and interactive rectangle.
     pub fn widget_rect(&self, content_rect: Rect) -> Rect {
-        content_rect + self.inner_margin + Marginf::from(self.stroke.width)
+        content_rect + self.inner_margin + MarginF32::from(self.stroke.width)
     }
 
     /// Calculate the `outer_rect` from the `content_rect`.
     ///
     /// This is what is allocated in the outer [`Ui`], and is what is returned by [`Response::rect`].
     pub fn outer_rect(&self, content_rect: Rect) -> Rect {
-        content_rect + self.inner_margin + Marginf::from(self.stroke.width) + self.outer_margin
+        content_rect + self.inner_margin + MarginF32::from(self.stroke.width) + self.outer_margin
     }
 }
 
@@ -463,7 +464,7 @@ impl Prepared {
         let content_rect = self.content_ui.min_rect();
         content_rect
             + self.frame.inner_margin
-            + Marginf::from(self.frame.stroke.width)
+            + MarginF32::from(self.frame.stroke.width)
             + self.frame.outer_margin
     }
 
diff --git a/crates/egui/src/containers/menu.rs b/crates/egui/src/containers/menu.rs
new file mode 100644
index 000000000..f2aaee046
--- /dev/null
+++ b/crates/egui/src/containers/menu.rs
@@ -0,0 +1,592 @@
+//! Popup menus, context menus and menu bars.
+//!
+//! Show menus via
+//! - [`Popup::menu`] and [`Popup::context_menu`]
+//! - [`Ui::menu_button`], [`MenuButton`] and [`SubMenuButton`]
+//! - [`MenuBar`]
+//! - [`Response::context_menu`]
+//!
+//! See [`MenuBar`] for an example.
+
+use crate::style::StyleModifier;
+use crate::{
+    Button, Color32, Context, Frame, Id, InnerResponse, IntoAtoms, Layout, Popup,
+    PopupCloseBehavior, Response, Style, Ui, UiBuilder, UiKind, UiStack, UiStackInfo, Widget as _,
+};
+use emath::{Align, RectAlign, Vec2, vec2};
+use epaint::Stroke;
+
+/// Apply a menu style to the [`Style`].
+///
+/// Mainly removes the background stroke and the inactive background fill.
+pub fn 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.open.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;
+}
+
+/// Find the root [`UiStack`] of the menu.
+pub fn find_menu_root(ui: &Ui) -> &UiStack {
+    ui.stack()
+        .iter()
+        .find(|stack| {
+            stack.is_root_ui()
+                || [Some(UiKind::Popup), Some(UiKind::Menu)].contains(&stack.kind())
+                || stack.info.tags.contains(MenuConfig::MENU_CONFIG_TAG)
+        })
+        .expect("We should always find the root")
+}
+
+/// Is this Ui part of a menu?
+///
+/// Returns `false` if this is a menu bar.
+/// Should be used to determine if we should show a menu button or submenu button.
+pub fn is_in_menu(ui: &Ui) -> bool {
+    for stack in ui.stack().iter() {
+        if let Some(config) = stack
+            .info
+            .tags
+            .get_downcast::<MenuConfig>(MenuConfig::MENU_CONFIG_TAG)
+        {
+            return !config.bar;
+        }
+        if [Some(UiKind::Popup), Some(UiKind::Menu)].contains(&stack.kind()) {
+            return true;
+        }
+    }
+    false
+}
+
+/// Configuration and style for menus.
+#[derive(Clone, Debug)]
+pub struct MenuConfig {
+    /// Is this a menu bar?
+    bar: bool,
+
+    /// If the user clicks, should we close the menu?
+    pub close_behavior: PopupCloseBehavior,
+
+    /// Override the menu style.
+    ///
+    /// Default is [`menu_style`].
+    pub style: StyleModifier,
+}
+
+impl Default for MenuConfig {
+    fn default() -> Self {
+        Self {
+            close_behavior: PopupCloseBehavior::default(),
+            bar: false,
+            style: menu_style.into(),
+        }
+    }
+}
+
+impl MenuConfig {
+    /// The tag used to store the menu config in the [`UiStack`].
+    pub const MENU_CONFIG_TAG: &'static str = "egui_menu_config";
+
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// If the user clicks, should we close the menu?
+    #[inline]
+    pub fn close_behavior(mut self, close_behavior: PopupCloseBehavior) -> Self {
+        self.close_behavior = close_behavior;
+        self
+    }
+
+    /// Override the menu style.
+    ///
+    /// Default is [`menu_style`].
+    #[inline]
+    pub fn style(mut self, style: impl Into<StyleModifier>) -> Self {
+        self.style = style.into();
+        self
+    }
+
+    fn from_stack(stack: &UiStack) -> Self {
+        stack
+            .info
+            .tags
+            .get_downcast(Self::MENU_CONFIG_TAG)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// Find the config for the current menu.
+    ///
+    /// Returns the default config if no config is found.
+    pub fn find(ui: &Ui) -> Self {
+        find_menu_root(ui)
+            .info
+            .tags
+            .get_downcast(Self::MENU_CONFIG_TAG)
+            .cloned()
+            .unwrap_or_default()
+    }
+}
+
+/// Holds the state of the menu.
+#[derive(Clone)]
+pub struct MenuState {
+    /// The currently open sub menu in this menu.
+    pub open_item: Option<Id>,
+    last_visible_pass: u64,
+}
+
+impl MenuState {
+    pub const ID: &'static str = "menu_state";
+
+    /// Find the root of the menu and get the state
+    pub fn from_ui<R>(ui: &Ui, f: impl FnOnce(&mut Self, &UiStack) -> R) -> R {
+        let stack = find_menu_root(ui);
+        Self::from_id(ui.ctx(), stack.id, |state| f(state, stack))
+    }
+
+    /// Get the state via the menus root [`Ui`] id
+    pub fn from_id<R>(ctx: &Context, id: Id, f: impl FnOnce(&mut Self) -> R) -> R {
+        let pass_nr = ctx.cumulative_pass_nr();
+        ctx.data_mut(|data| {
+            let state_id = id.with(Self::ID);
+            let mut state = data.get_temp(state_id).unwrap_or(Self {
+                open_item: None,
+                last_visible_pass: pass_nr,
+            });
+            // If the menu was closed for at least a frame, reset the open item
+            if state.last_visible_pass + 1 < pass_nr {
+                state.open_item = None;
+            }
+            if let Some(item) = state.open_item {
+                if data
+                    .get_temp(item.with(Self::ID))
+                    .is_none_or(|item: Self| item.last_visible_pass + 1 < pass_nr)
+                {
+                    // If the open item wasn't shown for at least a frame, reset the open item
+                    state.open_item = None;
+                }
+            }
+            let r = f(&mut state);
+            data.insert_temp(state_id, state);
+            r
+        })
+    }
+
+    pub fn mark_shown(ctx: &Context, id: Id) {
+        let pass_nr = ctx.cumulative_pass_nr();
+        Self::from_id(ctx, id, |state| {
+            state.last_visible_pass = pass_nr;
+        });
+    }
+
+    /// Is the menu with this id the deepest sub menu? (-> no child sub menu is open)
+    ///
+    /// Note: This only returns correct results if called after the menu contents were shown.
+    pub fn is_deepest_open_sub_menu(ctx: &Context, id: Id) -> bool {
+        let pass_nr = ctx.cumulative_pass_nr();
+        let open_item = Self::from_id(ctx, id, |state| state.open_item);
+        // If we have some open item, check if that was actually shown this frame
+        open_item.is_none_or(|submenu_id| {
+            Self::from_id(ctx, submenu_id, |state| state.last_visible_pass != pass_nr)
+        })
+    }
+}
+
+/// Horizontal menu bar where you can add [`MenuButton`]s.
+///
+/// The menu bar goes well in a [`crate::TopBottomPanel::top`],
+/// but can also be placed in a [`crate::Window`].
+/// In the latter case you may want to wrap it in [`Frame`].
+///
+/// ### Example:
+/// ```
+/// # egui::__run_test_ui(|ui| {
+/// egui::MenuBar::new().ui(ui, |ui| {
+///     ui.menu_button("File", |ui| {
+///         if ui.button("Quit").clicked() {
+///             ui.ctx().send_viewport_cmd(egui::ViewportCommand::Close);
+///         }
+///     });
+/// });
+/// # });
+/// ```
+#[derive(Clone, Debug)]
+pub struct MenuBar {
+    config: MenuConfig,
+    style: StyleModifier,
+}
+
+#[deprecated = "Renamed to `egui::MenuBar`"]
+pub type Bar = MenuBar;
+
+impl Default for MenuBar {
+    fn default() -> Self {
+        Self {
+            config: MenuConfig::default(),
+            style: menu_style.into(),
+        }
+    }
+}
+
+impl MenuBar {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the style for buttons in the menu bar.
+    ///
+    /// Doesn't affect the style of submenus, use [`MenuConfig::style`] for that.
+    /// Default is [`menu_style`].
+    #[inline]
+    pub fn style(mut self, style: impl Into<StyleModifier>) -> Self {
+        self.style = style.into();
+        self
+    }
+
+    /// Set the config for submenus.
+    ///
+    /// Note: The config will only be passed when using [`MenuButton`], not via [`Popup::menu`].
+    #[inline]
+    pub fn config(mut self, config: MenuConfig) -> Self {
+        self.config = config;
+        self
+    }
+
+    /// Show the menu bar.
+    #[inline]
+    pub fn ui<R>(self, ui: &mut Ui, content: impl FnOnce(&mut Ui) -> R) -> InnerResponse<R> {
+        let Self { mut config, style } = self;
+        config.bar = true;
+        // TODO(lucasmerlin): It'd be nice if we had a ui.horizontal_builder or something
+        // So we don't need the nested scope here
+        ui.horizontal(|ui| {
+            ui.scope_builder(
+                UiBuilder::new()
+                    .layout(Layout::left_to_right(Align::Center))
+                    .ui_stack_info(
+                        UiStackInfo::new(UiKind::Menu)
+                            .with_tag_value(MenuConfig::MENU_CONFIG_TAG, config),
+                    ),
+                |ui| {
+                    style.apply(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));
+
+                    content(ui)
+                },
+            )
+            .inner
+        })
+    }
+}
+
+/// A thin wrapper around a [`Button`] that shows a [`Popup::menu`] when clicked.
+///
+/// The only thing this does is search for the current menu config (if set via [`MenuBar`]).
+/// If your menu button is not in a [`MenuBar`] it's fine to use [`Ui::button`] and [`Popup::menu`]
+/// directly.
+pub struct MenuButton<'a> {
+    pub button: Button<'a>,
+    pub config: Option<MenuConfig>,
+}
+
+impl<'a> MenuButton<'a> {
+    pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
+        Self::from_button(Button::new(atoms.into_atoms()))
+    }
+
+    /// Set the config for the menu.
+    #[inline]
+    pub fn config(mut self, config: MenuConfig) -> Self {
+        self.config = Some(config);
+        self
+    }
+
+    /// Create a new menu button from a [`Button`].
+    #[inline]
+    pub fn from_button(button: Button<'a>) -> Self {
+        Self {
+            button,
+            config: None,
+        }
+    }
+
+    /// Show the menu button.
+    pub fn ui<R>(
+        self,
+        ui: &mut Ui,
+        content: impl FnOnce(&mut Ui) -> R,
+    ) -> (Response, Option<InnerResponse<R>>) {
+        let response = self.button.ui(ui);
+        let mut config = self.config.unwrap_or_else(|| MenuConfig::find(ui));
+        config.bar = false;
+        let inner = Popup::menu(&response)
+            .close_behavior(config.close_behavior)
+            .style(config.style.clone())
+            .info(
+                UiStackInfo::new(UiKind::Menu).with_tag_value(MenuConfig::MENU_CONFIG_TAG, config),
+            )
+            .show(content);
+        (response, inner)
+    }
+}
+
+/// A submenu button that shows a [`SubMenu`] if a [`Button`] is hovered.
+pub struct SubMenuButton<'a> {
+    pub button: Button<'a>,
+    pub sub_menu: SubMenu,
+}
+
+impl<'a> SubMenuButton<'a> {
+    /// The default right arrow symbol: `"⏵"`
+    pub const RIGHT_ARROW: &'static str = "⏵";
+
+    pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
+        Self::from_button(Button::new(atoms.into_atoms()).right_text("⏵"))
+    }
+
+    /// Create a new submenu button from a [`Button`].
+    ///
+    /// Use [`Button::right_text`] and [`SubMenuButton::RIGHT_ARROW`] to add the default right
+    /// arrow symbol.
+    pub fn from_button(button: Button<'a>) -> Self {
+        Self {
+            button,
+            sub_menu: SubMenu::default(),
+        }
+    }
+
+    /// Set the config for the submenu.
+    ///
+    /// The close behavior will not affect the current button, but the buttons in the submenu.
+    #[inline]
+    pub fn config(mut self, config: MenuConfig) -> Self {
+        self.sub_menu.config = Some(config);
+        self
+    }
+
+    /// Show the submenu button.
+    pub fn ui<R>(
+        self,
+        ui: &mut Ui,
+        content: impl FnOnce(&mut Ui) -> R,
+    ) -> (Response, Option<InnerResponse<R>>) {
+        let my_id = ui.next_auto_id();
+        let open = MenuState::from_ui(ui, |state, _| {
+            state.open_item == Some(SubMenu::id_from_widget_id(my_id))
+        });
+        let inactive = ui.style().visuals.widgets.inactive;
+        // TODO(lucasmerlin) add `open` function to `Button`
+        if open {
+            ui.style_mut().visuals.widgets.inactive = ui.style().visuals.widgets.open;
+        }
+        let response = self.button.ui(ui);
+        ui.style_mut().visuals.widgets.inactive = inactive;
+
+        let popup_response = self.sub_menu.show(ui, &response, content);
+
+        (response, popup_response)
+    }
+}
+
+/// Show a submenu in a menu.
+///
+/// Useful if you want to make custom menu buttons.
+/// Usually, just use [`MenuButton`] or [`SubMenuButton`] instead.
+#[derive(Clone, Debug, Default)]
+pub struct SubMenu {
+    config: Option<MenuConfig>,
+}
+
+impl SubMenu {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the config for the submenu.
+    ///
+    /// The close behavior will not affect the current button, but the buttons in the submenu.
+    #[inline]
+    pub fn config(mut self, config: MenuConfig) -> Self {
+        self.config = Some(config);
+        self
+    }
+
+    /// Get the id for the submenu from the widget/response id.
+    pub fn id_from_widget_id(widget_id: Id) -> Id {
+        widget_id.with("submenu")
+    }
+
+    /// Show the submenu.
+    ///
+    /// This does some heuristics to check if the `button_response` was the last thing in the
+    /// menu that was hovered/clicked, and if so, shows the submenu.
+    pub fn show<R>(
+        self,
+        ui: &Ui,
+        button_response: &Response,
+        content: impl FnOnce(&mut Ui) -> R,
+    ) -> Option<InnerResponse<R>> {
+        let frame = Frame::menu(ui.style());
+
+        let id = Self::id_from_widget_id(button_response.id);
+
+        // Get the state from the parent menu
+        let (open_item, menu_id, parent_config) = MenuState::from_ui(ui, |state, stack| {
+            (state.open_item, stack.id, MenuConfig::from_stack(stack))
+        });
+
+        let mut menu_config = self.config.unwrap_or_else(|| parent_config.clone());
+        menu_config.bar = false;
+
+        let menu_root_response = ui
+            .ctx()
+            .read_response(menu_id)
+            // Since we are a child of that ui, this should always exist
+            .unwrap();
+
+        let hover_pos = ui.ctx().pointer_hover_pos();
+
+        // We don't care if the user is hovering over the border
+        let menu_rect = menu_root_response.rect - frame.total_margin();
+        let is_hovering_menu = hover_pos.is_some_and(|pos| {
+            ui.ctx().layer_id_at(pos) == Some(menu_root_response.layer_id)
+                && menu_rect.contains(pos)
+        });
+
+        let is_any_open = open_item.is_some();
+        let mut is_open = open_item == Some(id);
+        let mut set_open = None;
+
+        // We expand the button rect so there is no empty space where no menu is shown
+        // TODO(lucasmerlin): Instead, maybe make item_spacing.y 0.0?
+        let button_rect = button_response
+            .rect
+            .expand2(ui.style().spacing.item_spacing / 2.0);
+
+        // In theory some other widget could cover the button and this check would still pass
+        // But since we check if no other menu is open, nothing should be able to cover the button
+        let is_hovered = hover_pos.is_some_and(|pos| button_rect.contains(pos));
+
+        // The clicked handler is there for accessibility (keyboard navigation)
+        let should_open =
+            ui.is_enabled() && (button_response.clicked() || (is_hovered && !is_any_open));
+        if should_open {
+            set_open = Some(true);
+            is_open = true;
+            // Ensure that all other sub menus are closed when we open the menu
+            MenuState::from_id(ui.ctx(), menu_id, |state| {
+                state.open_item = None;
+            });
+        }
+
+        let gap = frame.total_margin().sum().x / 2.0 + 2.0;
+
+        let mut response = button_response.clone();
+        // Expand the button rect so that the button and the first item in the submenu are aligned
+        let expand = Vec2::new(0.0, frame.total_margin().sum().y / 2.0);
+        response.interact_rect = response.interact_rect.expand2(expand);
+
+        let popup_response = Popup::from_response(&response)
+            .id(id)
+            .open(is_open)
+            .align(RectAlign::RIGHT_START)
+            .layout(Layout::top_down_justified(Align::Min))
+            .gap(gap)
+            .style(menu_config.style.clone())
+            .frame(frame)
+            // The close behavior is handled by the menu (see below)
+            .close_behavior(PopupCloseBehavior::IgnoreClicks)
+            .info(
+                UiStackInfo::new(UiKind::Menu)
+                    .with_tag_value(MenuConfig::MENU_CONFIG_TAG, menu_config.clone()),
+            )
+            .show(|ui| {
+                // Ensure our layer stays on top when the button is clicked
+                if button_response.clicked() || button_response.is_pointer_button_down_on() {
+                    ui.ctx().move_to_top(ui.layer_id());
+                }
+                content(ui)
+            });
+
+        if let Some(popup_response) = &popup_response {
+            // If no child sub menu is open means we must be the deepest child sub menu.
+            let is_deepest_submenu = MenuState::is_deepest_open_sub_menu(ui.ctx(), id);
+
+            // If the user clicks and the cursor is not hovering over our menu rect, it's
+            // safe to assume they clicked outside the menu, so we close everything.
+            // If they were to hover some other parent submenu we wouldn't be open.
+            // Only edge case is the user hovering this submenu's button, so we also check
+            // if we clicked outside the parent menu (which we luckily have access to here).
+            let clicked_outside = is_deepest_submenu
+                && popup_response.response.clicked_elsewhere()
+                && menu_root_response.clicked_elsewhere();
+
+            // We never automatically close when a submenu button is clicked, (so menus work
+            // on touch devices)
+            // Luckily we will always be the deepest submenu when a submenu button is clicked,
+            // so the following check is enough.
+            let submenu_button_clicked = button_response.clicked();
+
+            let clicked_inside = is_deepest_submenu
+                && !submenu_button_clicked
+                && response.ctx.input(|i| i.pointer.any_click())
+                && hover_pos.is_some_and(|pos| popup_response.response.interact_rect.contains(pos));
+
+            let click_close = match menu_config.close_behavior {
+                PopupCloseBehavior::CloseOnClick => clicked_outside || clicked_inside,
+                PopupCloseBehavior::CloseOnClickOutside => clicked_outside,
+                PopupCloseBehavior::IgnoreClicks => false,
+            };
+
+            if click_close {
+                set_open = Some(false);
+                ui.close();
+            }
+
+            let is_moving_towards_rect = ui.input(|i| {
+                i.pointer
+                    .is_moving_towards_rect(&popup_response.response.rect)
+            });
+            if is_moving_towards_rect {
+                // We need to repaint while this is true, so we can detect when
+                // the pointer is no longer moving towards the rect
+                ui.ctx().request_repaint();
+            }
+            let hovering_other_menu_entry = is_open
+                && !is_hovered
+                && !popup_response.response.contains_pointer()
+                && !is_moving_towards_rect
+                && is_hovering_menu;
+
+            let close_called = popup_response.response.should_close();
+
+            // Close the parent ui to e.g. close the popup from where the submenu was opened
+            if close_called {
+                ui.close();
+            }
+
+            if hovering_other_menu_entry {
+                set_open = Some(false);
+            }
+
+            if ui.will_parent_close() {
+                ui.data_mut(|data| data.remove_by_type::<MenuState>());
+            }
+        }
+
+        if let Some(set_open) = set_open {
+            MenuState::from_id(ui.ctx(), menu_id, |state| {
+                state.open_item = set_open.then_some(id);
+            });
+        }
+
+        popup_response
+    }
+}
diff --git a/crates/egui/src/containers/mod.rs b/crates/egui/src/containers/mod.rs
index c1f80cb5e..a34ed1647 100644
--- a/crates/egui/src/containers/mod.rs
+++ b/crates/egui/src/containers/mod.rs
@@ -3,29 +3,36 @@
 //! For instance, a [`Frame`] adds a frame and background to some contained UI.
 
 pub(crate) mod area;
+mod close_tag;
 pub mod collapsing_header;
 mod combo_box;
 pub mod frame;
+pub mod menu;
 pub mod modal;
+pub mod old_popup;
 pub mod panel;
-pub mod popup;
+mod popup;
 pub(crate) mod resize;
 mod scene;
 pub mod scroll_area;
 mod sides;
+mod tooltip;
 pub(crate) mod window;
 
 pub use {
     area::{Area, AreaState},
+    close_tag::ClosableTag,
     collapsing_header::{CollapsingHeader, CollapsingResponse},
     combo_box::*,
     frame::Frame,
     modal::{Modal, ModalResponse},
-    panel::{CentralPanel, Panel, PanelSide, VerticalSide, HorizontalSide},
+    old_popup::*,
+    panel::{CentralPanel, HorizontalSide, Panel, PanelSide, VerticalSide},
     popup::*,
     resize::Resize,
-    scene::Scene,
+    scene::{DragPanButtons, Scene},
     scroll_area::ScrollArea,
     sides::Sides,
+    tooltip::*,
     window::Window,
 };
diff --git a/crates/egui/src/containers/modal.rs b/crates/egui/src/containers/modal.rs
index 8bf596675..23190ddf6 100644
--- a/crates/egui/src/containers/modal.rs
+++ b/crates/egui/src/containers/modal.rs
@@ -1,14 +1,18 @@
+use emath::{Align2, Vec2};
+
 use crate::{
     Area, Color32, Context, Frame, Id, InnerResponse, Order, Response, Sense, Ui, UiBuilder, UiKind,
 };
-use emath::{Align2, Vec2};
 
 /// A modal dialog.
+///
 /// Similar to a [`crate::Window`] but centered and with a backdrop that
 /// blocks input to the rest of the UI.
 ///
 /// You can show multiple modals on top of each other. The topmost modal will always be
 /// the most recently shown one.
+/// If multiple modals are newly shown in the same frame, the order of the modals is undefined
+/// (either first or second could be top).
 pub struct Modal {
     pub area: Area,
     pub backdrop_color: Color32,
@@ -16,7 +20,9 @@ pub struct Modal {
 }
 
 impl Modal {
-    /// Create a new Modal. The id is passed to the area.
+    /// Create a new Modal.
+    ///
+    /// The id is passed to the area.
     pub fn new(id: Id) -> Self {
         Self {
             area: Self::default_area(id),
@@ -26,6 +32,7 @@ impl Modal {
     }
 
     /// Returns an area customized for a modal.
+    ///
     /// Makes these changes to the default area:
     /// - sense: hover
     /// - anchor: center
@@ -74,18 +81,16 @@ impl Modal {
             frame,
         } = self;
 
-        let (is_top_modal, any_popup_open) = ctx.memory_mut(|mem| {
+        let is_top_modal = ctx.memory_mut(|mem| {
             mem.set_modal_layer(area.layer());
-            (
-                mem.top_modal_layer() == Some(area.layer()),
-                mem.any_popup_open(),
-            )
+            mem.top_modal_layer() == Some(area.layer())
         });
+        let any_popup_open = crate::Popup::is_any_open(ctx);
         let InnerResponse {
             inner: (inner, backdrop_response),
             response,
         } = area.show(ctx, |ui| {
-            let bg_rect = ui.ctx().screen_rect();
+            let bg_rect = ui.ctx().content_rect();
             let bg_sense = Sense::CLICK | Sense::DRAG;
             let mut backdrop = ui.new_child(UiBuilder::new().sense(bg_sense).max_rect(bg_rect));
             backdrop.set_min_size(bg_rect.size());
@@ -150,7 +155,10 @@ impl<T> ModalResponse<T> {
         let escape_clicked =
             || ctx.input_mut(|i| i.consume_key(crate::Modifiers::NONE, crate::Key::Escape));
 
+        let ui_close_called = self.response.should_close();
+
         self.backdrop_response.clicked()
+            || ui_close_called
             || (self.is_top_modal && !self.any_popup_open && escape_clicked())
     }
 }
diff --git a/crates/egui/src/containers/old_popup.rs b/crates/egui/src/containers/old_popup.rs
new file mode 100644
index 000000000..3ddf77bf6
--- /dev/null
+++ b/crates/egui/src/containers/old_popup.rs
@@ -0,0 +1,212 @@
+//! Old and deprecated API for popups. Use [`Popup`] instead.
+#![allow(deprecated)]
+
+use crate::containers::tooltip::Tooltip;
+use crate::{
+    Align, Context, Id, LayerId, Layout, Popup, PopupAnchor, PopupCloseBehavior, Pos2, Rect,
+    Response, Ui, Widget as _, WidgetText,
+};
+use emath::RectAlign;
+// ----------------------------------------------------------------------------
+
+/// 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| {
+/// # #[expect(deprecated)]
+/// if ui.ui_contains_pointer() {
+///     egui::show_tooltip(ui.ctx(), ui.layer_id(), egui::Id::new("my_tooltip"), |ui| {
+///         ui.label("Helpful text");
+///     });
+/// }
+/// # });
+/// ```
+#[deprecated = "Use `egui::Tooltip` instead"]
+pub fn show_tooltip<R>(
+    ctx: &Context,
+    parent_layer: LayerId,
+    widget_id: Id,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    show_tooltip_at_pointer(ctx, parent_layer, widget_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(), ui.layer_id(), egui::Id::new("my_tooltip"), |ui| {
+///         ui.label("Helpful text");
+///     });
+/// }
+/// # });
+/// ```
+#[deprecated = "Use `egui::Tooltip` instead"]
+pub fn show_tooltip_at_pointer<R>(
+    ctx: &Context,
+    parent_layer: LayerId,
+    widget_id: Id,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    Tooltip::always_open(ctx.clone(), parent_layer, widget_id, PopupAnchor::Pointer)
+        .gap(12.0)
+        .show(add_contents)
+        .map(|response| response.inner)
+}
+
+/// Show a tooltip under the given area.
+///
+/// If the tooltip does not fit under the area, it tries to place it above it instead.
+#[deprecated = "Use `egui::Tooltip` instead"]
+pub fn show_tooltip_for<R>(
+    ctx: &Context,
+    parent_layer: LayerId,
+    widget_id: Id,
+    widget_rect: &Rect,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    Tooltip::always_open(ctx.clone(), parent_layer, widget_id, *widget_rect)
+        .show(add_contents)
+        .map(|response| response.inner)
+}
+
+/// Show a tooltip at the given position.
+///
+/// Returns `None` if the tooltip could not be placed.
+#[deprecated = "Use `egui::Tooltip` instead"]
+pub fn show_tooltip_at<R>(
+    ctx: &Context,
+    parent_layer: LayerId,
+    widget_id: Id,
+    suggested_position: Pos2,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    Tooltip::always_open(ctx.clone(), parent_layer, widget_id, suggested_position)
+        .show(add_contents)
+        .map(|response| response.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(), ui.layer_id(), egui::Id::new("my_tooltip"), "Helpful text");
+/// }
+/// # });
+/// ```
+#[deprecated = "Use `egui::Tooltip` instead"]
+pub fn show_tooltip_text(
+    ctx: &Context,
+    parent_layer: LayerId,
+    widget_id: Id,
+    text: impl Into<WidgetText>,
+) -> Option<()> {
+    show_tooltip(ctx, parent_layer, widget_id, |ui| {
+        crate::widgets::Label::new(text).ui(ui);
+    })
+}
+
+/// Was this tooltip visible last frame?
+#[deprecated = "Use `Tooltip::was_tooltip_open_last_frame` instead"]
+pub fn was_tooltip_open_last_frame(ctx: &Context, widget_id: Id) -> bool {
+    Tooltip::was_tooltip_open_last_frame(ctx, widget_id)
+}
+
+/// Indicate whether a popup will be shown above or below the box.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AboveOrBelow {
+    Above,
+    Below,
+}
+
+/// Helper for [`popup_above_or_below_widget`].
+#[deprecated = "Use `egui::Popup` instead"]
+pub fn popup_below_widget<R>(
+    ui: &Ui,
+    popup_id: Id,
+    widget_response: &Response,
+    close_behavior: PopupCloseBehavior,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    popup_above_or_below_widget(
+        ui,
+        popup_id,
+        widget_response,
+        AboveOrBelow::Below,
+        close_behavior,
+        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 a minimum width matching its parent.
+///
+/// You must open the popup with [`crate::Memory::open_popup`] or  [`crate::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;
+/// let close_on_click_outside = egui::PopupCloseBehavior::CloseOnClickOutside;
+/// # #[expect(deprecated)]
+/// egui::popup_above_or_below_widget(ui, popup_id, &response, below, close_on_click_outside, |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("…");
+/// });
+/// # });
+/// ```
+#[deprecated = "Use `egui::Popup` instead"]
+pub fn popup_above_or_below_widget<R>(
+    _parent_ui: &Ui,
+    popup_id: Id,
+    widget_response: &Response,
+    above_or_below: AboveOrBelow,
+    close_behavior: PopupCloseBehavior,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
+    let response = Popup::from_response(widget_response)
+        .layout(Layout::top_down_justified(Align::LEFT))
+        .open_memory(None)
+        .close_behavior(close_behavior)
+        .id(popup_id)
+        .align(match above_or_below {
+            AboveOrBelow::Above => RectAlign::TOP_START,
+            AboveOrBelow::Below => RectAlign::BOTTOM_START,
+        })
+        .width(widget_response.rect.width())
+        .show(|ui| {
+            ui.set_min_width(ui.available_width());
+            add_contents(ui)
+        })?;
+    Some(response.inner)
+}
diff --git a/crates/egui/src/containers/popup.rs b/crates/egui/src/containers/popup.rs
index 81bf84a2f..a9c00661d 100644
--- a/crates/egui/src/containers/popup.rs
+++ b/crates/egui/src/containers/popup.rs
@@ -1,457 +1,699 @@
-//! Show popup windows, tooltips, context menus etc.
+#![expect(deprecated)] // This is a new, safe wrapper around the old `Memory::popup` API.
 
-use pass_state::PerWidgetTooltipState;
+use std::iter::once;
+
+use emath::{Align, Pos2, Rect, RectAlign, Vec2, vec2};
 
 use crate::{
-    pass_state, vec2, AboveOrBelow, Align, Align2, Area, AreaState, Context, Frame, Id,
-    InnerResponse, Key, LayerId, Layout, Order, Pos2, Rect, Response, Sense, Ui, UiKind, Vec2,
-    Widget, WidgetText,
+    Area, AreaState, Context, Frame, Id, InnerResponse, Key, LayerId, Layout, Order, Response,
+    Sense, Ui, UiKind, UiStackInfo,
+    containers::menu::{MenuConfig, MenuState, menu_style},
+    style::StyleModifier,
 };
 
-// ----------------------------------------------------------------------------
+/// What should we anchor the popup to?
+///
+/// The final position for the popup will be calculated based on [`RectAlign`]
+/// and can be customized with [`Popup::align`] and [`Popup::align_alternatives`].
+/// [`PopupAnchor`] is the parent rect of [`RectAlign`].
+///
+/// For [`PopupAnchor::Pointer`], [`PopupAnchor::PointerFixed`] and [`PopupAnchor::Position`],
+/// the rect will be derived via [`Rect::from_pos`] (so a zero-sized rect at the given position).
+///
+/// The rect should be in global coordinates. `PopupAnchor::from(&response)` will automatically
+/// do this conversion.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PopupAnchor {
+    /// Show the popup relative to some parent [`Rect`].
+    ParentRect(Rect),
 
-fn when_was_a_toolip_last_shown_id() -> Id {
-    Id::new("when_was_a_toolip_last_shown")
+    /// Show the popup relative to the mouse pointer.
+    Pointer,
+
+    /// Remember the mouse position and show the popup relative to that (like a context menu).
+    PointerFixed,
+
+    /// Show the popup relative to a specific position.
+    Position(Pos2),
 }
 
-pub fn seconds_since_last_tooltip(ctx: &Context) -> f32 {
-    let when_was_a_toolip_last_shown =
-        ctx.data(|d| d.get_temp::<f64>(when_was_a_toolip_last_shown_id()));
-
-    if let Some(when_was_a_toolip_last_shown) = when_was_a_toolip_last_shown {
-        let now = ctx.input(|i| i.time);
-        (now - when_was_a_toolip_last_shown) as f32
-    } else {
-        f32::INFINITY
+impl From<Rect> for PopupAnchor {
+    fn from(rect: Rect) -> Self {
+        Self::ParentRect(rect)
     }
 }
 
-fn remember_that_tooltip_was_shown(ctx: &Context) {
-    let now = ctx.input(|i| i.time);
-    ctx.data_mut(|data| data.insert_temp::<f64>(when_was_a_toolip_last_shown_id(), now));
+impl From<Pos2> for PopupAnchor {
+    fn from(pos: Pos2) -> Self {
+        Self::Position(pos)
+    }
 }
 
-// ----------------------------------------------------------------------------
-
-/// 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(), ui.layer_id(), egui::Id::new("my_tooltip"), |ui| {
-///         ui.label("Helpful text");
-///     });
-/// }
-/// # });
-/// ```
-pub fn show_tooltip<R>(
-    ctx: &Context,
-    parent_layer: LayerId,
-    widget_id: Id,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    show_tooltip_at_pointer(ctx, parent_layer, widget_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(), ui.layer_id(), egui::Id::new("my_tooltip"), |ui| {
-///         ui.label("Helpful text");
-///     });
-/// }
-/// # });
-/// ```
-pub fn show_tooltip_at_pointer<R>(
-    ctx: &Context,
-    parent_layer: LayerId,
-    widget_id: Id,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    ctx.input(|i| i.pointer.hover_pos()).map(|pointer_pos| {
-        let allow_placing_below = true;
-
-        // Add a small exclusion zone around the pointer to avoid tooltips
-        // covering what we're hovering over.
-        let mut pointer_rect = Rect::from_center_size(pointer_pos, Vec2::splat(24.0));
-
-        // Keep the left edge of the tooltip in line with the cursor:
-        pointer_rect.min.x = pointer_pos.x;
-
-        // Transform global coords to layer coords:
-        if let Some(from_global) = ctx.layer_transform_from_global(parent_layer) {
-            pointer_rect = from_global * pointer_rect;
+impl From<&Response> for PopupAnchor {
+    fn from(response: &Response) -> Self {
+        // We use interact_rect so we don't show the popup relative to some clipped point
+        let mut widget_rect = response.interact_rect;
+        if let Some(to_global) = response.ctx.layer_transform_to_global(response.layer_id) {
+            widget_rect = to_global * widget_rect;
         }
-
-        show_tooltip_at_dyn(
-            ctx,
-            parent_layer,
-            widget_id,
-            allow_placing_below,
-            &pointer_rect,
-            Box::new(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,
-    parent_layer: LayerId,
-    widget_id: Id,
-    widget_rect: &Rect,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> R {
-    let is_touch_screen = ctx.input(|i| i.any_touches());
-    let allow_placing_below = !is_touch_screen; // There is a finger below.
-    show_tooltip_at_dyn(
-        ctx,
-        parent_layer,
-        widget_id,
-        allow_placing_below,
-        widget_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,
-    parent_layer: LayerId,
-    widget_id: Id,
-    suggested_position: Pos2,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> R {
-    let allow_placing_below = true;
-    let rect = Rect::from_center_size(suggested_position, Vec2::ZERO);
-    show_tooltip_at_dyn(
-        ctx,
-        parent_layer,
-        widget_id,
-        allow_placing_below,
-        &rect,
-        Box::new(add_contents),
-    )
-}
-
-fn show_tooltip_at_dyn<'c, R>(
-    ctx: &Context,
-    parent_layer: LayerId,
-    widget_id: Id,
-    allow_placing_below: bool,
-    widget_rect: &Rect,
-    add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
-) -> R {
-    // Transform layer coords to global coords:
-    let mut widget_rect = *widget_rect;
-    if let Some(to_global) = ctx.layer_transform_to_global(parent_layer) {
-        widget_rect = to_global * widget_rect;
+        Self::ParentRect(widget_rect)
     }
-
-    remember_that_tooltip_was_shown(ctx);
-
-    let mut state = ctx.pass_state_mut(|fs| {
-        // Remember that this is the widget showing the tooltip:
-        fs.layers
-            .entry(parent_layer)
-            .or_default()
-            .widget_with_tooltip = Some(widget_id);
-
-        fs.tooltips
-            .widget_tooltips
-            .get(&widget_id)
-            .copied()
-            .unwrap_or(PerWidgetTooltipState {
-                bounding_rect: widget_rect,
-                tooltip_count: 0,
-            })
-    });
-
-    let tooltip_area_id = tooltip_id(widget_id, state.tooltip_count);
-    let expected_tooltip_size = AreaState::load(ctx, tooltip_area_id)
-        .and_then(|area| area.size)
-        .unwrap_or(vec2(64.0, 32.0));
-
-    let screen_rect = ctx.screen_rect();
-
-    let (pivot, anchor) = find_tooltip_position(
-        screen_rect,
-        state.bounding_rect,
-        allow_placing_below,
-        expected_tooltip_size,
-    );
-
-    let InnerResponse { inner, response } = Area::new(tooltip_area_id)
-        .kind(UiKind::Popup)
-        .order(Order::Tooltip)
-        .pivot(pivot)
-        .fixed_pos(anchor)
-        .default_width(ctx.style().spacing.tooltip_width)
-        .sense(Sense::hover()) // don't click to bring to front
-        .show(ctx, |ui| {
-            // By default the text in tooltips aren't selectable.
-            // This means that most tooltips aren't interactable,
-            // which also mean they won't stick around so you can click them.
-            // Only tooltips that have actual interactive stuff (buttons, links, …)
-            // will stick around when you try to click them.
-            ui.style_mut().interaction.selectable_labels = false;
-
-            Frame::popup(&ctx.style()).show_dyn(ui, add_contents).inner
-        });
-
-    state.tooltip_count += 1;
-    state.bounding_rect = state.bounding_rect.union(response.rect);
-    ctx.pass_state_mut(|fs| fs.tooltips.widget_tooltips.insert(widget_id, state));
-
-    inner
 }
 
-/// What is the id of the next tooltip for this widget?
-pub fn next_tooltip_id(ctx: &Context, widget_id: Id) -> Id {
-    let tooltip_count = ctx.pass_state(|fs| {
-        fs.tooltips
-            .widget_tooltips
-            .get(&widget_id)
-            .map_or(0, |state| state.tooltip_count)
-    });
-    tooltip_id(widget_id, tooltip_count)
-}
-
-pub fn tooltip_id(widget_id: Id, tooltip_count: usize) -> Id {
-    widget_id.with(tooltip_count)
-}
-
-/// Returns `(PIVOT, POS)` to mean: put the `PIVOT` corner of the tooltip at `POS`.
-///
-/// Note: the position might need to be constrained to the screen,
-/// (e.g. moved sideways if shown under the widget)
-/// but the `Area` will take care of that.
-fn find_tooltip_position(
-    screen_rect: Rect,
-    widget_rect: Rect,
-    allow_placing_below: bool,
-    tooltip_size: Vec2,
-) -> (Align2, Pos2) {
-    let spacing = 4.0;
-
-    // Does it fit below?
-    if allow_placing_below
-        && widget_rect.bottom() + spacing + tooltip_size.y <= screen_rect.bottom()
-    {
-        return (
-            Align2::LEFT_TOP,
-            widget_rect.left_bottom() + spacing * Vec2::DOWN,
-        );
+impl PopupAnchor {
+    /// Get the rect the popup should be shown relative to.
+    /// Returns `Rect::from_pos` for [`PopupAnchor::Pointer`], [`PopupAnchor::PointerFixed`]
+    /// and [`PopupAnchor::Position`] (so the rect will be zero-sized).
+    pub fn rect(self, popup_id: Id, ctx: &Context) -> Option<Rect> {
+        match self {
+            Self::ParentRect(rect) => Some(rect),
+            Self::Pointer => ctx.pointer_hover_pos().map(Rect::from_pos),
+            Self::PointerFixed => Popup::position_of_id(ctx, popup_id).map(Rect::from_pos),
+            Self::Position(pos) => Some(Rect::from_pos(pos)),
+        }
     }
-
-    // Does it fit above?
-    if screen_rect.top() + tooltip_size.y + spacing <= widget_rect.top() {
-        return (
-            Align2::LEFT_BOTTOM,
-            widget_rect.left_top() + spacing * Vec2::UP,
-        );
-    }
-
-    // Does it fit to the right?
-    if widget_rect.right() + spacing + tooltip_size.x <= screen_rect.right() {
-        return (
-            Align2::LEFT_TOP,
-            widget_rect.right_top() + spacing * Vec2::RIGHT,
-        );
-    }
-
-    // Does it fit to the left?
-    if screen_rect.left() + tooltip_size.x + spacing <= widget_rect.left() {
-        return (
-            Align2::RIGHT_TOP,
-            widget_rect.left_top() + spacing * Vec2::LEFT,
-        );
-    }
-
-    // It doesn't fit anywhere :(
-
-    // Just show it anyway:
-    (Align2::LEFT_TOP, screen_rect.left_top())
-}
-
-/// 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(), ui.layer_id(), egui::Id::new("my_tooltip"), "Helpful text");
-/// }
-/// # });
-/// ```
-pub fn show_tooltip_text(
-    ctx: &Context,
-    parent_layer: LayerId,
-    widget_id: Id,
-    text: impl Into<WidgetText>,
-) -> Option<()> {
-    show_tooltip(ctx, parent_layer, widget_id, |ui| {
-        crate::widgets::Label::new(text).ui(ui);
-    })
-}
-
-/// Was this popup visible last frame?
-pub fn was_tooltip_open_last_frame(ctx: &Context, widget_id: Id) -> bool {
-    let primary_tooltip_area_id = tooltip_id(widget_id, 0);
-    ctx.memory(|mem| {
-        mem.areas()
-            .visible_last_frame(&LayerId::new(Order::Tooltip, primary_tooltip_area_id))
-    })
 }
 
 /// Determines popup's close behavior
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq, Default, Debug)]
 pub enum PopupCloseBehavior {
     /// Popup will be closed on click anywhere, inside or outside the popup.
     ///
-    /// It is used in [`crate::ComboBox`].
+    /// It is used in [`crate::ComboBox`] and in [`crate::containers::menu`]s.
+    #[default]
     CloseOnClick,
 
     /// Popup will be closed if the click happened somewhere else
     /// but in the popup's body
     CloseOnClickOutside,
 
-    /// Clicks will be ignored. Popup might be closed manually by calling [`crate::Memory::close_popup`]
+    /// Clicks will be ignored. Popup might be closed manually by calling [`crate::Memory::close_all_popups`]
     /// or by pressing the escape button
     IgnoreClicks,
 }
 
-/// Helper for [`popup_above_or_below_widget`].
-pub fn popup_below_widget<R>(
-    ui: &Ui,
-    popup_id: Id,
-    widget_response: &Response,
-    close_behavior: PopupCloseBehavior,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    popup_above_or_below_widget(
-        ui,
-        popup_id,
-        widget_response,
-        AboveOrBelow::Below,
-        close_behavior,
-        add_contents,
-    )
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SetOpenCommand {
+    /// Set the open state to the given value
+    Bool(bool),
+
+    /// Toggle the open state
+    Toggle,
 }
 
-/// 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 a minimum width matching its parent.
-///
-/// You must open the popup with [`crate::Memory::open_popup`] or  [`crate::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;
-/// let close_on_click_outside = egui::popup::PopupCloseBehavior::CloseOnClickOutside;
-/// egui::popup::popup_above_or_below_widget(ui, popup_id, &response, below, close_on_click_outside, |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>(
-    parent_ui: &Ui,
-    popup_id: Id,
-    widget_response: &Response,
-    above_or_below: AboveOrBelow,
+impl From<bool> for SetOpenCommand {
+    fn from(b: bool) -> Self {
+        Self::Bool(b)
+    }
+}
+
+/// How do we determine if the popup should be open or closed
+enum OpenKind<'a> {
+    /// Always open
+    Open,
+
+    /// Always closed
+    Closed,
+
+    /// Open if the bool is true
+    Bool(&'a mut bool),
+
+    /// Store the open state via [`crate::Memory`]
+    Memory { set: Option<SetOpenCommand> },
+}
+
+impl OpenKind<'_> {
+    /// Returns `true` if the popup should be open
+    fn is_open(&self, popup_id: Id, ctx: &Context) -> bool {
+        match self {
+            OpenKind::Open => true,
+            OpenKind::Closed => false,
+            OpenKind::Bool(open) => **open,
+            OpenKind::Memory { .. } => Popup::is_id_open(ctx, popup_id),
+        }
+    }
+}
+
+/// Is the popup a popup, tooltip or menu?
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PopupKind {
+    Popup,
+    Tooltip,
+    Menu,
+}
+
+impl PopupKind {
+    /// Returns the order to be used with this kind.
+    pub fn order(self) -> Order {
+        match self {
+            Self::Tooltip => Order::Tooltip,
+            Self::Menu | Self::Popup => Order::Foreground,
+        }
+    }
+}
+
+impl From<PopupKind> for UiKind {
+    fn from(kind: PopupKind) -> Self {
+        match kind {
+            PopupKind::Popup => Self::Popup,
+            PopupKind::Tooltip => Self::Tooltip,
+            PopupKind::Menu => Self::Menu,
+        }
+    }
+}
+
+/// A popup container.
+#[must_use = "Call `.show()` to actually display the popup"]
+pub struct Popup<'a> {
+    id: Id,
+    ctx: Context,
+    anchor: PopupAnchor,
+    rect_align: RectAlign,
+    alternative_aligns: Option<&'a [RectAlign]>,
+    layer_id: LayerId,
+    open_kind: OpenKind<'a>,
     close_behavior: PopupCloseBehavior,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    if !parent_ui.memory(|mem| mem.is_popup_open(popup_id)) {
-        return None;
+    info: Option<UiStackInfo>,
+    kind: PopupKind,
+
+    /// Gap between the anchor and the popup
+    gap: f32,
+
+    /// Default width passed to the Area
+    width: Option<f32>,
+    sense: Sense,
+    layout: Layout,
+    frame: Option<Frame>,
+    style: StyleModifier,
+}
+
+impl<'a> Popup<'a> {
+    /// Create a new popup
+    pub fn new(id: Id, ctx: Context, anchor: impl Into<PopupAnchor>, layer_id: LayerId) -> Self {
+        Self {
+            id,
+            ctx,
+            anchor: anchor.into(),
+            open_kind: OpenKind::Open,
+            close_behavior: PopupCloseBehavior::default(),
+            info: None,
+            kind: PopupKind::Popup,
+            layer_id,
+            rect_align: RectAlign::BOTTOM_START,
+            alternative_aligns: None,
+            gap: 0.0,
+            width: None,
+            sense: Sense::click(),
+            layout: Layout::default(),
+            frame: None,
+            style: StyleModifier::default(),
+        }
     }
 
-    let (mut 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),
-    };
-
-    if let Some(to_global) = parent_ui
-        .ctx()
-        .layer_transform_to_global(parent_ui.layer_id())
-    {
-        pos = to_global * pos;
+    /// Show a popup relative to some widget.
+    /// The popup will be always open.
+    ///
+    /// See [`Self::menu`] and [`Self::context_menu`] for common use cases.
+    pub fn from_response(response: &Response) -> Self {
+        Self::new(
+            Self::default_response_id(response),
+            response.ctx.clone(),
+            response,
+            response.layer_id,
+        )
     }
 
-    let frame = Frame::popup(parent_ui.style());
-    let frame_margin = frame.total_margin();
-    let inner_width = (widget_response.rect.width() - frame_margin.sum().x).max(0.0);
+    /// Show a popup relative to some widget,
+    /// toggling the open state based on the widget's click state.
+    ///
+    /// See [`Self::menu`] and [`Self::context_menu`] for common use cases.
+    pub fn from_toggle_button_response(button_response: &Response) -> Self {
+        Self::from_response(button_response)
+            .open_memory(button_response.clicked().then_some(SetOpenCommand::Toggle))
+    }
 
-    parent_ui.ctx().pass_state_mut(|fs| {
-        fs.layers
-            .entry(parent_ui.layer_id())
-            .or_default()
-            .open_popups
-            .insert(popup_id)
-    });
+    /// Show a popup when the widget was clicked.
+    /// Sets the layout to `Layout::top_down_justified(Align::Min)`.
+    pub fn menu(button_response: &Response) -> Self {
+        Self::from_toggle_button_response(button_response)
+            .kind(PopupKind::Menu)
+            .layout(Layout::top_down_justified(Align::Min))
+            .style(menu_style)
+            .gap(0.0)
+    }
 
-    let response = Area::new(popup_id)
-        .kind(UiKind::Popup)
-        .order(Order::Foreground)
-        .fixed_pos(pos)
-        .default_width(inner_width)
-        .pivot(pivot)
-        .show(parent_ui.ctx(), |ui| {
-            frame
-                .show(ui, |ui| {
-                    ui.with_layout(Layout::top_down_justified(Align::LEFT), |ui| {
-                        ui.set_min_width(inner_width);
-                        add_contents(ui)
-                    })
-                    .inner
-                })
-                .inner
+    /// Show a context menu when the widget was secondary clicked.
+    /// Sets the layout to `Layout::top_down_justified(Align::Min)`.
+    /// In contrast to [`Self::menu`], this will open at the pointer position.
+    pub fn context_menu(response: &Response) -> Self {
+        Self::menu(response)
+            .open_memory(if response.secondary_clicked() {
+                Some(SetOpenCommand::Bool(true))
+            } else if response.clicked() {
+                // Explicitly close the menu if the widget was clicked
+                // Without this, the context menu would stay open if the user clicks the widget
+                Some(SetOpenCommand::Bool(false))
+            } else {
+                None
+            })
+            .at_pointer_fixed()
+    }
+
+    /// Set the kind of the popup. Used for [`Area::kind`] and [`Area::order`].
+    #[inline]
+    pub fn kind(mut self, kind: PopupKind) -> Self {
+        self.kind = kind;
+        self
+    }
+
+    /// Set the [`UiStackInfo`] of the popup's [`Ui`].
+    #[inline]
+    pub fn info(mut self, info: UiStackInfo) -> Self {
+        self.info = Some(info);
+        self
+    }
+
+    /// Set the [`RectAlign`] of the popup relative to the [`PopupAnchor`].
+    /// This is the default position, and will be used if it fits.
+    /// See [`Self::align_alternatives`] for more on this.
+    #[inline]
+    pub fn align(mut self, position_align: RectAlign) -> Self {
+        self.rect_align = position_align;
+        self
+    }
+
+    /// Set alternative positions to try if the default one doesn't fit. Set to an empty slice to
+    /// always use the position you set with [`Self::align`].
+    /// By default, this will try [`RectAlign::symmetries`] and then [`RectAlign::MENU_ALIGNS`].
+    #[inline]
+    pub fn align_alternatives(mut self, alternatives: &'a [RectAlign]) -> Self {
+        self.alternative_aligns = Some(alternatives);
+        self
+    }
+
+    /// Force the popup to be open or closed.
+    #[inline]
+    pub fn open(mut self, open: bool) -> Self {
+        self.open_kind = if open {
+            OpenKind::Open
+        } else {
+            OpenKind::Closed
+        };
+        self
+    }
+
+    /// Store the open state via [`crate::Memory`].
+    /// You can set the state via the first [`SetOpenCommand`] param.
+    #[inline]
+    pub fn open_memory(mut self, set_state: impl Into<Option<SetOpenCommand>>) -> Self {
+        self.open_kind = OpenKind::Memory {
+            set: set_state.into(),
+        };
+        self
+    }
+
+    /// Store the open state via a mutable bool.
+    #[inline]
+    pub fn open_bool(mut self, open: &'a mut bool) -> Self {
+        self.open_kind = OpenKind::Bool(open);
+        self
+    }
+
+    /// Set the close behavior of the popup.
+    ///
+    /// This will do nothing if [`Popup::open`] was called.
+    #[inline]
+    pub fn close_behavior(mut self, close_behavior: PopupCloseBehavior) -> Self {
+        self.close_behavior = close_behavior;
+        self
+    }
+
+    /// Show the popup relative to the pointer.
+    #[inline]
+    pub fn at_pointer(mut self) -> Self {
+        self.anchor = PopupAnchor::Pointer;
+        self
+    }
+
+    /// Remember the pointer position at the time of opening the popup, and show the popup
+    /// relative to that.
+    #[inline]
+    pub fn at_pointer_fixed(mut self) -> Self {
+        self.anchor = PopupAnchor::PointerFixed;
+        self
+    }
+
+    /// Show the popup relative to a specific position.
+    #[inline]
+    pub fn at_position(mut self, position: Pos2) -> Self {
+        self.anchor = PopupAnchor::Position(position);
+        self
+    }
+
+    /// Show the popup relative to the given [`PopupAnchor`].
+    #[inline]
+    pub fn anchor(mut self, anchor: impl Into<PopupAnchor>) -> Self {
+        self.anchor = anchor.into();
+        self
+    }
+
+    /// Set the gap between the anchor and the popup.
+    #[inline]
+    pub fn gap(mut self, gap: f32) -> Self {
+        self.gap = gap;
+        self
+    }
+
+    /// Set the frame of the popup.
+    #[inline]
+    pub fn frame(mut self, frame: Frame) -> Self {
+        self.frame = Some(frame);
+        self
+    }
+
+    /// Set the sense of the popup.
+    #[inline]
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = sense;
+        self
+    }
+
+    /// Set the layout of the popup.
+    #[inline]
+    pub fn layout(mut self, layout: Layout) -> Self {
+        self.layout = layout;
+        self
+    }
+
+    /// The width that will be passed to [`Area::default_width`].
+    #[inline]
+    pub fn width(mut self, width: f32) -> Self {
+        self.width = Some(width);
+        self
+    }
+
+    /// Set the id of the Area.
+    #[inline]
+    pub fn id(mut self, id: Id) -> Self {
+        self.id = id;
+        self
+    }
+
+    /// Set the style for the popup contents.
+    ///
+    /// Default:
+    /// - is [`menu_style`] for [`Self::menu`] and [`Self::context_menu`]
+    /// - is [`None`] otherwise
+    #[inline]
+    pub fn style(mut self, style: impl Into<StyleModifier>) -> Self {
+        self.style = style.into();
+        self
+    }
+
+    /// Get the [`Context`]
+    pub fn ctx(&self) -> &Context {
+        &self.ctx
+    }
+
+    /// Return the [`PopupAnchor`] of the popup.
+    pub fn get_anchor(&self) -> PopupAnchor {
+        self.anchor
+    }
+
+    /// Return the anchor rect of the popup.
+    ///
+    /// Returns `None` if the anchor is [`PopupAnchor::Pointer`] and there is no pointer.
+    pub fn get_anchor_rect(&self) -> Option<Rect> {
+        self.anchor.rect(self.id, &self.ctx)
+    }
+
+    /// Get the expected rect the popup will be shown in.
+    ///
+    /// Returns `None` if the popup wasn't shown before or anchor is `PopupAnchor::Pointer` and
+    /// there is no pointer.
+    pub fn get_popup_rect(&self) -> Option<Rect> {
+        let size = self.get_expected_size();
+        if let Some(size) = size {
+            self.get_anchor_rect()
+                .map(|anchor| self.get_best_align().align_rect(&anchor, size, self.gap))
+        } else {
+            None
+        }
+    }
+
+    /// Get the id of the popup.
+    pub fn get_id(&self) -> Id {
+        self.id
+    }
+
+    /// Is the popup open?
+    pub fn is_open(&self) -> bool {
+        match &self.open_kind {
+            OpenKind::Open => true,
+            OpenKind::Closed => false,
+            OpenKind::Bool(open) => **open,
+            OpenKind::Memory { .. } => Self::is_id_open(&self.ctx, self.id),
+        }
+    }
+
+    /// Get the expected size of the popup.
+    pub fn get_expected_size(&self) -> Option<Vec2> {
+        AreaState::load(&self.ctx, self.id)?.size
+    }
+
+    /// Calculate the best alignment for the popup, based on the last size and screen rect.
+    pub fn get_best_align(&self) -> RectAlign {
+        let expected_popup_size = self
+            .get_expected_size()
+            .unwrap_or(vec2(self.width.unwrap_or(0.0), 0.0));
+
+        let Some(anchor_rect) = self.anchor.rect(self.id, &self.ctx) else {
+            return self.rect_align;
+        };
+
+        RectAlign::find_best_align(
+            #[expect(clippy::iter_on_empty_collections)]
+            once(self.rect_align).chain(
+                self.alternative_aligns
+                    // Need the empty slice so the iters have the same type so we can unwrap_or
+                    .map(|a| a.iter().copied().chain([].iter().copied()))
+                    .unwrap_or(
+                        self.rect_align
+                            .symmetries()
+                            .iter()
+                            .copied()
+                            .chain(RectAlign::MENU_ALIGNS.iter().copied()),
+                    ),
+            ),
+            self.ctx.content_rect(),
+            anchor_rect,
+            self.gap,
+            expected_popup_size,
+        )
+        .unwrap_or_default()
+    }
+
+    /// Show the popup.
+    ///
+    /// Returns `None` if the popup is not open or anchor is `PopupAnchor::Pointer` and there is
+    /// no pointer.
+    pub fn show<R>(self, content: impl FnOnce(&mut Ui) -> R) -> Option<InnerResponse<R>> {
+        let id = self.id;
+        // When the popup was just opened with a click we don't want to immediately close it based
+        // on the `PopupCloseBehavior`, so we need to remember if the popup was already open on
+        // last frame. A convenient way to check this is to see if we have a response for the `Area`
+        // from last frame:
+        let was_open_last_frame = self.ctx.read_response(id).is_some();
+
+        let hover_pos = self.ctx.pointer_hover_pos();
+        if let OpenKind::Memory { set } = self.open_kind {
+            match set {
+                Some(SetOpenCommand::Bool(open)) => {
+                    if open {
+                        match self.anchor {
+                            PopupAnchor::PointerFixed => {
+                                self.ctx.memory_mut(|mem| mem.open_popup_at(id, hover_pos));
+                            }
+                            _ => Popup::open_id(&self.ctx, id),
+                        }
+                    } else {
+                        Self::close_id(&self.ctx, id);
+                    }
+                }
+                Some(SetOpenCommand::Toggle) => {
+                    Self::toggle_id(&self.ctx, id);
+                }
+                None => {
+                    self.ctx.memory_mut(|mem| mem.keep_popup_open(id));
+                }
+            }
+        }
+
+        if !self.open_kind.is_open(self.id, &self.ctx) {
+            return None;
+        }
+
+        let best_align = self.get_best_align();
+
+        let Popup {
+            id,
+            ctx,
+            anchor,
+            open_kind,
+            close_behavior,
+            kind,
+            info,
+            layer_id,
+            rect_align: _,
+            alternative_aligns: _,
+            gap,
+            width,
+            sense,
+            layout,
+            frame,
+            style,
+        } = self;
+
+        if kind != PopupKind::Tooltip {
+            ctx.pass_state_mut(|fs| {
+                fs.layers
+                    .entry(layer_id)
+                    .or_default()
+                    .open_popups
+                    .insert(id)
+            });
+        }
+
+        let anchor_rect = anchor.rect(id, &ctx)?;
+
+        let (pivot, anchor) = best_align.pivot_pos(&anchor_rect, gap);
+
+        let mut area = Area::new(id)
+            .order(kind.order())
+            .pivot(pivot)
+            .fixed_pos(anchor)
+            .sense(sense)
+            .layout(layout)
+            .info(info.unwrap_or_else(|| {
+                UiStackInfo::new(kind.into()).with_tag_value(
+                    MenuConfig::MENU_CONFIG_TAG,
+                    MenuConfig::new()
+                        .close_behavior(close_behavior)
+                        .style(style.clone()),
+                )
+            }));
+
+        if let Some(width) = width {
+            area = area.default_width(width);
+        }
+
+        let mut response = area.show(&ctx, |ui| {
+            style.apply(ui.style_mut());
+            let frame = frame.unwrap_or_else(|| Frame::popup(ui.style()));
+            frame.show(ui, content).inner
         });
 
-    let should_close = match close_behavior {
-        PopupCloseBehavior::CloseOnClick => widget_response.clicked_elsewhere(),
-        PopupCloseBehavior::CloseOnClickOutside => {
-            widget_response.clicked_elsewhere() && response.response.clicked_elsewhere()
-        }
-        PopupCloseBehavior::IgnoreClicks => false,
-    };
+        // If the popup was just opened with a click, we don't want to immediately close it again.
+        let close_click = was_open_last_frame && ctx.input(|i| i.pointer.any_click());
 
-    if parent_ui.input(|i| i.key_pressed(Key::Escape)) || should_close {
-        parent_ui.memory_mut(|mem| mem.close_popup());
+        let closed_by_click = match close_behavior {
+            PopupCloseBehavior::CloseOnClick => close_click,
+            PopupCloseBehavior::CloseOnClickOutside => {
+                close_click && response.response.clicked_elsewhere()
+            }
+            PopupCloseBehavior::IgnoreClicks => false,
+        };
+
+        // Mark the menu as shown, so the sub menu open state is not reset
+        MenuState::mark_shown(&ctx, id);
+
+        // If a submenu is open, the CloseBehavior is handled there
+        let is_any_submenu_open = !MenuState::is_deepest_open_sub_menu(&response.response.ctx, id);
+
+        let should_close = (!is_any_submenu_open && closed_by_click)
+            || ctx.input(|i| i.key_pressed(Key::Escape))
+            || response.response.should_close();
+
+        if should_close {
+            response.response.set_close();
+        }
+
+        match open_kind {
+            OpenKind::Open | OpenKind::Closed => {}
+            OpenKind::Bool(open) => {
+                if should_close {
+                    *open = false;
+                }
+            }
+            OpenKind::Memory { .. } => {
+                if should_close {
+                    ctx.memory_mut(|mem| mem.close_popup(id));
+                }
+            }
+        }
+
+        Some(response)
+    }
+}
+
+/// ## Static methods
+impl Popup<'_> {
+    /// The default ID when constructing a popup from the [`Response`] of e.g. a button.
+    pub fn default_response_id(response: &Response) -> Id {
+        response.id.with("popup")
+    }
+
+    /// Is the given popup open?
+    ///
+    /// This assumes the use of either:
+    /// * [`Self::open_memory`]
+    /// * [`Self::from_toggle_button_response`]
+    /// * [`Self::menu`]
+    /// * [`Self::context_menu`]
+    ///
+    /// The popup id should be the same as either you set with [`Self::id`] or the
+    /// default one from [`Self::default_response_id`].
+    pub fn is_id_open(ctx: &Context, popup_id: Id) -> bool {
+        ctx.memory(|mem| mem.is_popup_open(popup_id))
+    }
+
+    /// Is any popup open?
+    ///
+    /// This assumes the egui memory is being used to track the open state of popups.
+    pub fn is_any_open(ctx: &Context) -> bool {
+        ctx.memory(|mem| mem.any_popup_open())
+    }
+
+    /// Open the given popup and close all others.
+    ///
+    /// If you are NOT using [`Popup::show`], you must
+    /// also call [`crate::Memory::keep_popup_open`] as long as
+    /// you're showing the popup.
+    pub fn open_id(ctx: &Context, popup_id: Id) {
+        ctx.memory_mut(|mem| mem.open_popup(popup_id));
+    }
+
+    /// Toggle the given popup between closed and open.
+    ///
+    /// Note: At most, only one popup can be open at a time.
+    pub fn toggle_id(ctx: &Context, popup_id: Id) {
+        ctx.memory_mut(|mem| mem.toggle_popup(popup_id));
+    }
+
+    /// Close all currently open popups.
+    pub fn close_all(ctx: &Context) {
+        ctx.memory_mut(|mem| mem.close_all_popups());
+    }
+
+    /// Close the given popup, if it is open.
+    ///
+    /// See also [`Self::close_all`] if you want to close any / all currently open popups.
+    pub fn close_id(ctx: &Context, popup_id: Id) {
+        ctx.memory_mut(|mem| mem.close_popup(popup_id));
+    }
+
+    /// Get the position for this popup, if it is open.
+    pub fn position_of_id(ctx: &Context, popup_id: Id) -> Option<Pos2> {
+        ctx.memory(|mem| mem.popup_position(popup_id))
     }
-    Some(response.inner)
 }
diff --git a/crates/egui/src/containers/resize.rs b/crates/egui/src/containers/resize.rs
index 0df9a1136..50cc28774 100644
--- a/crates/egui/src/containers/resize.rs
+++ b/crates/egui/src/containers/resize.rs
@@ -1,6 +1,6 @@
 use crate::{
-    pos2, vec2, Align2, Color32, Context, CursorIcon, Id, NumExt, Rect, Response, Sense, Shape, Ui,
-    UiBuilder, UiKind, UiStackInfo, Vec2, Vec2b,
+    Align2, Color32, Context, CursorIcon, Id, NumExt as _, Rect, Response, Sense, Shape, Ui,
+    UiBuilder, UiKind, UiStackInfo, Vec2, Vec2b, pos2, vec2,
 };
 
 #[derive(Clone, Copy, Debug)]
@@ -220,7 +220,7 @@ impl Resize {
                 .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
+                    ui.ctx().content_rect().size() - ui.spacing().window_margin.sum(), // hack for windows
                 )
                 .round_ui();
 
@@ -241,14 +241,12 @@ impl Resize {
 
         let corner_id = self.resizable.any().then(|| id.with("__resize_corner"));
 
-        if let Some(corner_id) = corner_id {
-            if let Some(corner_response) = ui.ctx().read_response(corner_id) {
-                if let Some(pointer_pos) = corner_response.interact_pointer_pos() {
-                    // Respond to the interaction early to avoid frame delay.
-                    user_requested_size =
-                        Some(pointer_pos - position + 0.5 * corner_response.rect.size());
-                }
-            }
+        if let Some(corner_id) = corner_id
+            && let Some(corner_response) = ui.ctx().read_response(corner_id)
+            && let Some(pointer_pos) = corner_response.interact_pointer_pos()
+        {
+            // Respond to the interaction early to avoid frame delay.
+            user_requested_size = Some(pointer_pos - position + 0.5 * corner_response.rect.size());
         }
 
         if let Some(user_requested_size) = user_requested_size {
diff --git a/crates/egui/src/containers/scene.rs b/crates/egui/src/containers/scene.rs
index 5deeb01b6..36222b138 100644
--- a/crates/egui/src/containers/scene.rs
+++ b/crates/egui/src/containers/scene.rs
@@ -1,9 +1,10 @@
 use core::f32;
 
-use emath::{GuiRounding, Pos2};
+use emath::{GuiRounding as _, Pos2};
 
 use crate::{
-    emath::TSTransform, InnerResponse, LayerId, Rangef, Rect, Response, Sense, Ui, UiBuilder, Vec2,
+    InnerResponse, LayerId, PointerButton, Rangef, Rect, Response, Sense, Ui, UiBuilder, Vec2,
+    emath::TSTransform,
 };
 
 /// Creates a transformation that fits a given scene rectangle into the available screen size.
@@ -44,14 +45,41 @@ fn fit_to_rect_in_scene(
 #[must_use = "You should call .show()"]
 pub struct Scene {
     zoom_range: Rangef,
+    sense: Sense,
     max_inner_size: Vec2,
+    drag_pan_buttons: DragPanButtons,
+}
+
+/// Specifies which pointer buttons can be used to pan the scene by dragging.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct DragPanButtons(u8);
+
+bitflags::bitflags! {
+    impl DragPanButtons: u8 {
+        /// [PointerButton::Primary]
+        const PRIMARY = 1 << 0;
+
+        /// [PointerButton::Secondary]
+        const SECONDARY = 1 << 1;
+
+        /// [PointerButton::Middle]
+        const MIDDLE = 1 << 2;
+
+        /// [PointerButton::Extra1]
+        const EXTRA_1 = 1 << 3;
+
+        /// [PointerButton::Extra2]
+        const EXTRA_2 = 1 << 4;
+    }
 }
 
 impl Default for Scene {
     fn default() -> Self {
         Self {
             zoom_range: Rangef::new(f32::EPSILON, 1.0),
+            sense: Sense::click_and_drag(),
             max_inner_size: Vec2::splat(1000.0),
+            drag_pan_buttons: DragPanButtons::all(),
         }
     }
 }
@@ -62,6 +90,17 @@ impl Scene {
         Default::default()
     }
 
+    /// Specify what type of input the scene should respond to.
+    ///
+    /// The default is `Sense::click_and_drag()`.
+    ///
+    /// Set this to `Sense::hover()` to disable panning via clicking and dragging.
+    #[inline]
+    pub fn sense(mut self, sense: Sense) -> Self {
+        self.sense = sense;
+        self
+    }
+
     /// Set the allowed zoom range.
     ///
     /// The default zoom range is `0.0..=1.0`,
@@ -82,6 +121,15 @@ impl Scene {
         self
     }
 
+    /// Specify which pointer buttons can be used to pan by clicking and dragging.
+    ///
+    /// By default, this is `DragPanButtons::all()`.
+    #[inline]
+    pub fn drag_pan_buttons(mut self, flags: DragPanButtons) -> Self {
+        self.drag_pan_buttons = flags;
+        self
+    }
+
     /// `scene_rect` contains the view bounds of the inner [`Ui`].
     ///
     /// `scene_rect` will be mutated by any panning/zooming done by the user.
@@ -118,8 +166,10 @@ impl Scene {
         }
 
         if !scene_rect_was_good {
-            // Auto-reset if the trsnsformation goes bad somehow (or started bad).
-            *scene_rect = inner_rect;
+            // Auto-reset if the transformation goes bad somehow (or started bad).
+            // Recalculates transform based on inner_rect, resulting in a rect that's the full size of outer_rect but centered on inner_rect.
+            let to_global = fit_to_rect_in_scene(outer_rect, inner_rect, self.zoom_range);
+            *scene_rect = to_global.inverse() * outer_rect;
         }
 
         ret
@@ -147,7 +197,7 @@ impl Scene {
             UiBuilder::new()
                 .layer_id(scene_layer_id)
                 .max_rect(Rect::from_min_size(Pos2::ZERO, self.max_inner_size))
-                .sense(Sense::click_and_drag()),
+                .sense(self.sense),
         );
 
         let mut pan_response = local_ui.response();
@@ -158,17 +208,17 @@ impl Scene {
         // Set a correct global clip rect:
         local_ui.set_clip_rect(to_global.inverse() * outer_rect);
 
+        // Tell egui to apply the transform on the layer:
+        local_ui
+            .ctx()
+            .set_transform_layer(scene_layer_id, *to_global);
+
         // Add the actual contents to the area:
         let ret = add_contents(&mut local_ui);
 
         // This ensures we catch clicks/drags/pans anywhere on the background.
         local_ui.force_set_min_rect((to_global.inverse() * outer_rect).round_ui());
 
-        // Tell egui to apply the transform on the layer:
-        local_ui
-            .ctx()
-            .set_transform_layer(scene_layer_id, *to_global);
-
         InnerResponse {
             response: pan_response,
             inner: ret,
@@ -177,43 +227,51 @@ impl Scene {
 
     /// Helper function to handle pan and zoom interactions on a response.
     pub fn register_pan_and_zoom(&self, ui: &Ui, resp: &mut Response, to_global: &mut TSTransform) {
-        if resp.dragged() {
+        let dragged = self.drag_pan_buttons.iter().any(|button| match button {
+            DragPanButtons::PRIMARY => resp.dragged_by(PointerButton::Primary),
+            DragPanButtons::SECONDARY => resp.dragged_by(PointerButton::Secondary),
+            DragPanButtons::MIDDLE => resp.dragged_by(PointerButton::Middle),
+            DragPanButtons::EXTRA_1 => resp.dragged_by(PointerButton::Extra1),
+            DragPanButtons::EXTRA_2 => resp.dragged_by(PointerButton::Extra2),
+            _ => false,
+        });
+        if dragged {
             to_global.translation += to_global.scaling * resp.drag_delta();
             resp.mark_changed();
         }
 
-        if let Some(mouse_pos) = ui.input(|i| i.pointer.latest_pos()) {
-            if resp.contains_pointer() {
-                let pointer_in_scene = to_global.inverse() * mouse_pos;
-                let zoom_delta = ui.ctx().input(|i| i.zoom_delta());
-                let pan_delta = ui.ctx().input(|i| i.smooth_scroll_delta);
+        if let Some(mouse_pos) = ui.input(|i| i.pointer.latest_pos())
+            && resp.contains_pointer()
+        {
+            let pointer_in_scene = to_global.inverse() * mouse_pos;
+            let zoom_delta = ui.ctx().input(|i| i.zoom_delta());
+            let pan_delta = ui.ctx().input(|i| i.smooth_scroll_delta());
 
-                // Most of the time we can return early. This is also important to
-                // avoid `ui_from_scene` to change slightly due to floating point errors.
-                if zoom_delta == 1.0 && pan_delta == Vec2::ZERO {
-                    return;
-                }
-
-                if zoom_delta != 1.0 {
-                    // Zoom in on pointer, but only if we are not zoomed in or out too far.
-                    let zoom_delta = zoom_delta.clamp(
-                        self.zoom_range.min / to_global.scaling,
-                        self.zoom_range.max / to_global.scaling,
-                    );
-
-                    *to_global = *to_global
-                        * TSTransform::from_translation(pointer_in_scene.to_vec2())
-                        * TSTransform::from_scaling(zoom_delta)
-                        * TSTransform::from_translation(-pointer_in_scene.to_vec2());
-
-                    // Clamp to exact zoom range.
-                    to_global.scaling = self.zoom_range.clamp(to_global.scaling);
-                }
-
-                // Pan:
-                *to_global = TSTransform::from_translation(pan_delta) * *to_global;
-                resp.mark_changed();
+            // Most of the time we can return early. This is also important to
+            // avoid `ui_from_scene` to change slightly due to floating point errors.
+            if zoom_delta == 1.0 && pan_delta == Vec2::ZERO {
+                return;
             }
+
+            if zoom_delta != 1.0 {
+                // Zoom in on pointer, but only if we are not zoomed in or out too far.
+                let zoom_delta = zoom_delta.clamp(
+                    self.zoom_range.min / to_global.scaling,
+                    self.zoom_range.max / to_global.scaling,
+                );
+
+                *to_global = *to_global
+                    * TSTransform::from_translation(pointer_in_scene.to_vec2())
+                    * TSTransform::from_scaling(zoom_delta)
+                    * TSTransform::from_translation(-pointer_in_scene.to_vec2());
+
+                // Clamp to exact zoom range.
+                to_global.scaling = self.zoom_range.clamp(to_global.scaling);
+            }
+
+            // Pan:
+            *to_global = TSTransform::from_translation(pan_delta) * *to_global;
+            resp.mark_changed();
         }
     }
 }
diff --git a/crates/egui/src/containers/scroll_area.rs b/crates/egui/src/containers/scroll_area.rs
index 727a9da7b..4d952d315 100644
--- a/crates/egui/src/containers/scroll_area.rs
+++ b/crates/egui/src/containers/scroll_area.rs
@@ -1,8 +1,12 @@
 #![allow(clippy::needless_range_loop)]
 
+use std::ops::{Add, AddAssign, BitOr, BitOrAssign};
+
+use emath::GuiRounding as _;
+
 use crate::{
-    emath, epaint, lerp, pass_state, pos2, remap, remap_clamp, vec2, Context, Id, NumExt, Pos2,
-    Rangef, Rect, Sense, Ui, UiBuilder, UiKind, UiStackInfo, Vec2, Vec2b,
+    Context, CursorIcon, Id, NumExt as _, Pos2, Rangef, Rect, Response, Sense, Ui, UiBuilder,
+    UiKind, UiStackInfo, Vec2, Vec2b, emath, epaint, lerp, pass_state, pos2, remap, remap_clamp,
 };
 
 #[derive(Clone, Copy, Debug)]
@@ -133,6 +137,113 @@ impl ScrollBarVisibility {
     ];
 }
 
+/// What is the source of scrolling for a [`ScrollArea`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ScrollSource {
+    /// Scroll the area by dragging a scroll bar.
+    ///
+    /// By default the scroll bars remain visible to show current position.
+    /// To hide them use [`ScrollArea::scroll_bar_visibility()`].
+    pub scroll_bar: bool,
+
+    /// Scroll the area by dragging the contents.
+    pub drag: bool,
+
+    /// Scroll the area by scrolling (or shift scrolling) the mouse wheel with
+    /// the mouse cursor over the [`ScrollArea`].
+    pub mouse_wheel: bool,
+}
+
+impl Default for ScrollSource {
+    fn default() -> Self {
+        Self::ALL
+    }
+}
+
+impl ScrollSource {
+    pub const NONE: Self = Self {
+        scroll_bar: false,
+        drag: false,
+        mouse_wheel: false,
+    };
+    pub const ALL: Self = Self {
+        scroll_bar: true,
+        drag: true,
+        mouse_wheel: true,
+    };
+    pub const SCROLL_BAR: Self = Self {
+        scroll_bar: true,
+        drag: false,
+        mouse_wheel: false,
+    };
+    pub const DRAG: Self = Self {
+        scroll_bar: false,
+        drag: true,
+        mouse_wheel: false,
+    };
+    pub const MOUSE_WHEEL: Self = Self {
+        scroll_bar: false,
+        drag: false,
+        mouse_wheel: true,
+    };
+
+    /// Is everything disabled?
+    #[inline]
+    pub fn is_none(&self) -> bool {
+        self == &Self::NONE
+    }
+
+    /// Is anything enabled?
+    #[inline]
+    pub fn any(&self) -> bool {
+        self.scroll_bar | self.drag | self.mouse_wheel
+    }
+
+    /// Is everything enabled?
+    #[inline]
+    pub fn is_all(&self) -> bool {
+        self.scroll_bar & self.drag & self.mouse_wheel
+    }
+}
+
+impl BitOr for ScrollSource {
+    type Output = Self;
+
+    #[inline]
+    fn bitor(self, rhs: Self) -> Self::Output {
+        Self {
+            scroll_bar: self.scroll_bar | rhs.scroll_bar,
+            drag: self.drag | rhs.drag,
+            mouse_wheel: self.mouse_wheel | rhs.mouse_wheel,
+        }
+    }
+}
+
+#[expect(clippy::suspicious_arithmetic_impl)]
+impl Add for ScrollSource {
+    type Output = Self;
+
+    #[inline]
+    fn add(self, rhs: Self) -> Self::Output {
+        self | rhs
+    }
+}
+
+impl BitOrAssign for ScrollSource {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
+}
+
+impl AddAssign for ScrollSource {
+    #[inline]
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs;
+    }
+}
+
 /// Add vertical and/or horizontal scrolling to a contained [`Ui`].
 ///
 /// By default, scroll bars only show up when needed, i.e. when the contents
@@ -168,7 +279,7 @@ impl ScrollBarVisibility {
 #[must_use = "You should call .show()"]
 pub struct ScrollArea {
     /// Do we have horizontal/vertical scrolling enabled?
-    scroll_enabled: Vec2b,
+    direction_enabled: Vec2b,
 
     auto_shrink: Vec2b,
     max_size: Vec2,
@@ -178,10 +289,10 @@ pub struct ScrollArea {
     id_salt: Option<Id>,
     offset_x: Option<f32>,
     offset_y: Option<f32>,
-
-    /// If false, we ignore scroll events.
-    scrolling_enabled: bool,
-    drag_to_scroll: bool,
+    on_hover_cursor: Option<CursorIcon>,
+    on_drag_cursor: Option<CursorIcon>,
+    scroll_source: ScrollSource,
+    wheel_scroll_multiplier: Vec2,
 
     /// If true for vertical or horizontal the scroll wheel will stick to the
     /// end position until user manually changes position. It will become true
@@ -220,9 +331,9 @@ impl ScrollArea {
 
     /// Create a scroll area where you decide which axis has scrolling enabled.
     /// For instance, `ScrollArea::new([true, false])` enables horizontal scrolling.
-    pub fn new(scroll_enabled: impl Into<Vec2b>) -> Self {
+    pub fn new(direction_enabled: impl Into<Vec2b>) -> Self {
         Self {
-            scroll_enabled: scroll_enabled.into(),
+            direction_enabled: direction_enabled.into(),
             auto_shrink: Vec2b::TRUE,
             max_size: Vec2::INFINITY,
             min_scrolled_size: Vec2::splat(64.0),
@@ -231,8 +342,10 @@ impl ScrollArea {
             id_salt: None,
             offset_x: None,
             offset_y: None,
-            scrolling_enabled: true,
-            drag_to_scroll: true,
+            on_hover_cursor: None,
+            on_drag_cursor: None,
+            scroll_source: ScrollSource::default(),
+            wheel_scroll_multiplier: Vec2::splat(1.0),
             stick_to_end: Vec2b::FALSE,
             animated: true,
         }
@@ -355,17 +468,41 @@ impl ScrollArea {
         self
     }
 
+    /// Set the cursor used when the mouse pointer is hovering over the [`ScrollArea`].
+    ///
+    /// Only applies if [`Self::scroll_source()`] has set [`ScrollSource::drag`] to `true`.
+    ///
+    /// Any changes to the mouse cursor made within the contents of the [`ScrollArea`] will
+    /// override this setting.
+    #[inline]
+    pub fn on_hover_cursor(mut self, cursor: CursorIcon) -> Self {
+        self.on_hover_cursor = Some(cursor);
+        self
+    }
+
+    /// Set the cursor used when the [`ScrollArea`] is being dragged.
+    ///
+    /// Only applies if [`Self::scroll_source()`] has set [`ScrollSource::drag`] to `true`.
+    ///
+    /// Any changes to the mouse cursor made within the contents of the [`ScrollArea`] will
+    /// override this setting.
+    #[inline]
+    pub fn on_drag_cursor(mut self, cursor: CursorIcon) -> Self {
+        self.on_drag_cursor = Some(cursor);
+        self
+    }
+
     /// Turn on/off scrolling on the horizontal axis.
     #[inline]
     pub fn hscroll(mut self, hscroll: bool) -> Self {
-        self.scroll_enabled[0] = hscroll;
+        self.direction_enabled[0] = hscroll;
         self
     }
 
     /// Turn on/off scrolling on the vertical axis.
     #[inline]
     pub fn vscroll(mut self, vscroll: bool) -> Self {
-        self.scroll_enabled[1] = vscroll;
+        self.direction_enabled[1] = vscroll;
         self
     }
 
@@ -373,16 +510,8 @@ impl ScrollArea {
     ///
     /// You can pass in `false`, `true`, `[false, true]` etc.
     #[inline]
-    pub fn scroll(mut self, scroll_enabled: impl Into<Vec2b>) -> Self {
-        self.scroll_enabled = scroll_enabled.into();
-        self
-    }
-
-    /// Turn on/off scrolling on the horizontal/vertical axes.
-    #[deprecated = "Renamed to `scroll`"]
-    #[inline]
-    pub fn scroll2(mut self, scroll_enabled: impl Into<Vec2b>) -> Self {
-        self.scroll_enabled = scroll_enabled.into();
+    pub fn scroll(mut self, direction_enabled: impl Into<Vec2b>) -> Self {
+        self.direction_enabled = direction_enabled.into();
         self
     }
 
@@ -395,9 +524,14 @@ impl ScrollArea {
     /// is typing text in a [`crate::TextEdit`] widget contained within the scroll area.
     ///
     /// This controls both scrolling directions.
+    #[deprecated = "Use `ScrollArea::scroll_source()"]
     #[inline]
     pub fn enable_scrolling(mut self, enable: bool) -> Self {
-        self.scrolling_enabled = enable;
+        self.scroll_source = if enable {
+            ScrollSource::ALL
+        } else {
+            ScrollSource::NONE
+        };
         self
     }
 
@@ -408,9 +542,28 @@ impl ScrollArea {
     /// If `true`, the [`ScrollArea`] will sense drags.
     ///
     /// Default: `true`.
+    #[deprecated = "Use `ScrollArea::scroll_source()"]
     #[inline]
     pub fn drag_to_scroll(mut self, drag_to_scroll: bool) -> Self {
-        self.drag_to_scroll = drag_to_scroll;
+        self.scroll_source.drag = drag_to_scroll;
+        self
+    }
+
+    /// What sources does the [`ScrollArea`] use for scrolling the contents.
+    #[inline]
+    pub fn scroll_source(mut self, scroll_source: ScrollSource) -> Self {
+        self.scroll_source = scroll_source;
+        self
+    }
+
+    /// The scroll amount caused by a mouse wheel scroll is multiplied by this amount.
+    ///
+    /// Independent for each scroll direction. Defaults to `Vec2{x: 1.0, y: 1.0}`.
+    ///
+    /// This can invert or effectively disable mouse scrolling.
+    #[inline]
+    pub fn wheel_scroll_multiplier(mut self, multiplier: Vec2) -> Self {
+        self.wheel_scroll_multiplier = multiplier;
         self
     }
 
@@ -437,7 +590,7 @@ impl ScrollArea {
 
     /// Is any scrolling enabled?
     pub(crate) fn is_any_scroll_enabled(&self) -> bool {
-        self.scroll_enabled[0] || self.scroll_enabled[1]
+        self.direction_enabled[0] || self.direction_enabled[1]
     }
 
     /// The scroll handle will stick to the rightmost position even while the content size
@@ -472,7 +625,7 @@ struct Prepared {
     auto_shrink: Vec2b,
 
     /// Does this `ScrollArea` have horizontal/vertical scrolling enabled?
-    scroll_enabled: Vec2b,
+    direction_enabled: Vec2b,
 
     /// Smoothly interpolated boolean of whether or not to show the scroll bars.
     show_bars_factor: Vec2,
@@ -500,20 +653,24 @@ struct Prepared {
     /// `viewport.min == ZERO` means we scrolled to the top.
     viewport: Rect,
 
-    scrolling_enabled: bool,
+    scroll_source: ScrollSource,
+    wheel_scroll_multiplier: Vec2,
     stick_to_end: Vec2b,
 
     /// If there was a scroll target before the [`ScrollArea`] was added this frame, it's
     /// not for us to handle so we save it and restore it after this [`ScrollArea`] is done.
     saved_scroll_target: [Option<pass_state::ScrollTarget>; 2],
 
+    /// The response from dragging the background (if enabled)
+    background_drag_response: Option<Response>,
+
     animated: bool,
 }
 
 impl ScrollArea {
     fn begin(self, ui: &mut Ui) -> Prepared {
         let Self {
-            scroll_enabled,
+            direction_enabled,
             auto_shrink,
             max_size,
             min_scrolled_size,
@@ -522,14 +679,15 @@ impl ScrollArea {
             id_salt,
             offset_x,
             offset_y,
-            scrolling_enabled,
-            drag_to_scroll,
+            on_hover_cursor,
+            on_drag_cursor,
+            scroll_source,
+            wheel_scroll_multiplier,
             stick_to_end,
             animated,
         } = self;
 
         let ctx = ui.ctx().clone();
-        let scrolling_enabled = scrolling_enabled && ui.is_enabled();
 
         let id_salt = id_salt.unwrap_or_else(|| Id::new("scroll_area"));
         let id = ui.make_persistent_id(id_salt);
@@ -546,7 +704,7 @@ impl ScrollArea {
         let show_bars: Vec2b = match scroll_bar_visibility {
             ScrollBarVisibility::AlwaysHidden => Vec2b::FALSE,
             ScrollBarVisibility::VisibleWhenNeeded => state.show_scroll,
-            ScrollBarVisibility::AlwaysVisible => scroll_enabled,
+            ScrollBarVisibility::AlwaysVisible => direction_enabled,
         };
 
         let show_bars_factor = Vec2::new(
@@ -568,7 +726,7 @@ impl ScrollArea {
             // one shouldn't collapse into nothingness.
             // See https://github.com/emilk/egui/issues/1097
             for d in 0..2 {
-                if scroll_enabled[d] {
+                if direction_enabled[d] {
                     inner_size[d] = inner_size[d].max(min_scrolled_size[d]);
                 }
             }
@@ -585,13 +743,19 @@ impl ScrollArea {
         } else {
             // Tell the inner Ui to use as much space as possible, we can scroll to see it!
             for d in 0..2 {
-                if scroll_enabled[d] {
+                if direction_enabled[d] {
                     content_max_size[d] = f32::INFINITY;
                 }
             }
         }
 
         let content_max_rect = Rect::from_min_size(inner_rect.min - state.offset, content_max_size);
+
+        // Round to pixels to avoid widgets appearing to "float" when scrolling fractional amounts:
+        let content_max_rect = content_max_rect
+            .round_to_pixels(ui.pixels_per_point())
+            .round_ui();
+
         let mut content_ui = ui.new_child(
             UiBuilder::new()
                 .ui_stack_info(UiStackInfo::new(UiKind::ScrollArea))
@@ -603,7 +767,7 @@ impl ScrollArea {
             let clip_rect_margin = ui.visuals().clip_rect_margin;
             let mut content_clip_rect = ui.clip_rect();
             for d in 0..2 {
-                if scroll_enabled[d] {
+                if direction_enabled[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;
                 } else {
@@ -619,56 +783,72 @@ impl ScrollArea {
         let viewport = Rect::from_min_size(Pos2::ZERO + state.offset, inner_size);
         let dt = ui.input(|i| i.stable_dt).at_most(0.1);
 
-        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_option = state
-                .interact_rect
-                .map(|rect| ui.interact(rect, id.with("area"), Sense::drag()));
+        let background_drag_response =
+            if scroll_source.drag && ui.is_enabled() && state.content_is_too_large.any() {
+                // 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_option = state
+                    .interact_rect
+                    .map(|rect| ui.interact(rect, id.with("area"), Sense::drag()));
 
-            if content_response_option
-                .as_ref()
-                .is_some_and(|response| response.dragged())
-            {
-                for d in 0..2 {
-                    if scroll_enabled[d] {
-                        ui.input(|input| {
-                            state.offset[d] -= input.pointer.delta()[d];
-                        });
-                        state.scroll_stuck_to_end[d] = false;
-                        state.offset_target[d] = None;
-                    }
-                }
-            } else {
-                // Apply the cursor velocity to the scroll area when the user releases the drag.
                 if content_response_option
                     .as_ref()
-                    .is_some_and(|response| response.drag_stopped())
+                    .is_some_and(|response| response.dragged())
                 {
-                    state.vel =
-                        scroll_enabled.to_vec2() * ui.input(|input| input.pointer.velocity());
-                }
-                for d in 0..2 {
-                    // Kinetic scrolling
-                    let stop_speed = 20.0; // Pixels per second.
-                    let friction_coeff = 1000.0; // Pixels per second squared.
+                    for d in 0..2 {
+                        if direction_enabled[d] {
+                            ui.input(|input| {
+                                state.offset[d] -= input.pointer.delta()[d];
+                            });
+                            state.scroll_stuck_to_end[d] = false;
+                            state.offset_target[d] = None;
+                        }
+                    }
+                } else {
+                    // Apply the cursor velocity to the scroll area when the user releases the drag.
+                    if content_response_option
+                        .as_ref()
+                        .is_some_and(|response| response.drag_stopped())
+                    {
+                        state.vel = direction_enabled.to_vec2()
+                            * ui.input(|input| input.pointer.velocity());
+                    }
+                    for d in 0..2 {
+                        // Kinetic scrolling
+                        let stop_speed = 20.0; // Pixels per second.
+                        let friction_coeff = 1000.0; // Pixels per second squared.
 
-                    let friction = friction_coeff * dt;
-                    if friction > state.vel[d].abs() || state.vel[d].abs() < stop_speed {
-                        state.vel[d] = 0.0;
-                    } else {
-                        state.vel[d] -= friction * state.vel[d].signum();
-                        // Offset has an inverted coordinate system compared to
-                        // the velocity, so we subtract it instead of adding it
-                        state.offset[d] -= state.vel[d] * dt;
-                        ctx.request_repaint();
+                        let friction = friction_coeff * dt;
+                        if friction > state.vel[d].abs() || state.vel[d].abs() < stop_speed {
+                            state.vel[d] = 0.0;
+                        } else {
+                            state.vel[d] -= friction * state.vel[d].signum();
+                            // Offset has an inverted coordinate system compared to
+                            // the velocity, so we subtract it instead of adding it
+                            state.offset[d] -= state.vel[d] * dt;
+                            ctx.request_repaint();
+                        }
                     }
                 }
-            }
-        }
+
+                // Set the desired mouse cursors.
+                if let Some(response) = &content_response_option {
+                    if response.dragged()
+                        && let Some(cursor) = on_drag_cursor
+                    {
+                        ui.ctx().set_cursor_icon(cursor);
+                    } else if response.hovered()
+                        && let Some(cursor) = on_hover_cursor
+                    {
+                        ui.ctx().set_cursor_icon(cursor);
+                    }
+                }
+
+                content_response_option
+            } else {
+                None
+            };
 
         // Scroll with an animation if we have a target offset (that hasn't been cleared by the code
         // above).
@@ -709,7 +889,7 @@ impl ScrollArea {
             id,
             state,
             auto_shrink,
-            scroll_enabled,
+            direction_enabled,
             show_bars_factor,
             current_bar_use,
             scroll_bar_visibility,
@@ -717,9 +897,11 @@ impl ScrollArea {
             inner_rect,
             content_ui,
             viewport,
-            scrolling_enabled,
+            scroll_source,
+            wheel_scroll_multiplier,
             stick_to_end,
             saved_scroll_target,
+            background_drag_response,
             animated,
         }
     }
@@ -776,7 +958,7 @@ impl ScrollArea {
 
             let rect = Rect::from_x_y_ranges(ui.max_rect().x_range(), y_min..=y_max);
 
-            ui.allocate_new_ui(UiBuilder::new().max_rect(rect), |viewport_ui| {
+            ui.scope_builder(UiBuilder::new().max_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)
             })
@@ -824,16 +1006,18 @@ impl Prepared {
             mut state,
             inner_rect,
             auto_shrink,
-            scroll_enabled,
+            direction_enabled,
             mut show_bars_factor,
             current_bar_use,
             scroll_bar_visibility,
             scroll_bar_rect,
             content_ui,
             viewport: _,
-            scrolling_enabled,
+            scroll_source,
+            wheel_scroll_multiplier,
             stick_to_end,
             saved_scroll_target,
+            background_drag_response,
             animated,
         } = self;
 
@@ -854,7 +1038,7 @@ impl Prepared {
                 .ctx()
                 .pass_state_mut(|state| state.scroll_target[d].take());
 
-            if scroll_enabled[d] {
+            if direction_enabled[d] {
                 if let Some(target) = scroll_target {
                     let pass_state::ScrollTarget {
                         range,
@@ -890,7 +1074,7 @@ impl Prepared {
 
                     delta += delta_update;
                     animation = animation_update;
-                };
+                }
 
                 if delta != 0.0 {
                     let target_offset = state.offset[d] + delta;
@@ -921,7 +1105,7 @@ impl Prepared {
             for d in 0..2 {
                 if saved_scroll_target[d].is_some() {
                     state.scroll_target[d] = saved_scroll_target[d].clone();
-                };
+                }
             }
         });
 
@@ -930,7 +1114,7 @@ impl Prepared {
             let mut inner_size = inner_rect.size();
 
             for d in 0..2 {
-                inner_size[d] = match (scroll_enabled[d], auto_shrink[d]) {
+                inner_size[d] = match (direction_enabled[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).
@@ -944,25 +1128,35 @@ impl Prepared {
         let outer_rect = Rect::from_min_size(inner_rect.min, inner_rect.size() + current_bar_use);
 
         let content_is_too_large = Vec2b::new(
-            scroll_enabled[0] && inner_rect.width() < content_size.x,
-            scroll_enabled[1] && inner_rect.height() < content_size.y,
+            direction_enabled[0] && inner_rect.width() < content_size.x,
+            direction_enabled[1] && inner_rect.height() < content_size.y,
         );
 
         let max_offset = content_size - inner_rect.size();
-        let is_hovering_outer_rect = ui.rect_contains_pointer(outer_rect);
-        if scrolling_enabled && is_hovering_outer_rect {
+
+        // Drag-to-scroll?
+        let is_dragging_background = background_drag_response
+            .as_ref()
+            .is_some_and(|r| r.dragged());
+
+        let is_hovering_outer_rect = ui.rect_contains_pointer(outer_rect)
+            && ui.ctx().dragged_id().is_none()
+            || is_dragging_background;
+
+        if scroll_source.mouse_wheel && ui.is_enabled() && is_hovering_outer_rect {
             let always_scroll_enabled_direction = ui.style().always_scroll_the_only_direction
-                && scroll_enabled[0] != scroll_enabled[1];
+                && direction_enabled[0] != direction_enabled[1];
             for d in 0..2 {
-                if scroll_enabled[d] {
-                    let scroll_delta = ui.ctx().input_mut(|input| {
+                if direction_enabled[d] {
+                    let scroll_delta = ui.ctx().input(|input| {
                         if always_scroll_enabled_direction {
                             // no bidirectional scrolling; allow horizontal scrolling without pressing shift
-                            input.smooth_scroll_delta[0] + input.smooth_scroll_delta[1]
+                            input.smooth_scroll_delta()[0] + input.smooth_scroll_delta()[1]
                         } else {
-                            input.smooth_scroll_delta[d]
+                            input.smooth_scroll_delta()[d]
                         }
                     });
+                    let scroll_delta = scroll_delta * wheel_scroll_multiplier[d];
 
                     let scrolling_up = state.offset[d] > 0.0 && scroll_delta > 0.0;
                     let scrolling_down = state.offset[d] < max_offset[d] && scroll_delta < 0.0;
@@ -973,10 +1167,10 @@ impl Prepared {
                         // Clear scroll delta so no parent scroll will use it:
                         ui.ctx().input_mut(|input| {
                             if always_scroll_enabled_direction {
-                                input.smooth_scroll_delta[0] = 0.0;
-                                input.smooth_scroll_delta[1] = 0.0;
+                                input.smooth_scroll_delta()[0] = 0.0;
+                                input.smooth_scroll_delta()[1] = 0.0;
                             } else {
-                                input.smooth_scroll_delta[d] = 0.0;
+                                input.smooth_scroll_delta()[d] = 0.0;
                             }
                         });
 
@@ -990,7 +1184,7 @@ impl Prepared {
         let show_scroll_this_frame = match scroll_bar_visibility {
             ScrollBarVisibility::AlwaysHidden => Vec2b::FALSE,
             ScrollBarVisibility::VisibleWhenNeeded => content_is_too_large,
-            ScrollBarVisibility::AlwaysVisible => scroll_enabled,
+            ScrollBarVisibility::AlwaysVisible => direction_enabled,
         };
 
         // Avoid frame delay; start showing scroll bar right away:
@@ -1034,6 +1228,7 @@ impl Prepared {
 
                 let is_hovering_bar_area = is_hovering_outer_rect
                     && ui.rect_contains_pointer(max_bar_rect)
+                    && !is_dragging_background
                     || state.scroll_bar_interaction[d];
 
                 let is_hovering_bar_area_t = ui
@@ -1090,23 +1285,37 @@ impl Prepared {
                 )
             };
 
-            let handle_rect = if d == 0 {
-                Rect::from_min_max(
-                    pos2(from_content(state.offset.x), cross.min),
-                    pos2(from_content(state.offset.x + inner_rect.width()), cross.max),
-                )
-            } else {
-                Rect::from_min_max(
-                    pos2(cross.min, from_content(state.offset.y)),
-                    pos2(
-                        cross.max,
-                        from_content(state.offset.y + inner_rect.height()),
-                    ),
-                )
+            let calculate_handle_rect = |d, offset: &Vec2| {
+                let handle_size = if d == 0 {
+                    from_content(offset.x + inner_rect.width()) - from_content(offset.x)
+                } else {
+                    from_content(offset.y + inner_rect.height()) - from_content(offset.y)
+                }
+                .max(scroll_style.handle_min_length);
+
+                let handle_start_point = remap_clamp(
+                    offset[d],
+                    0.0..=max_offset[d],
+                    scroll_bar_rect.min[d]..=(scroll_bar_rect.max[d] - handle_size),
+                );
+
+                if d == 0 {
+                    Rect::from_min_max(
+                        pos2(handle_start_point, cross.min),
+                        pos2(handle_start_point + handle_size, cross.max),
+                    )
+                } else {
+                    Rect::from_min_max(
+                        pos2(cross.min, handle_start_point),
+                        pos2(cross.max, handle_start_point + handle_size),
+                    )
+                }
             };
 
+            let handle_rect = calculate_handle_rect(d, &state.offset);
+
             let interact_id = id.with(d);
-            let sense = if self.scrolling_enabled {
+            let sense = if scroll_source.scroll_bar && ui.is_enabled() {
                 Sense::click_and_drag()
             } else {
                 Sense::hover()
@@ -1131,11 +1340,13 @@ impl Prepared {
                     });
 
                 let new_handle_top = pointer_pos[d] - *scroll_start_offset_from_top_left;
-                state.offset[d] = remap(
-                    new_handle_top,
-                    scroll_bar_rect.min[d]..=scroll_bar_rect.max[d],
-                    0.0..=content_size[d],
-                );
+                let handle_travel =
+                    scroll_bar_rect.min[d]..=(scroll_bar_rect.max[d] - handle_rect.size()[d]);
+                state.offset[d] = if handle_travel.start() == handle_travel.end() {
+                    0.0
+                } else {
+                    remap(new_handle_top, handle_travel, 0.0..=max_offset[d])
+                };
 
                 // some manual action taken, scroll not stuck
                 state.scroll_stuck_to_end[d] = false;
@@ -1154,33 +1365,9 @@ impl Prepared {
 
             if ui.is_rect_visible(outer_scroll_bar_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), cross.min),
-                        pos2(from_content(state.offset.x + inner_rect.width()), cross.max),
-                    )
-                } else {
-                    Rect::from_min_max(
-                        pos2(cross.min, from_content(state.offset.y)),
-                        pos2(
-                            cross.max,
-                            from_content(state.offset.y + inner_rect.height()),
-                        ),
-                    )
-                };
-                let min_handle_size = scroll_style.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 handle_rect = calculate_handle_rect(d, &state.offset);
 
-                let visuals = if scrolling_enabled {
+                let visuals = if scroll_source.scroll_bar && ui.is_enabled() {
                     // Pick visuals based on interaction with the handle.
                     // Remember that the response is for the whole scroll bar!
                     let is_hovering_handle = response.hovered()
diff --git a/crates/egui/src/containers/sides.rs b/crates/egui/src/containers/sides.rs
index e34ae70eb..709c1b645 100644
--- a/crates/egui/src/containers/sides.rs
+++ b/crates/egui/src/containers/sides.rs
@@ -1,4 +1,4 @@
-use emath::Align;
+use emath::{Align, NumExt as _};
 
 use crate::{Layout, Ui, UiBuilder};
 
@@ -20,8 +20,13 @@ use crate::{Layout, Ui, UiBuilder};
 ///
 /// If the parent is not wide enough to fit all widgets, the parent will be expanded to the right.
 ///
-/// The left widgets are first added to the ui, left-to-right.
-/// Then the right widgets are added, right-to-left.
+/// The left widgets are added left-to-right.
+/// The right widgets are added right-to-left.
+///
+/// Which side is first depends on the configuration:
+///  - [`Sides::extend`] - left widgets are added first
+///  - [`Sides::shrink_left`] - right widgets are added first
+///  - [`Sides::shrink_right`] - left widgets are added first
 ///
 /// ```
 /// # egui::__run_test_ui(|ui| {
@@ -40,6 +45,16 @@ use crate::{Layout, Ui, UiBuilder};
 pub struct Sides {
     height: Option<f32>,
     spacing: Option<f32>,
+    kind: SidesKind,
+    wrap_mode: Option<crate::TextWrapMode>,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+enum SidesKind {
+    #[default]
+    Extend,
+    ShrinkLeft,
+    ShrinkRight,
 }
 
 impl Sides {
@@ -68,58 +83,175 @@ impl Sides {
         self
     }
 
+    /// Try to shrink widgets on the left side.
+    ///
+    /// Right widgets will be added first. The left [`Ui`]s max rect will be limited to the
+    /// remaining space.
+    #[inline]
+    pub fn shrink_left(mut self) -> Self {
+        self.kind = SidesKind::ShrinkLeft;
+        self
+    }
+
+    /// Try to shrink widgets on the right side.
+    ///
+    /// Left widgets will be added first. The right [`Ui`]s max rect will be limited to the
+    /// remaining space.
+    #[inline]
+    pub fn shrink_right(mut self) -> Self {
+        self.kind = SidesKind::ShrinkRight;
+        self
+    }
+
+    /// Extend the left and right sides to fill the available space.
+    ///
+    /// This is the default behavior.
+    /// The left widgets will be added first, followed by the right widgets.
+    #[inline]
+    pub fn extend(mut self) -> Self {
+        self.kind = SidesKind::Extend;
+        self
+    }
+
+    /// The text wrap mode for the shrinking side.
+    ///
+    /// Does nothing if [`Self::extend`] is used (the default).
+    #[inline]
+    pub fn wrap_mode(mut self, wrap_mode: crate::TextWrapMode) -> Self {
+        self.wrap_mode = Some(wrap_mode);
+        self
+    }
+
+    /// Truncate the text on the shrinking side.
+    ///
+    /// This is a shortcut for [`Self::wrap_mode`].
+    /// Does nothing if [`Self::extend`] is used (the default).
+    #[inline]
+    pub fn truncate(mut self) -> Self {
+        self.wrap_mode = Some(crate::TextWrapMode::Truncate);
+        self
+    }
+
+    /// Wrap the text on the shrinking side.
+    ///
+    /// This is a shortcut for [`Self::wrap_mode`].
+    /// Does nothing if [`Self::extend`] is used (the default).
+    #[inline]
+    pub fn wrap(mut self) -> Self {
+        self.wrap_mode = Some(crate::TextWrapMode::Wrap);
+        self
+    }
+
     pub fn show<RetL, RetR>(
         self,
         ui: &mut Ui,
         add_left: impl FnOnce(&mut Ui) -> RetL,
         add_right: impl FnOnce(&mut Ui) -> RetR,
     ) -> (RetL, RetR) {
-        let Self { height, spacing } = self;
+        let Self {
+            height,
+            spacing,
+            mut kind,
+            mut wrap_mode,
+        } = self;
         let height = height.unwrap_or_else(|| ui.spacing().interact_size.y);
         let spacing = spacing.unwrap_or_else(|| ui.spacing().item_spacing.x);
 
         let mut top_rect = ui.available_rect_before_wrap();
         top_rect.max.y = top_rect.min.y + height;
 
-        let result_left;
-        let result_right;
-
-        let left_rect = {
-            let left_max_rect = top_rect;
-            let mut left_ui = ui.new_child(
-                UiBuilder::new()
-                    .max_rect(left_max_rect)
-                    .layout(Layout::left_to_right(Align::Center)),
-            );
-            result_left = add_left(&mut left_ui);
-            left_ui.min_rect()
-        };
-
-        let right_rect = {
-            let right_max_rect = top_rect.with_min_x(left_rect.max.x);
-            let mut right_ui = ui.new_child(
-                UiBuilder::new()
-                    .max_rect(right_max_rect)
-                    .layout(Layout::right_to_left(Align::Center)),
-            );
-            result_right = add_right(&mut right_ui);
-            right_ui.min_rect()
-        };
-
-        let mut final_rect = left_rect.union(right_rect);
-        let min_width = left_rect.width() + spacing + right_rect.width();
-
         if ui.is_sizing_pass() {
-            // Make as small as possible:
-            final_rect.max.x = left_rect.min.x + min_width;
-        } else {
-            // If the rects overlap, make sure we expand the allocated rect so that the parent
-            // ui knows we overflowed, and resizes:
-            final_rect.max.x = final_rect.max.x.max(left_rect.min.x + min_width);
+            kind = SidesKind::Extend;
+            wrap_mode = None;
         }
 
-        ui.advance_cursor_after_rect(final_rect);
+        match kind {
+            SidesKind::ShrinkLeft => {
+                let (right_rect, result_right) = Self::create_ui(
+                    ui,
+                    top_rect,
+                    Layout::right_to_left(Align::Center),
+                    add_right,
+                    None,
+                );
+                let available_width = top_rect.width() - right_rect.width() - spacing;
+                let left_rect_constraint =
+                    top_rect.with_max_x(top_rect.min.x + available_width.at_least(0.0));
+                let (left_rect, result_left) = Self::create_ui(
+                    ui,
+                    left_rect_constraint,
+                    Layout::left_to_right(Align::Center),
+                    add_left,
+                    wrap_mode,
+                );
 
-        (result_left, result_right)
+                ui.advance_cursor_after_rect(left_rect | right_rect);
+                (result_left, result_right)
+            }
+            SidesKind::ShrinkRight => {
+                let (left_rect, result_left) = Self::create_ui(
+                    ui,
+                    top_rect,
+                    Layout::left_to_right(Align::Center),
+                    add_left,
+                    None,
+                );
+                let right_rect_constraint = top_rect.with_min_x(left_rect.max.x + spacing);
+                let (right_rect, result_right) = Self::create_ui(
+                    ui,
+                    right_rect_constraint,
+                    Layout::right_to_left(Align::Center),
+                    add_right,
+                    wrap_mode,
+                );
+
+                ui.advance_cursor_after_rect(left_rect | right_rect);
+                (result_left, result_right)
+            }
+            SidesKind::Extend => {
+                let (left_rect, result_left) = Self::create_ui(
+                    ui,
+                    top_rect,
+                    Layout::left_to_right(Align::Center),
+                    add_left,
+                    None,
+                );
+                let right_max_rect = top_rect.with_min_x(left_rect.max.x);
+                let (right_rect, result_right) = Self::create_ui(
+                    ui,
+                    right_max_rect,
+                    Layout::right_to_left(Align::Center),
+                    add_right,
+                    None,
+                );
+
+                let mut final_rect = left_rect | right_rect;
+                let min_width = left_rect.width() + spacing + right_rect.width();
+
+                if ui.is_sizing_pass() {
+                    final_rect.max.x = left_rect.min.x + min_width;
+                } else {
+                    final_rect.max.x = final_rect.max.x.max(left_rect.min.x + min_width);
+                }
+
+                ui.advance_cursor_after_rect(final_rect);
+                (result_left, result_right)
+            }
+        }
+    }
+
+    fn create_ui<Ret>(
+        ui: &mut Ui,
+        max_rect: emath::Rect,
+        layout: Layout,
+        add_content: impl FnOnce(&mut Ui) -> Ret,
+        wrap_mode: Option<crate::TextWrapMode>,
+    ) -> (emath::Rect, Ret) {
+        let mut child_ui = ui.new_child(UiBuilder::new().max_rect(max_rect).layout(layout));
+        if let Some(wrap_mode) = wrap_mode {
+            child_ui.style_mut().wrap_mode = Some(wrap_mode);
+        }
+        let result = add_content(&mut child_ui);
+        (child_ui.min_rect(), result)
     }
 }
diff --git a/crates/egui/src/containers/tooltip.rs b/crates/egui/src/containers/tooltip.rs
new file mode 100644
index 000000000..c46e21d57
--- /dev/null
+++ b/crates/egui/src/containers/tooltip.rs
@@ -0,0 +1,403 @@
+use crate::pass_state::PerWidgetTooltipState;
+use crate::{
+    AreaState, Context, Id, InnerResponse, LayerId, Layout, Order, Popup, PopupAnchor, PopupKind,
+    Response, Sense,
+};
+use emath::Vec2;
+
+pub struct Tooltip<'a> {
+    pub popup: Popup<'a>,
+
+    /// The layer of the parent widget.
+    parent_layer: LayerId,
+
+    /// The id of the widget that owns this tooltip.
+    parent_widget: Id,
+}
+
+impl Tooltip<'_> {
+    /// Show a tooltip that is always open.
+    #[deprecated = "Use `Tooltip::always_open` instead."]
+    pub fn new(
+        parent_widget: Id,
+        ctx: Context,
+        anchor: impl Into<PopupAnchor>,
+        parent_layer: LayerId,
+    ) -> Self {
+        Self {
+            popup: Popup::new(parent_widget, ctx, anchor.into(), parent_layer)
+                .kind(PopupKind::Tooltip)
+                .gap(4.0)
+                .sense(Sense::hover()),
+            parent_layer,
+            parent_widget,
+        }
+    }
+
+    /// Show a tooltip that is always open.
+    pub fn always_open(
+        ctx: Context,
+        parent_layer: LayerId,
+        parent_widget: Id,
+        anchor: impl Into<PopupAnchor>,
+    ) -> Self {
+        let width = ctx.style().spacing.tooltip_width;
+        Self {
+            popup: Popup::new(parent_widget, ctx, anchor.into(), parent_layer)
+                .kind(PopupKind::Tooltip)
+                .gap(4.0)
+                .width(width)
+                .sense(Sense::hover()),
+            parent_layer,
+            parent_widget,
+        }
+    }
+
+    /// Show a tooltip for a widget. Always open (as long as this function is called).
+    pub fn for_widget(response: &Response) -> Self {
+        let popup = Popup::from_response(response)
+            .kind(PopupKind::Tooltip)
+            .gap(4.0)
+            .width(response.ctx.style().spacing.tooltip_width)
+            .sense(Sense::hover());
+        Self {
+            popup,
+            parent_layer: response.layer_id,
+            parent_widget: response.id,
+        }
+    }
+
+    /// Show a tooltip when hovering an enabled widget.
+    pub fn for_enabled(response: &Response) -> Self {
+        let mut tooltip = Self::for_widget(response);
+        tooltip.popup = tooltip
+            .popup
+            .open(response.enabled() && Self::should_show_tooltip(response, true));
+        tooltip
+    }
+
+    /// Show a tooltip when hovering a disabled widget.
+    pub fn for_disabled(response: &Response) -> Self {
+        let mut tooltip = Self::for_widget(response);
+        tooltip.popup = tooltip
+            .popup
+            .open(!response.enabled() && Self::should_show_tooltip(response, true));
+        tooltip
+    }
+
+    /// Show the tooltip at the pointer position.
+    #[inline]
+    pub fn at_pointer(mut self) -> Self {
+        self.popup = self.popup.at_pointer();
+        self
+    }
+
+    /// Set the gap between the tooltip and the anchor
+    ///
+    /// Default: 5.0
+    #[inline]
+    pub fn gap(mut self, gap: f32) -> Self {
+        self.popup = self.popup.gap(gap);
+        self
+    }
+
+    /// Set the layout of the tooltip
+    #[inline]
+    pub fn layout(mut self, layout: Layout) -> Self {
+        self.popup = self.popup.layout(layout);
+        self
+    }
+
+    /// Set the width of the tooltip
+    #[inline]
+    pub fn width(mut self, width: f32) -> Self {
+        self.popup = self.popup.width(width);
+        self
+    }
+
+    /// Show the tooltip
+    pub fn show<R>(self, content: impl FnOnce(&mut crate::Ui) -> R) -> Option<InnerResponse<R>> {
+        let Self {
+            mut popup,
+            parent_layer,
+            parent_widget,
+        } = self;
+
+        if !popup.is_open() {
+            return None;
+        }
+
+        let rect = popup.get_anchor_rect()?;
+
+        let mut state = popup.ctx().pass_state_mut(|fs| {
+            // Remember that this is the widget showing the tooltip:
+            fs.layers
+                .entry(parent_layer)
+                .or_default()
+                .widget_with_tooltip = Some(parent_widget);
+
+            fs.tooltips
+                .widget_tooltips
+                .get(&parent_widget)
+                .copied()
+                .unwrap_or(PerWidgetTooltipState {
+                    bounding_rect: rect,
+                    tooltip_count: 0,
+                })
+        });
+
+        let tooltip_area_id = Self::tooltip_id(parent_widget, state.tooltip_count);
+        popup = popup.anchor(state.bounding_rect).id(tooltip_area_id);
+
+        let response = popup.show(|ui| {
+            // By default, the text in tooltips aren't selectable.
+            // This means that most tooltips aren't interactable,
+            // which also mean they won't stick around so you can click them.
+            // Only tooltips that have actual interactive stuff (buttons, links, …)
+            // will stick around when you try to click them.
+            ui.style_mut().interaction.selectable_labels = false;
+
+            content(ui)
+        });
+
+        // The popup might not be shown on at_pointer if there is no pointer.
+        if let Some(response) = &response {
+            state.tooltip_count += 1;
+            state.bounding_rect |= response.response.rect;
+            response
+                .response
+                .ctx
+                .pass_state_mut(|fs| fs.tooltips.widget_tooltips.insert(parent_widget, state));
+            Self::remember_that_tooltip_was_shown(&response.response.ctx);
+        }
+
+        response
+    }
+
+    fn when_was_a_toolip_last_shown_id() -> Id {
+        Id::new("when_was_a_toolip_last_shown")
+    }
+
+    pub fn seconds_since_last_tooltip(ctx: &Context) -> f32 {
+        let when_was_a_toolip_last_shown =
+            ctx.data(|d| d.get_temp::<f64>(Self::when_was_a_toolip_last_shown_id()));
+
+        if let Some(when_was_a_toolip_last_shown) = when_was_a_toolip_last_shown {
+            let now = ctx.input(|i| i.time);
+            (now - when_was_a_toolip_last_shown) as f32
+        } else {
+            f32::INFINITY
+        }
+    }
+
+    fn remember_that_tooltip_was_shown(ctx: &Context) {
+        let now = ctx.input(|i| i.time);
+        ctx.data_mut(|data| data.insert_temp::<f64>(Self::when_was_a_toolip_last_shown_id(), now));
+    }
+
+    /// What is the id of the next tooltip for this widget?
+    pub fn next_tooltip_id(ctx: &Context, widget_id: Id) -> Id {
+        let tooltip_count = ctx.pass_state(|fs| {
+            fs.tooltips
+                .widget_tooltips
+                .get(&widget_id)
+                .map_or(0, |state| state.tooltip_count)
+        });
+        Self::tooltip_id(widget_id, tooltip_count)
+    }
+
+    pub fn tooltip_id(widget_id: Id, tooltip_count: usize) -> Id {
+        widget_id.with(tooltip_count)
+    }
+
+    /// Should we show a tooltip for this response?
+    ///
+    /// Argument `allow_interactive_tooltip` controls whether mouse can interact with tooltip that
+    /// contains interactive widgets
+    pub fn should_show_tooltip(response: &Response, allow_interactive_tooltip: bool) -> bool {
+        if response.ctx.memory(|mem| mem.everything_is_visible()) {
+            return true;
+        }
+
+        let any_open_popups = response.ctx.prev_pass_state(|fs| {
+            fs.layers
+                .get(&response.layer_id)
+                .is_some_and(|layer| !layer.open_popups.is_empty())
+        });
+        if any_open_popups {
+            // Hide tooltips if the user opens a popup (menu, combo-box, etc.) in the same layer.
+            return false;
+        }
+
+        let style = response.ctx.style();
+
+        let tooltip_delay = style.interaction.tooltip_delay;
+        let tooltip_grace_time = style.interaction.tooltip_grace_time;
+
+        let (
+            time_since_last_scroll,
+            time_since_last_click,
+            time_since_last_pointer_movement,
+            pointer_pos,
+            pointer_dir,
+        ) = response.ctx.input(|i| {
+            (
+                i.time_since_last_scroll(),
+                i.pointer.time_since_last_click(),
+                i.pointer.time_since_last_movement(),
+                i.pointer.hover_pos(),
+                i.pointer.direction(),
+            )
+        });
+
+        if time_since_last_scroll < tooltip_delay {
+            // See https://github.com/emilk/egui/issues/4781
+            // Note that this means we cannot have `ScrollArea`s in a tooltip.
+            response
+                .ctx
+                .request_repaint_after_secs(tooltip_delay - time_since_last_scroll);
+            return false;
+        }
+
+        let is_our_tooltip_open = response.is_tooltip_open();
+
+        if is_our_tooltip_open {
+            // Check if we should automatically stay open:
+
+            let tooltip_id = Self::next_tooltip_id(&response.ctx, response.id);
+            let tooltip_layer_id = LayerId::new(Order::Tooltip, tooltip_id);
+
+            let tooltip_has_interactive_widget = allow_interactive_tooltip
+                && response.ctx.viewport(|vp| {
+                    vp.prev_pass
+                        .widgets
+                        .get_layer(tooltip_layer_id)
+                        .any(|w| w.enabled && w.sense.interactive())
+                });
+
+            if tooltip_has_interactive_widget {
+                // We keep the tooltip open if hovered,
+                // or if the pointer is on its way to it,
+                // so that the user can interact with the tooltip
+                // (i.e. click links that are in it).
+                if let Some(area) = AreaState::load(&response.ctx, tooltip_id) {
+                    let rect = area.rect();
+
+                    if let Some(pos) = pointer_pos {
+                        if rect.contains(pos) {
+                            return true; // hovering interactive tooltip
+                        }
+                        if pointer_dir != Vec2::ZERO
+                            && rect.intersects_ray(pos, pointer_dir.normalized())
+                        {
+                            return true; // on the way to interactive tooltip
+                        }
+                    }
+                }
+            }
+        }
+
+        let clicked_more_recently_than_moved =
+            time_since_last_click < time_since_last_pointer_movement + 0.1;
+        if clicked_more_recently_than_moved {
+            // It is common to click a widget and then rest the mouse there.
+            // It would be annoying to then see a tooltip for it immediately.
+            // Similarly, clicking should hide the existing tooltip.
+            // Only hovering should lead to a tooltip, not clicking.
+            // The offset is only to allow small movement just right after the click.
+            return false;
+        }
+
+        if is_our_tooltip_open {
+            // Check if we should automatically stay open:
+
+            if pointer_pos.is_some_and(|pointer_pos| response.rect.contains(pointer_pos)) {
+                // Handle the case of a big tooltip that covers the widget:
+                return true;
+            }
+        }
+
+        let is_other_tooltip_open = response.ctx.prev_pass_state(|fs| {
+            if let Some(already_open_tooltip) = fs
+                .layers
+                .get(&response.layer_id)
+                .and_then(|layer| layer.widget_with_tooltip)
+            {
+                already_open_tooltip != response.id
+            } else {
+                false
+            }
+        });
+        if is_other_tooltip_open {
+            // We only allow one tooltip per layer. First one wins. It is up to that tooltip to close itself.
+            return false;
+        }
+
+        // Fast early-outs:
+        if response.enabled() {
+            if !response.hovered() || !response.ctx.input(|i| i.pointer.has_pointer()) {
+                return false;
+            }
+        } else if !response
+            .ctx
+            .rect_contains_pointer(response.layer_id, response.rect)
+        {
+            return false;
+        }
+
+        // There is a tooltip_delay before showing the first tooltip,
+        // but once one tooltip is show, moving the mouse cursor to
+        // another widget should show the tooltip for that widget right away.
+
+        // Let the user quickly move over some dead space to hover the next thing
+        let tooltip_was_recently_shown =
+            Self::seconds_since_last_tooltip(&response.ctx) < tooltip_grace_time;
+
+        if !tooltip_was_recently_shown && !is_our_tooltip_open {
+            if style.interaction.show_tooltips_only_when_still {
+                // We only show the tooltip when the mouse pointer is still.
+                if !response
+                    .ctx
+                    .input(|i| i.pointer.is_still() && !i.is_scrolling())
+                {
+                    // wait for mouse to stop
+                    response.ctx.request_repaint();
+                    return false;
+                }
+            }
+
+            let time_since_last_interaction = time_since_last_scroll
+                .min(time_since_last_pointer_movement)
+                .min(time_since_last_click);
+            let time_til_tooltip = tooltip_delay - time_since_last_interaction;
+
+            if 0.0 < time_til_tooltip {
+                // Wait until the mouse has been still for a while
+                response.ctx.request_repaint_after_secs(time_til_tooltip);
+                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 response
+            .ctx
+            .input(|i| i.pointer.any_down() && i.pointer.has_moved_too_much_for_a_click)
+        {
+            return false;
+        }
+
+        // All checks passed: show the tooltip!
+
+        true
+    }
+
+    /// Was this tooltip visible last frame?
+    pub fn was_tooltip_open_last_frame(ctx: &Context, widget_id: Id) -> bool {
+        let primary_tooltip_area_id = Self::tooltip_id(widget_id, 0);
+        ctx.memory(|mem| {
+            mem.areas()
+                .visible_last_frame(&LayerId::new(Order::Tooltip, primary_tooltip_area_id))
+        })
+    }
+}
diff --git a/crates/egui/src/containers/window.rs b/crates/egui/src/containers/window.rs
index 6075377ff..8d7a95be7 100644
--- a/crates/egui/src/containers/window.rs
+++ b/crates/egui/src/containers/window.rs
@@ -8,8 +8,8 @@ use epaint::{CornerRadiusF32, RectShape};
 use crate::collapsing_header::CollapsingState;
 use crate::*;
 
-use super::scroll_area::ScrollBarVisibility;
-use super::{area, resize, Area, Frame, Resize, ScrollArea};
+use super::scroll_area::{ScrollBarVisibility, ScrollSource};
+use super::{Area, Frame, Resize, ScrollArea, area, resize};
 
 /// Builder for a floating window which can be dragged, closed, collapsed, resized and scrolled (off by default).
 ///
@@ -376,14 +376,6 @@ impl<'open> Window<'open> {
         self
     }
 
-    /// Enable/disable horizontal/vertical scrolling. `false` by default.
-    #[deprecated = "Renamed to `scroll`"]
-    #[inline]
-    pub fn scroll2(mut self, scroll: impl Into<Vec2b>) -> Self {
-        self.scroll = self.scroll.scroll(scroll);
-        self
-    }
-
     /// Enable/disable horizontal scrolling. `false` by default.
     #[inline]
     pub fn hscroll(mut self, hscroll: bool) -> Self {
@@ -403,7 +395,10 @@ impl<'open> Window<'open> {
     /// See [`ScrollArea::drag_to_scroll`] for more.
     #[inline]
     pub fn drag_to_scroll(mut self, drag_to_scroll: bool) -> Self {
-        self.scroll = self.scroll.drag_to_scroll(drag_to_scroll);
+        self.scroll = self.scroll.scroll_source(ScrollSource {
+            drag: drag_to_scroll,
+            ..Default::default()
+        });
         self
     }
 
@@ -434,7 +429,7 @@ impl Window<'_> {
     ) -> Option<InnerResponse<Option<R>>> {
         let Window {
             title,
-            open,
+            mut open,
             area,
             frame,
             resize,
@@ -481,7 +476,7 @@ impl Window<'_> {
         let (title_bar_height_with_margin, title_content_spacing) = if with_title_bar {
             let style = ctx.style();
             let title_bar_inner_height = ctx
-                .fonts(|fonts| title.font_height(fonts, &style))
+                .fonts_mut(|fonts| title.font_height(fonts, &style))
                 .at_least(style.spacing.interact_size.y);
             let title_bar_inner_height = title_bar_inner_height + window_frame.inner_margin.sum().y;
             let half_height = (title_bar_inner_height / 2.0).round() as _;
@@ -510,15 +505,14 @@ impl Window<'_> {
 
         // First check for resize to avoid frame delay:
         let last_frame_outer_rect = area.state().rect();
-        let resize_interaction = ctx.with_accessibility_parent(area.id(), || {
-            resize_interaction(
-                ctx,
-                possible,
-                area_layer_id,
-                last_frame_outer_rect,
-                window_frame,
-            )
-        });
+        let resize_interaction = resize_interaction(
+            ctx,
+            possible,
+            area.id(),
+            area_layer_id,
+            last_frame_outer_rect,
+            window_frame,
+        );
 
         {
             let margins = window_frame.total_margin().sum()
@@ -543,113 +537,117 @@ impl Window<'_> {
         }
 
         let content_inner = {
-            ctx.with_accessibility_parent(area.id(), || {
-                // BEGIN FRAME --------------------------------
-                let mut frame = window_frame.begin(&mut area_content_ui);
+            // BEGIN FRAME --------------------------------
+            let mut frame = window_frame.begin(&mut area_content_ui);
 
-                let show_close_button = open.is_some();
+            let show_close_button = open.is_some();
 
-                let where_to_put_header_background = &area_content_ui.painter().add(Shape::Noop);
+            let where_to_put_header_background = &area_content_ui.painter().add(Shape::Noop);
 
-                let title_bar = if with_title_bar {
-                    let title_bar = TitleBar::new(
-                        &frame.content_ui,
-                        title,
-                        show_close_button,
-                        collapsible,
-                        window_frame,
-                        title_bar_height_with_margin,
-                    );
-                    resize.min_size.x = resize.min_size.x.at_least(title_bar.inner_rect.width()); // Prevent making window smaller than title bar width
-
-                    frame.content_ui.set_min_size(title_bar.inner_rect.size());
-
-                    // Skip the title bar (and separator):
-                    if is_collapsed {
-                        frame.content_ui.add_space(title_bar.inner_rect.height());
-                    } else {
-                        frame.content_ui.add_space(
-                            title_bar.inner_rect.height()
-                                + title_content_spacing
-                                + window_frame.inner_margin.sum().y,
-                        );
-                    }
-
-                    Some(title_bar)
-                } else {
-                    None
-                };
-
-                let (content_inner, content_response) = collapsing
-                    .show_body_unindented(&mut frame.content_ui, |ui| {
-                        resize.show(ui, |ui| {
-                            if scroll.is_any_scroll_enabled() {
-                                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(
-                    &area_content_ui,
-                    &possible,
-                    outer_rect,
-                    &window_frame,
-                    resize_interaction,
+            let title_bar = if with_title_bar {
+                let title_bar = TitleBar::new(
+                    &frame.content_ui,
+                    title,
+                    show_close_button,
+                    collapsible,
+                    window_frame,
+                    title_bar_height_with_margin,
                 );
+                resize.min_size.x = resize.min_size.x.at_least(title_bar.inner_rect.width()); // Prevent making window smaller than title bar width
 
-                // END FRAME --------------------------------
+                frame.content_ui.set_min_size(title_bar.inner_rect.size());
 
-                if let Some(mut title_bar) = title_bar {
-                    title_bar.inner_rect = outer_rect.shrink(window_frame.stroke.width);
-                    title_bar.inner_rect.max.y =
-                        title_bar.inner_rect.min.y + title_bar_height_with_margin;
-
-                    if on_top && area_content_ui.visuals().window_highlight_topmost {
-                        let mut round =
-                            window_frame.corner_radius - window_frame.stroke.width.round() as u8;
-
-                        if !is_collapsed {
-                            round.se = 0;
-                            round.sw = 0;
-                        }
-
-                        area_content_ui.painter().set(
-                            *where_to_put_header_background,
-                            RectShape::filled(title_bar.inner_rect, round, header_color),
-                        );
-                    };
-
-                    if false {
-                        ctx.debug_painter().debug_rect(
-                            title_bar.inner_rect,
-                            Color32::LIGHT_BLUE,
-                            "title_bar.rect",
-                        );
-                    }
-
-                    title_bar.ui(
-                        &mut area_content_ui,
-                        &content_response,
-                        open,
-                        &mut collapsing,
-                        collapsible,
+                // Skip the title bar (and separator):
+                if is_collapsed {
+                    frame.content_ui.add_space(title_bar.inner_rect.height());
+                } else {
+                    frame.content_ui.add_space(
+                        title_bar.inner_rect.height()
+                            + title_content_spacing
+                            + window_frame.inner_margin.sum().y,
                     );
                 }
 
-                collapsing.store(ctx);
+                Some(title_bar)
+            } else {
+                None
+            };
 
-                paint_frame_interaction(&area_content_ui, outer_rect, resize_interaction);
+            let (content_inner, content_response) = collapsing
+                .show_body_unindented(&mut frame.content_ui, |ui| {
+                    resize.show(ui, |ui| {
+                        if scroll.is_any_scroll_enabled() {
+                            scroll.show(ui, add_contents).inner
+                        } else {
+                            add_contents(ui)
+                        }
+                    })
+                })
+                .map_or((None, None), |ir| (Some(ir.inner), Some(ir.response)));
 
-                content_inner
-            })
+            let outer_rect = frame.end(&mut area_content_ui).rect;
+            paint_resize_corner(
+                &area_content_ui,
+                &possible,
+                outer_rect,
+                &window_frame,
+                resize_interaction,
+            );
+
+            // END FRAME --------------------------------
+
+            if let Some(mut title_bar) = title_bar {
+                title_bar.inner_rect = outer_rect.shrink(window_frame.stroke.width);
+                title_bar.inner_rect.max.y =
+                    title_bar.inner_rect.min.y + title_bar_height_with_margin;
+
+                if on_top && area_content_ui.visuals().window_highlight_topmost {
+                    let mut round =
+                        window_frame.corner_radius - window_frame.stroke.width.round() as u8;
+
+                    if !is_collapsed {
+                        round.se = 0;
+                        round.sw = 0;
+                    }
+
+                    area_content_ui.painter().set(
+                        *where_to_put_header_background,
+                        RectShape::filled(title_bar.inner_rect, round, header_color),
+                    );
+                }
+
+                if false {
+                    ctx.debug_painter().debug_rect(
+                        title_bar.inner_rect,
+                        Color32::LIGHT_BLUE,
+                        "title_bar.rect",
+                    );
+                }
+
+                title_bar.ui(
+                    &mut area_content_ui,
+                    &content_response,
+                    open.as_deref_mut(),
+                    &mut collapsing,
+                    collapsible,
+                );
+            }
+
+            collapsing.store(ctx);
+
+            paint_frame_interaction(&area_content_ui, outer_rect, resize_interaction);
+
+            content_inner
         };
 
         let full_response = area.end(ctx, area_content_ui);
 
+        if full_response.should_close()
+            && let Some(open) = open
+        {
+            *open = false;
+        }
+
         let inner_response = InnerResponse {
             inner: content_inner,
             response: full_response,
@@ -827,7 +825,7 @@ fn resize_response(
     area: &mut area::Prepared,
     resize_id: Id,
 ) {
-    let Some(mut new_rect) = move_and_resize_window(ctx, &resize_interaction) else {
+    let Some(mut new_rect) = move_and_resize_window(ctx, resize_id, &resize_interaction) else {
         return;
     };
 
@@ -838,38 +836,49 @@ fn resize_response(
     // 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 resize_interaction.any_dragged() {
-        if let Some(mut state) = resize::State::load(ctx, resize_id) {
-            state.requested_size = Some(new_rect.size() - margins);
-            state.store(ctx, resize_id);
-        }
+    if resize_interaction.any_dragged()
+        && 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_mut().move_to_top(area_layer_id));
 }
 
 /// Acts on outer rect (outside the stroke)
-fn move_and_resize_window(ctx: &Context, interaction: &ResizeInteraction) -> Option<Rect> {
+fn move_and_resize_window(ctx: &Context, id: Id, interaction: &ResizeInteraction) -> Option<Rect> {
+    // Used to prevent drift
+    let rect_at_start_of_drag_id = id.with("window_rect_at_drag_start");
+
     if !interaction.any_dragged() {
+        ctx.data_mut(|data| {
+            data.remove::<Rect>(rect_at_start_of_drag_id);
+        });
         return None;
     }
 
-    let pointer_pos = ctx.input(|i| i.pointer.interact_pos())?;
-    let mut rect = interaction.outer_rect; // prevent drift
+    let total_drag_delta = ctx.input(|i| i.pointer.total_drag_delta())?;
+
+    let rect_at_start_of_drag = ctx.data_mut(|data| {
+        *data.get_temp_mut_or::<Rect>(rect_at_start_of_drag_id, interaction.outer_rect)
+    });
+
+    let mut rect = rect_at_start_of_drag; // prevent drift
 
     // Put the rect in the center of the stroke:
     rect = rect.shrink(interaction.window_frame.stroke.width / 2.0);
 
     if interaction.left.drag {
-        rect.min.x = pointer_pos.x;
+        rect.min.x += total_drag_delta.x;
     } else if interaction.right.drag {
-        rect.max.x = pointer_pos.x;
+        rect.max.x += total_drag_delta.x;
     }
 
     if interaction.top.drag {
-        rect.min.y = pointer_pos.y;
+        rect.min.y += total_drag_delta.y;
     } else if interaction.bottom.drag {
-        rect.max.y = pointer_pos.y;
+        rect.max.y += total_drag_delta.y;
     }
 
     // Return to having the rect outside the stroke:
@@ -881,6 +890,7 @@ fn move_and_resize_window(ctx: &Context, interaction: &ResizeInteraction) -> Opt
 fn resize_interaction(
     ctx: &Context,
     possible: PossibleInteractions,
+    _accessibility_parent: Id,
     layer_id: LayerId,
     outer_rect: Rect,
     window_frame: Frame,
@@ -900,6 +910,7 @@ fn resize_interaction(
     let rect = outer_rect.shrink(window_frame.stroke.width / 2.0);
 
     let side_response = |rect, id| {
+        ctx.register_accesskit_parent(id, _accessibility_parent);
         let response = ctx.create_widget(
             WidgetRect {
                 layer_id,
@@ -1211,7 +1222,7 @@ impl TitleBar {
             let button_rect = Rect::from_center_size(button_center, button_size);
             let button_rect = button_rect.round_ui();
 
-            ui.allocate_new_ui(UiBuilder::new().max_rect(button_rect), |ui| {
+            ui.scope_builder(UiBuilder::new().max_rect(button_rect), |ui| {
                 collapsing.show_default_button_with_size(ui, button_size);
             });
         }
diff --git a/crates/egui/src/context.rs b/crates/egui/src/context.rs
index 811ca4a11..2ca7af4fc 100644
--- a/crates/egui/src/context.rs
+++ b/crates/egui/src/context.rs
@@ -2,49 +2,47 @@
 
 use std::{borrow::Cow, cell::RefCell, panic::Location, sync::Arc, time::Duration};
 
-use containers::area::AreaState;
 use emath::GuiRounding as _;
 use epaint::{
+    ClippedPrimitive, ClippedShape, Color32, ImageData, Pos2, Rect, StrokeKind,
+    TessellationOptions, TextureId, Vec2,
     emath::{self, TSTransform},
     mutex::RwLock,
     stats::PaintStats,
     tessellator,
-    text::{FontInsert, FontPriority, Fonts},
-    util::OrderedFloat,
-    vec2, ClippedPrimitive, ClippedShape, Color32, ImageData, ImageDelta, Pos2, Rect, StrokeKind,
-    TessellationOptions, TextureAtlas, TextureId, Vec2,
+    text::{FontInsert, FontPriority, Fonts, FontsView},
+    vec2,
 };
 
 use crate::{
+    Align2, CursorIcon, DeferredViewportUiCallback, FontDefinitions, Grid, Id, ImmediateViewport,
+    ImmediateViewportRendererCallback, Key, KeyboardShortcut, Label, LayerId, Memory,
+    ModifierNames, Modifiers, NumExt as _, Order, Painter, RawInput, Response, RichText,
+    SafeAreaInsets, ScrollArea, Sense, Style, TextStyle, TextureHandle, TextureOptions, Ui,
+    ViewportBuilder, ViewportCommand, ViewportId, ViewportIdMap, ViewportIdPair, ViewportIdSet,
+    ViewportOutput, Widget as _, WidgetRect, WidgetText,
     animation_manager::AnimationManager,
-    containers,
+    containers::{self, area::AreaState},
     data::output::PlatformOutput,
-    epaint, hit_test,
-    input_state::{InputState, MultiTouchInfo, PointerEvent},
-    interaction,
+    epaint,
+    hit_test::WidgetHits,
+    input_state::{InputState, MultiTouchInfo, PointerEvent, SurrenderFocusOn},
+    interaction::InteractionSnapshot,
     layers::GraphicLayers,
-    load,
-    load::{Bytes, Loaders, SizedTexture},
+    load::{self, Bytes, Loaders, SizedTexture},
     memory::{Options, Theme},
-    menu,
     os::OperatingSystem,
     output::FullOutput,
     pass_state::PassState,
+    plugin,
+    plugin::TypedPluginHandle,
     resize, response, scroll_area,
     util::IdTypeMap,
     viewport::ViewportClass,
-    Align2, CursorIcon, DeferredViewportUiCallback, FontDefinitions, Grid, Id, ImmediateViewport,
-    ImmediateViewportRendererCallback, Key, KeyboardShortcut, Label, LayerId, Memory,
-    ModifierNames, NumExt, Order, Painter, RawInput, Response, RichText, ScrollArea, Sense, Style,
-    TextStyle, TextureHandle, TextureOptions, Ui, ViewportBuilder, ViewportCommand, ViewportId,
-    ViewportIdMap, ViewportIdPair, ViewportIdSet, ViewportOutput, Widget, WidgetRect, WidgetText,
 };
 
-#[cfg(feature = "accesskit")]
 use crate::IdMap;
 
-use self::{hit_test::WidgetHits, interaction::InteractionSnapshot};
-
 /// Information given to the backend about when it is time to repaint the ui.
 ///
 /// This is given in the callback set by [`Context::set_request_repaint_callback`].
@@ -80,10 +78,14 @@ impl Default for WrappedTextureManager {
         // Will be filled in later
         let font_id = tex_mngr.alloc(
             "egui_font_texture".into(),
-            epaint::FontImage::new([0, 0]).into(),
+            epaint::ColorImage::filled([0, 0], Color32::TRANSPARENT).into(),
             Default::default(),
         );
-        assert_eq!(font_id, TextureId::default());
+        assert_eq!(
+            font_id,
+            TextureId::default(),
+            "font id should be equal to TextureId::default(), but was {font_id:?}",
+        );
 
         Self(Arc::new(RwLock::new(tex_mngr)))
     }
@@ -91,46 +93,6 @@ impl Default for WrappedTextureManager {
 
 // ----------------------------------------------------------------------------
 
-/// Generic event callback.
-pub type ContextCallback = Arc<dyn Fn(&Context) + Send + Sync>;
-
-#[derive(Clone)]
-struct NamedContextCallback {
-    debug_name: &'static str,
-    callback: ContextCallback,
-}
-
-/// Callbacks that users can register
-#[derive(Clone, Default)]
-struct Plugins {
-    pub on_begin_pass: Vec<NamedContextCallback>,
-    pub on_end_pass: Vec<NamedContextCallback>,
-}
-
-impl Plugins {
-    fn call(ctx: &Context, _cb_name: &str, callbacks: &[NamedContextCallback]) {
-        profiling::scope!("plugins", _cb_name);
-        for NamedContextCallback {
-            debug_name: _name,
-            callback,
-        } in callbacks
-        {
-            profiling::scope!("plugin", _name);
-            (callback)(ctx);
-        }
-    }
-
-    fn on_begin_pass(&self, ctx: &Context) {
-        Self::call(ctx, "on_begin_pass", &self.on_begin_pass);
-    }
-
-    fn on_end_pass(&self, ctx: &Context) {
-        Self::call(ctx, "on_end_pass", &self.on_end_pass);
-    }
-}
-
-// ----------------------------------------------------------------------------
-
 /// Repaint-logic
 impl ContextImpl {
     /// This is where we update the repaint logic.
@@ -311,7 +273,7 @@ impl std::fmt::Display for RepaintCause {
 
 impl RepaintCause {
     /// Capture the file and line number of the call site.
-    #[allow(clippy::new_without_default)]
+    #[expect(clippy::new_without_default)]
     #[track_caller]
     pub fn new() -> Self {
         let caller = Location::caller();
@@ -324,7 +286,6 @@ impl RepaintCause {
 
     /// Capture the file and line number of the call site,
     /// as well as add a reason.
-    #[allow(clippy::new_without_default)]
     #[track_caller]
     pub fn new_reason(reason: impl Into<Cow<'static, str>>) -> Self {
         let caller = Location::caller();
@@ -339,6 +300,15 @@ impl RepaintCause {
 /// Per-viewport state related to repaint scheduling.
 struct ViewportRepaintInfo {
     /// Monotonically increasing counter.
+    ///
+    /// Incremented at the end of [`Context::run`].
+    /// This can be smaller than [`Self::cumulative_pass_nr`],
+    /// but never larger.
+    cumulative_frame_nr: u64,
+
+    /// Monotonically increasing counter, counting the number of passes.
+    /// This can be larger than [`Self::cumulative_frame_nr`],
+    /// but never smaller.
     cumulative_pass_nr: u64,
 
     /// The duration which the backend will poll for new events
@@ -369,6 +339,7 @@ struct ViewportRepaintInfo {
 impl Default for ViewportRepaintInfo {
     fn default() -> Self {
         Self {
+            cumulative_frame_nr: 0,
             cumulative_pass_nr: 0,
 
             // We haven't scheduled a repaint yet.
@@ -395,18 +366,14 @@ impl ViewportRepaintInfo {
 
 #[derive(Default)]
 struct ContextImpl {
-    /// Since we could have multiple viewports across multiple monitors with
-    /// different `pixels_per_point`, we need a `Fonts` instance for each unique
-    /// `pixels_per_point`.
-    /// This is because the `Fonts` depend on `pixels_per_point` for the font atlas
-    /// as well as kerning, font sizes, etc.
-    fonts: std::collections::BTreeMap<OrderedFloat<f32>, Fonts>,
+    fonts: Option<Fonts>,
     font_definitions: FontDefinitions,
 
     memory: Memory,
     animation_manager: AnimationManager,
 
-    plugins: Plugins,
+    plugins: plugin::Plugins,
+    safe_area: SafeAreaInsets,
 
     /// All viewports share the same texture manager and texture namespace.
     ///
@@ -436,7 +403,6 @@ struct ContextImpl {
 
     embed_viewports: bool,
 
-    #[cfg(feature = "accesskit")]
     is_accesskit_enabled: bool,
 
     loaders: Arc<Loaders>,
@@ -452,6 +418,10 @@ impl ContextImpl {
             .unwrap_or_default();
         let ids = ViewportIdPair::from_self_and_parent(viewport_id, parent_id);
 
+        if let Some(safe_area) = new_raw_input.safe_area_insets {
+            self.safe_area = safe_area;
+        }
+
         let is_outermost_viewport = self.viewport_stack.is_empty(); // not necessarily root, just outermost immediate viewport
         self.viewport_stack.push(ids);
 
@@ -459,20 +429,18 @@ impl ContextImpl {
 
         let viewport = self.viewports.entry(viewport_id).or_default();
 
-        if is_outermost_viewport {
-            if let Some(new_zoom_factor) = self.new_zoom_factor.take() {
-                let ratio = self.memory.options.zoom_factor / new_zoom_factor;
-                self.memory.options.zoom_factor = new_zoom_factor;
+        if is_outermost_viewport && let Some(new_zoom_factor) = self.new_zoom_factor.take() {
+            let ratio = self.memory.options.zoom_factor / new_zoom_factor;
+            self.memory.options.zoom_factor = new_zoom_factor;
 
-                let input = &viewport.input;
-                // This is a bit hacky, but is required to avoid jitter:
-                let mut rect = 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);
-                // We should really scale everything else in the input too,
-                // but the `screen_rect` is the most important part.
-            }
+            let input = &viewport.input;
+            // This is a bit hacky, but is required to avoid jitter:
+            let mut rect = input.content_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);
+            // We should really scale everything else in the input too,
+            // but the `screen_rect` is the most important part.
         }
         let native_pixels_per_point = new_raw_input
             .viewport()
@@ -490,12 +458,13 @@ impl ContextImpl {
             new_raw_input,
             viewport.repaint.requested_immediate_repaint_prev_pass(),
             pixels_per_point,
-            &self.memory.options,
+            self.memory.options.input_options,
         );
+        let repaint_after = viewport.input.wants_repaint_after();
 
-        let screen_rect = viewport.input.screen_rect;
+        let content_rect = viewport.input.content_rect();
 
-        viewport.this_pass.begin_pass(screen_rect);
+        viewport.this_pass.begin_pass(content_rect);
 
         {
             let mut layers: Vec<LayerId> = viewport.prev_pass.widgets.layer_ids().collect();
@@ -528,15 +497,14 @@ impl ContextImpl {
         self.memory.areas_mut().set_state(
             LayerId::background(),
             AreaState {
-                pivot_pos: Some(screen_rect.left_top()),
+                pivot_pos: Some(content_rect.left_top()),
                 pivot: Align2::LEFT_TOP,
-                size: Some(screen_rect.size()),
+                size: Some(content_rect.size()),
                 interactable: true,
                 last_became_visible_at: None,
             },
         );
 
-        #[cfg(feature = "accesskit")]
         if self.is_accesskit_enabled {
             profiling::scope!("accesskit");
             use crate::pass_state::AccessKitPassState;
@@ -548,32 +516,35 @@ impl ContextImpl {
             nodes.insert(id, root_node);
             viewport.this_pass.accesskit_state = Some(AccessKitPassState {
                 nodes,
-                parent_stack: vec![id],
+                parent_map: IdMap::default(),
             });
         }
 
         self.update_fonts_mut();
+
+        if let Some(delay) = repaint_after {
+            self.request_repaint_after(delay, viewport_id, RepaintCause::new());
+        }
     }
 
     /// Load fonts unless already loaded.
     fn update_fonts_mut(&mut self) {
         profiling::function_scope!();
         let input = &self.viewport().input;
-        let pixels_per_point = input.pixels_per_point();
         let max_texture_side = input.max_texture_side;
 
         if let Some(font_definitions) = self.memory.new_font_definitions.take() {
             // New font definition loaded, so we need to reload all fonts.
-            self.fonts.clear();
+            self.fonts = None;
             self.font_definitions = font_definitions;
-            #[cfg(feature = "log")]
+
             log::trace!("Loading new font definitions");
         }
 
         if !self.memory.add_fonts.is_empty() {
             let fonts = self.memory.add_fonts.drain(..);
             for font in fonts {
-                self.fonts.clear(); // recreate all the fonts
+                self.fonts = None; // recreate all the fonts
                 for family in font.families {
                     let fam = self
                         .font_definitions
@@ -590,53 +561,62 @@ impl ContextImpl {
                     .insert(font.name, Arc::new(font.data));
             }
 
-            #[cfg(feature = "log")]
             log::trace!("Adding new fonts");
         }
 
+        let text_alpha_from_coverage = self.memory.options.style().visuals.text_alpha_from_coverage;
+
         let mut is_new = false;
 
-        let fonts = self
-            .fonts
-            .entry(pixels_per_point.into())
-            .or_insert_with(|| {
-                #[cfg(feature = "log")]
-                log::trace!("Creating new Fonts for pixels_per_point={pixels_per_point}");
+        let fonts = self.fonts.get_or_insert_with(|| {
+            log::trace!("Creating new Fonts");
 
-                is_new = true;
-                profiling::scope!("Fonts::new");
-                Fonts::new(
-                    pixels_per_point,
-                    max_texture_side,
-                    self.font_definitions.clone(),
-                )
-            });
+            is_new = true;
+            profiling::scope!("Fonts::new");
+            Fonts::new(
+                max_texture_side,
+                text_alpha_from_coverage,
+                self.font_definitions.clone(),
+            )
+        });
 
         {
             profiling::scope!("Fonts::begin_pass");
-            fonts.begin_pass(pixels_per_point, max_texture_side);
-        }
-
-        if is_new && self.memory.options.preload_font_glyphs {
-            profiling::scope!("preload_font_glyphs");
-            // Preload the most common characters for the most common fonts.
-            // This is not very important to do, but may save a few GPU operations.
-            for font_id in self.memory.options.style().text_styles.values() {
-                fonts.lock().fonts.font(font_id).preload_common_characters();
-            }
+            fonts.begin_pass(max_texture_side, text_alpha_from_coverage);
         }
     }
 
-    #[cfg(feature = "accesskit")]
     fn accesskit_node_builder(&mut self, id: Id) -> &mut accesskit::Node {
         let state = self.viewport().this_pass.accesskit_state.as_mut().unwrap();
         let builders = &mut state.nodes;
+
         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();
+
+            /// Find the first ancestor that already has an accesskit node.
+            fn find_accesskit_parent(
+                parent_map: &IdMap<Id>,
+                node_map: &IdMap<accesskit::Node>,
+                id: Id,
+            ) -> Option<Id> {
+                if let Some(parent_id) = parent_map.get(&id) {
+                    if node_map.contains_key(parent_id) {
+                        Some(*parent_id)
+                    } else {
+                        find_accesskit_parent(parent_map, node_map, *parent_id)
+                    }
+                } else {
+                    None
+                }
+            }
+
+            let parent_id = find_accesskit_parent(&state.parent_map, builders, id)
+                .unwrap_or(crate::accesskit_root_id());
+
+            let parent_builder = builders.get_mut(&parent_id).unwrap();
             parent_builder.push_child(id.accesskit_id());
         }
+
         builders.get_mut(&id).unwrap()
     }
 
@@ -698,7 +678,7 @@ impl ContextImpl {
 /// ```
 /// # 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());
+///     ctx.copy_text("Hello!".to_owned());
 /// }
 /// ```
 ///
@@ -751,14 +731,17 @@ impl Default for Context {
     fn default() -> Self {
         let ctx_impl = ContextImpl {
             embed_viewports: true,
+            viewports: std::iter::once((ViewportId::ROOT, ViewportState::default())).collect(),
             ..Default::default()
         };
         let ctx = Self(Arc::new(RwLock::new(ctx_impl)));
 
+        ctx.add_plugin(plugin::CallbackPlugin::default());
+
         // Register built-in plugins:
-        crate::debug_text::register(&ctx);
-        crate::text_selection::LabelSelectionState::register(&ctx);
-        crate::DragAndDrop::register(&ctx);
+        ctx.add_plugin(crate::debug_text::DebugTextPlugin::default());
+        ctx.add_plugin(crate::text_selection::LabelSelectionState::default());
+        ctx.add_plugin(crate::DragAndDrop::default());
 
         ctx
     }
@@ -805,7 +788,11 @@ impl Context {
         let max_passes = self.write(|ctx| ctx.memory.options.max_passes.get());
 
         let mut output = FullOutput::default();
-        debug_assert_eq!(output.platform_output.num_completed_passes, 0);
+        debug_assert_eq!(
+            output.platform_output.num_completed_passes, 0,
+            "output must be fresh, but had {} passes",
+            output.platform_output.num_completed_passes
+        );
 
         loop {
             profiling::scope!(
@@ -829,15 +816,21 @@ impl Context {
             self.begin_pass(new_input.take());
             run_ui(self);
             output.append(self.end_pass());
-            debug_assert!(0 < output.platform_output.num_completed_passes);
+            debug_assert!(
+                0 < output.platform_output.num_completed_passes,
+                "Completed passes was lower than 0, was {}",
+                output.platform_output.num_completed_passes
+            );
 
             if !output.platform_output.requested_discard() {
                 break; // no need for another pass
             }
 
             if max_passes <= output.platform_output.num_completed_passes {
-                #[cfg(feature = "log")]
-                log::debug!("Ignoring call request_discard, because max_passes={max_passes}. Requested from {:?}", output.platform_output.request_discard_reasons);
+                log::debug!(
+                    "Ignoring call request_discard, because max_passes={max_passes}. Requested from {:?}",
+                    output.platform_output.request_discard_reasons
+                );
 
                 break;
             }
@@ -851,6 +844,7 @@ impl Context {
             } else {
                 viewport.num_multipass_in_row = 0;
             }
+            viewport.repaint.cumulative_frame_nr += 1;
         });
 
         output
@@ -876,13 +870,16 @@ impl Context {
     /// let full_output = ctx.end_pass();
     /// // handle full_output
     /// ```
-    pub fn begin_pass(&self, new_input: RawInput) {
+    pub fn begin_pass(&self, mut new_input: RawInput) {
         profiling::function_scope!();
 
+        let plugins = self.read(|ctx| ctx.plugins.ordered_plugins());
+        plugins.on_input(&mut new_input);
+
         self.write(|ctx| ctx.begin_pass(new_input));
 
         // Plugins run just after the pass starts:
-        self.read(|ctx| ctx.plugins.clone()).on_begin_pass(self);
+        plugins.on_begin_pass(self);
     }
 
     /// See [`Self::begin_pass`].
@@ -1017,13 +1014,32 @@ impl Context {
     /// 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 {
+    pub fn fonts<R>(&self, reader: impl FnOnce(&FontsView<'_>) -> R) -> R {
         self.write(move |ctx| {
             let pixels_per_point = ctx.pixels_per_point();
             reader(
-                ctx.fonts
-                    .get(&pixels_per_point.into())
-                    .expect("No fonts available until first call to Context::run()"),
+                &ctx.fonts
+                    .as_mut()
+                    .expect("No fonts available until first call to Context::run()")
+                    .with_pixels_per_point(pixels_per_point),
+            )
+        })
+    }
+
+    /// Read-write 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_mut<R>(&self, reader: impl FnOnce(&mut FontsView<'_>) -> R) -> R {
+        self.write(move |ctx| {
+            let pixels_per_point = ctx.pixels_per_point();
+            reader(
+                &mut ctx
+                    .fonts
+                    .as_mut()
+                    .expect("No fonts available until first call to Context::run()")
+                    .with_pixels_per_point(pixels_per_point),
             )
         })
     }
@@ -1082,14 +1098,14 @@ impl Context {
         }
 
         let show_error = |widget_rect: Rect, text: String| {
-            let screen_rect = self.screen_rect();
+            let content_rect = self.content_rect();
 
             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), StrokeKind::Outside);
 
-            let below = widget_rect.bottom() + 32.0 < screen_rect.bottom();
+            let below = widget_rect.bottom() + 32.0 < content_rect.bottom();
 
             let text_rect = if below {
                 painter.debug_text(
@@ -1107,23 +1123,23 @@ impl Context {
                 )
             };
 
-            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)
-                    };
+            if let Some(pointer_pos) = self.pointer_hover_pos()
+                && 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(
+                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_salt:s.\n\n\
                              Sometimes the solution is to use ui.push_id.",
-                         if below { "above" } else { "below" })
+                                if below { "above" } else { "below" }),
                     );
-                }
             }
         };
 
@@ -1149,7 +1165,6 @@ impl Context {
     ///
     /// `allow_focus` should usually be true, unless you call this function multiple times with the
     /// same widget, then `allow_focus` should only be true once (like in [`Ui::new`] (true) and [`Ui::remember_min_rect`] (false)).
-    #[allow(clippy::too_many_arguments)]
     pub(crate) fn create_widget(&self, w: WidgetRect, allow_focus: bool) -> Response {
         let interested_in_focus = w.enabled
             && w.sense.is_focusable()
@@ -1178,10 +1193,15 @@ impl Context {
             self.check_for_id_clash(w.id, w.rect, "widget");
         }
 
-        #[allow(clippy::let_and_return)]
+        #[allow(clippy::let_and_return, clippy::allow_attributes)]
         let res = self.get_response(w);
 
-        #[cfg(feature = "accesskit")]
+        #[cfg(debug_assertions)]
+        if res.contains_pointer() {
+            let plugins = self.read(|ctx| ctx.plugins.ordered_plugins());
+            plugins.on_widget_under_pointer(self, &w);
+        }
+
         if allow_focus && w.sense.is_focusable() {
             // Make sure anything that can receive focus has an AccessKit node.
             // TODO(mwcampbell): For nodes that are filled from widget info,
@@ -1189,6 +1209,52 @@ impl Context {
             self.accesskit_node_builder(w.id, |builder| res.fill_accesskit_node_common(builder));
         }
 
+        self.write(|ctx| {
+            use crate::{Align, pass_state::ScrollTarget, style::ScrollAnimation};
+            let viewport = ctx.viewport_for(ctx.viewport_id());
+
+            viewport
+                .input
+                .consume_accesskit_action_requests(res.id, |request| {
+                    use accesskit::Action;
+
+                    // TODO(lucasmerlin): Correctly handle the scroll unit:
+                    // https://github.com/AccessKit/accesskit/blob/e639c0e0d8ccbfd9dff302d972fa06f9766d608e/common/src/lib.rs#L2621
+                    const DISTANCE: f32 = 100.0;
+
+                    match &request.action {
+                        Action::ScrollIntoView => {
+                            viewport.this_pass.scroll_target = [
+                                Some(ScrollTarget::new(
+                                    res.rect.x_range(),
+                                    Some(Align::Center),
+                                    ScrollAnimation::none(),
+                                )),
+                                Some(ScrollTarget::new(
+                                    res.rect.y_range(),
+                                    Some(Align::Center),
+                                    ScrollAnimation::none(),
+                                )),
+                            ];
+                        }
+                        Action::ScrollDown => {
+                            viewport.this_pass.scroll_delta.0 += DISTANCE * Vec2::UP;
+                        }
+                        Action::ScrollUp => {
+                            viewport.this_pass.scroll_delta.0 += DISTANCE * Vec2::DOWN;
+                        }
+                        Action::ScrollLeft => {
+                            viewport.this_pass.scroll_delta.0 += DISTANCE * Vec2::LEFT;
+                        }
+                        Action::ScrollRight => {
+                            viewport.this_pass.scroll_delta.0 += DISTANCE * Vec2::RIGHT;
+                        }
+                        _ => return false,
+                    }
+                    true
+                });
+        });
+
         res
     }
 
@@ -1197,26 +1263,31 @@ impl Context {
     /// This is because widget interaction happens at the start of the pass, using the widget rects from the previous pass.
     ///
     /// If the widget was not visible the previous pass (or this pass), this will return `None`.
+    ///
+    /// If you try to read a [`Ui`]'s response, while still inside, this will return the [`Rect`] from the previous frame.
     pub fn read_response(&self, id: Id) -> Option<Response> {
         self.write(|ctx| {
             let viewport = ctx.viewport();
-            viewport
+            let widget_rect = viewport
                 .this_pass
                 .widgets
                 .get(id)
                 .or_else(|| viewport.prev_pass.widgets.get(id))
-                .copied()
+                .copied();
+            widget_rect.map(|mut rect| {
+                // If the Rect is invalid the Ui hasn't registered its final Rect yet.
+                // We return the Rect from last frame instead.
+                if !(rect.rect.is_positive() && rect.rect.is_finite())
+                    && let Some(prev_rect) = viewport.prev_pass.widgets.get(id)
+                {
+                    rect.rect = prev_rect.rect;
+                }
+                rect
+            })
         })
         .map(|widget_rect| self.get_response(widget_rect))
     }
 
-    /// Returns `true` if the widget with the given `Id` contains the pointer.
-    #[deprecated = "Use Response.contains_pointer or Context::read_response instead"]
-    pub fn widget_contains_pointer(&self, id: Id) -> bool {
-        self.read_response(id)
-            .is_some_and(|response| response.contains_pointer())
-    }
-
     /// Do all interaction for an existing widget, without (re-)registering it.
     pub(crate) fn get_response(&self, widget_rect: WidgetRect) -> Response {
         use response::Flags;
@@ -1268,7 +1339,6 @@ impl Context {
                 res.flags.set(Flags::FAKE_PRIMARY_CLICKED, true);
             }
 
-            #[cfg(feature = "accesskit")]
             if enabled
                 && sense.senses_click()
                 && input.has_accesskit_action_request(id, accesskit::Action::Click)
@@ -1349,8 +1419,14 @@ impl Context {
                 res.flags.set(Flags::HOVERED, false);
             }
 
-            let pointer_pressed_elsewhere = any_press && !res.hovered();
-            if pointer_pressed_elsewhere && memory.has_focus(id) {
+            let should_surrender_focus = match memory.options.input_options.surrender_focus_on {
+                SurrenderFocusOn::Presses => any_press,
+                SurrenderFocusOn::Clicks => input.pointer.any_click(),
+                SurrenderFocusOn::Never => false,
+            };
+
+            let pointer_clicked_elsewhere = should_surrender_focus && !res.hovered();
+            if pointer_clicked_elsewhere && memory.has_focus(id) {
                 memory.surrender_focus(id);
             }
         });
@@ -1378,8 +1454,8 @@ impl Context {
 
     /// 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)
+        let content_rect = self.content_rect();
+        Painter::new(self.clone(), layer_id, content_rect)
     }
 
     /// Paint on top of everything else
@@ -1411,7 +1487,7 @@ impl Context {
     /// 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).
+    /// and is done so by [`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe).
     pub fn os(&self) -> OperatingSystem {
         self.read(|ctx| ctx.os)
     }
@@ -1447,7 +1523,7 @@ impl Context {
     /// ```
     /// # let ctx = egui::Context::default();
     /// # let open_url = egui::OpenUrl::same_tab("http://www.example.com");
-    /// ctx.output_mut(|o| o.open_url = Some(open_url));
+    /// ctx.send_cmd(egui::OutputCommand::OpenUrl(open_url));
     /// ```
     pub fn open_url(&self, open_url: crate::OpenUrl) {
         self.send_cmd(crate::OutputCommand::OpenUrl(open_url));
@@ -1471,44 +1547,88 @@ impl Context {
         self.send_cmd(crate::OutputCommand::CopyImage(image));
     }
 
+    fn can_show_modifier_symbols(&self) -> bool {
+        let ModifierNames {
+            alt,
+            ctrl,
+            shift,
+            mac_cmd,
+            ..
+        } = ModifierNames::SYMBOLS;
+
+        let font_id = TextStyle::Body.resolve(&self.style());
+        self.fonts_mut(|f| {
+            let mut font = f.fonts.font(&font_id.family);
+            font.has_glyphs(alt)
+                && font.has_glyphs(ctrl)
+                && font.has_glyphs(shift)
+                && font.has_glyphs(mac_cmd)
+        })
+    }
+
+    /// Format the given modifiers in a human-readable way (e.g. `Ctrl+Shift+X`).
+    pub fn format_modifiers(&self, modifiers: Modifiers) -> String {
+        let os = self.os();
+
+        let is_mac = os.is_mac();
+
+        if is_mac && self.can_show_modifier_symbols() {
+            ModifierNames::SYMBOLS.format(&modifiers, is_mac)
+        } else {
+            ModifierNames::NAMES.format(&modifiers, is_mac)
+        }
+    }
+
     /// Format the given shortcut in a human-readable way (e.g. `Ctrl+Shift+X`).
     ///
     /// Can be used to get the text for [`crate::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 is_mac = os.is_mac();
 
-        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() {
+        if is_mac && self.can_show_modifier_symbols() {
             shortcut.format(&ModifierNames::SYMBOLS, is_mac)
         } else {
             shortcut.format(&ModifierNames::NAMES, is_mac)
         }
     }
 
+    /// The total number of completed frames.
+    ///
+    /// Starts at zero, and is incremented once at the end of each call to [`Self::run`].
+    ///
+    /// This is always smaller or equal to [`Self::cumulative_pass_nr`].
+    pub fn cumulative_frame_nr(&self) -> u64 {
+        self.cumulative_frame_nr_for(self.viewport_id())
+    }
+
+    /// The total number of completed frames.
+    ///
+    /// Starts at zero, and is incremented once at the end of each call to [`Self::run`].
+    ///
+    /// This is always smaller or equal to [`Self::cumulative_pass_nr_for`].
+    pub fn cumulative_frame_nr_for(&self, id: ViewportId) -> u64 {
+        self.read(|ctx| {
+            ctx.viewports
+                .get(&id)
+                .map(|v| v.repaint.cumulative_frame_nr)
+                .unwrap_or_else(|| {
+                    if cfg!(debug_assertions) {
+                        panic!("cumulative_frame_nr_for failed to find the viewport {id:?}");
+                    } else {
+                        0
+                    }
+                })
+        })
+    }
+
     /// The total number of completed passes (usually there is one pass per rendered frame).
     ///
     /// Starts at zero, and is incremented for each completed pass inside of [`Self::run`] (usually once).
+    ///
+    /// If you instead want to know which pass index this is within the current frame,
+    /// use [`Self::current_pass_index`].
     pub fn cumulative_pass_nr(&self) -> u64 {
         self.cumulative_pass_nr_for(self.viewport_id())
     }
@@ -1524,6 +1644,18 @@ impl Context {
         })
     }
 
+    /// The index of the current pass in the current frame, starting at zero.
+    ///
+    /// Usually this is zero, but if something called [`Self::request_discard`] to do multi-pass layout,
+    /// then this will be incremented for each pass.
+    ///
+    /// This just reads the value of [`PlatformOutput::num_completed_passes`].
+    ///
+    /// To know the total number of passes ever completed, use [`Self::cumulative_pass_nr`].
+    pub fn current_pass_index(&self) -> usize {
+        self.output(|o| o.num_completed_passes)
+    }
+
     /// 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.
@@ -1696,7 +1828,7 @@ impl Context {
     /// This means the first pass will look glitchy, and ideally should not be shown to the user.
     /// So [`crate::Grid`] calls [`Self::request_discard`] to cover up this glitches.
     ///
-    /// There is a limit to how many passes egui will perform, set by [`Options::max_passes`].
+    /// There is a limit to how many passes egui will perform, set by [`Options::max_passes`] (default=2).
     /// Therefore, the request might be declined.
     ///
     /// You can check if the current pass will be discarded with [`Self::will_discard`].
@@ -1712,7 +1844,6 @@ impl Context {
         let cause = RepaintCause::new_reason(reason);
         self.output_mut(|o| o.request_discard_reasons.push(cause));
 
-        #[cfg(feature = "log")]
         log::trace!(
             "request_discard: {}",
             if self.will_discard() {
@@ -1742,26 +1873,76 @@ impl Context {
 impl Context {
     /// Call the given callback at the start of each pass of each viewport.
     ///
-    /// This can be used for egui _plugins_.
-    /// See [`crate::debug_text`] for an example.
-    pub fn on_begin_pass(&self, debug_name: &'static str, cb: ContextCallback) {
-        let named_cb = NamedContextCallback {
-            debug_name,
-            callback: cb,
-        };
-        self.write(|ctx| ctx.plugins.on_begin_pass.push(named_cb));
+    /// This is a convenience wrapper around [`Self::add_plugin`].
+    pub fn on_begin_pass(&self, debug_name: &'static str, cb: plugin::ContextCallback) {
+        self.with_plugin(|p: &mut crate::plugin::CallbackPlugin| {
+            p.on_begin_plugins.push((debug_name, cb));
+        });
     }
 
     /// Call the given callback at the end of each pass of each viewport.
     ///
-    /// This can be used for egui _plugins_.
-    /// See [`crate::debug_text`] for an example.
-    pub fn on_end_pass(&self, debug_name: &'static str, cb: ContextCallback) {
-        let named_cb = NamedContextCallback {
-            debug_name,
-            callback: cb,
-        };
-        self.write(|ctx| ctx.plugins.on_end_pass.push(named_cb));
+    /// This is a convenience wrapper around [`Self::add_plugin`].
+    pub fn on_end_pass(&self, debug_name: &'static str, cb: plugin::ContextCallback) {
+        self.with_plugin(|p: &mut crate::plugin::CallbackPlugin| {
+            p.on_end_plugins.push((debug_name, cb));
+        });
+    }
+
+    /// Register a [`Plugin`](plugin::Plugin)
+    ///
+    /// Plugins are called in the order they are added.
+    ///
+    /// A plugin of the same type can only be added once (further calls with the same type will be ignored).
+    /// This way it's convenient to add plugins in `eframe::run_simple_native`.
+    pub fn add_plugin(&self, plugin: impl plugin::Plugin + 'static) {
+        let handle = plugin::PluginHandle::new(plugin);
+
+        let added = self.write(|ctx| ctx.plugins.add(handle.clone()));
+
+        if added {
+            handle.lock().dyn_plugin_mut().setup(self);
+        }
+    }
+
+    /// Call the provided closure with the plugin of type `T`, if it was registered.
+    ///
+    /// Returns `None` if the plugin was not registered.
+    pub fn with_plugin<T: plugin::Plugin + 'static, R>(
+        &self,
+        f: impl FnOnce(&mut T) -> R,
+    ) -> Option<R> {
+        let plugin = self.read(|ctx| ctx.plugins.get(std::any::TypeId::of::<T>()));
+        plugin.map(|plugin| f(plugin.lock().typed_plugin_mut()))
+    }
+
+    /// Get a handle to the plugin of type `T`.
+    ///
+    /// ## Panics
+    /// If the plugin of type `T` was not registered, this will panic.
+    pub fn plugin<T: plugin::Plugin>(&self) -> TypedPluginHandle<T> {
+        if let Some(plugin) = self.plugin_opt() {
+            plugin
+        } else {
+            panic!("Plugin of type {:?} not found", std::any::type_name::<T>());
+        }
+    }
+
+    /// Get a handle to the plugin of type `T`, if it was registered.
+    pub fn plugin_opt<T: plugin::Plugin>(&self) -> Option<TypedPluginHandle<T>> {
+        let plugin = self.read(|ctx| ctx.plugins.get(std::any::TypeId::of::<T>()));
+        plugin.map(TypedPluginHandle::new)
+    }
+
+    /// Get a handle to the plugin of type `T`, or insert its default.
+    pub fn plugin_or_default<T: plugin::Plugin + Default>(&self) -> TypedPluginHandle<T> {
+        if let Some(plugin) = self.plugin_opt() {
+            plugin
+        } else {
+            let default_plugin = T::default();
+            self.add_plugin(default_plugin);
+            self.plugin()
+        }
     }
 }
 
@@ -1776,14 +1957,12 @@ impl Context {
     pub fn set_fonts(&self, font_definitions: FontDefinitions) {
         profiling::function_scope!();
 
-        let pixels_per_point = self.pixels_per_point();
-
         let mut update_fonts = true;
 
         self.read(|ctx| {
-            if let Some(current_fonts) = ctx.fonts.get(&pixels_per_point.into()) {
+            if let Some(current_fonts) = ctx.fonts.as_ref() {
                 // NOTE: this comparison is expensive since it checks TTF data for equality
-                if current_fonts.lock().fonts.definitions() == &font_definitions {
+                if current_fonts.definitions() == &font_definitions {
                     update_fonts = false; // no need to update
                 }
             }
@@ -1804,21 +1983,16 @@ impl Context {
     pub fn add_font(&self, new_font: FontInsert) {
         profiling::function_scope!();
 
-        let pixels_per_point = self.pixels_per_point();
-
         let mut update_fonts = true;
 
         self.read(|ctx| {
-            if let Some(current_fonts) = ctx.fonts.get(&pixels_per_point.into()) {
-                if current_fonts
-                    .lock()
-                    .fonts
+            if let Some(current_fonts) = ctx.fonts.as_ref()
+                && current_fonts
                     .definitions()
                     .font_data
                     .contains_key(&new_font.name)
-                {
-                    update_fonts = false; // no need to update
-                }
+            {
+                update_fonts = false; // no need to update
             }
         });
 
@@ -2019,6 +2193,7 @@ impl Context {
         self.write(|ctx| {
             if ctx.memory.options.zoom_factor != zoom_factor {
                 ctx.new_zoom_factor = Some(zoom_factor);
+                #[expect(clippy::iter_over_hash_type)]
                 for viewport_id in ctx.all_viewport_ids() {
                     ctx.request_repaint(viewport_id, cause.clone());
                 }
@@ -2127,12 +2302,15 @@ impl Context {
         }
 
         // Plugins run just before the pass ends.
-        self.read(|ctx| ctx.plugins.clone()).on_end_pass(self);
+        let plugins = self.read(|ctx| ctx.plugins.ordered_plugins());
+        plugins.on_end_pass(self);
 
         #[cfg(debug_assertions)]
         self.debug_painting();
 
-        self.write(|ctx| ctx.end_pass())
+        let mut output = self.write(|ctx| ctx.end_pass());
+        plugins.on_output(&mut output);
+        output
     }
 
     /// Call at the end of each frame if you called [`Context::begin_pass`].
@@ -2145,6 +2323,8 @@ impl Context {
     /// Called at the end of the pass.
     #[cfg(debug_assertions)]
     fn debug_painting(&self) {
+        #![expect(clippy::iter_over_hash_type)] // ok to be sloppy in debug painting
+
         let paint_widget = |widget: &WidgetRect, text: &str, color: Color32| {
             let rect = widget.interact_rect;
             if rect.is_positive() {
@@ -2275,7 +2455,9 @@ impl Context {
             // If you see this message, it means we've been paying the cost of multi-pass for multiple frames in a row.
             // This is likely a bug. `request_discard` should only be called in rare situations, when some layout changes.
 
-            let mut warning = format!("egui PERF WARNING: request_discard has been called {num_multipass_in_row} frames in a row");
+            let mut warning = format!(
+                "egui PERF WARNING: request_discard has been called {num_multipass_in_row} frames in a row"
+            );
             self.viewport(|vp| {
                 for reason in &vp.output.request_discard_reasons {
                     warning += &format!("\n  {reason}");
@@ -2294,43 +2476,25 @@ impl ContextImpl {
         let viewport = self.viewports.entry(ended_viewport_id).or_default();
         let pixels_per_point = viewport.input.pixels_per_point;
 
+        self.loaders.end_pass(viewport.repaint.cumulative_pass_nr);
+
         viewport.repaint.cumulative_pass_nr += 1;
 
         self.memory.end_pass(&viewport.this_pass.used_ids);
 
-        if let Some(fonts) = self.fonts.get(&pixels_per_point.into()) {
+        if let Some(fonts) = self.fonts.as_mut() {
             let tex_mngr = &mut self.tex_manager.0.write();
             if let Some(font_image_delta) = fonts.font_image_delta() {
                 // A partial font atlas update, e.g. a new glyph has been entered.
                 tex_mngr.set(TextureId::default(), font_image_delta);
             }
-
-            if 1 < self.fonts.len() {
-                // We have multiple different `pixels_per_point`,
-                // e.g. because we have many viewports spread across
-                // monitors with different DPI scaling.
-                // All viewports share the same texture namespace and renderer,
-                // so the all use `TextureId::default()` for the font texture.
-                // This is a problem.
-                // We solve this with a hack: we always upload the full font atlas
-                // every frame, for all viewports.
-                // This ensures it is up-to-date, solving
-                // https://github.com/emilk/egui/issues/3664
-                // at the cost of a lot of performance.
-                // (This will override any smaller delta that was uploaded above.)
-                profiling::scope!("full_font_atlas_update");
-                let full_delta = ImageDelta::full(fonts.image(), TextureAtlas::texture_options());
-                tex_mngr.set(TextureId::default(), full_delta);
-            }
         }
 
         // Inform the backend of all textures that have been updated (including font atlas).
         let textures_delta = self.tex_manager.0.write().take_delta();
 
-        #[cfg_attr(not(feature = "accesskit"), allow(unused_mut))]
         let mut platform_output: PlatformOutput = std::mem::take(&mut viewport.output);
 
-        #[cfg(feature = "accesskit")]
         {
             profiling::scope!("accesskit");
             let state = viewport.this_pass.accesskit_state.take();
@@ -2363,6 +2527,7 @@ impl ContextImpl {
 
         if self.memory.options.repaint_on_widget_change {
             profiling::scope!("compare-widget-rects");
+            #[allow(clippy::allow_attributes, clippy::collapsible_if)] // false positive on wasm
             if viewport.prev_pass.widgets != viewport.this_pass.widgets {
                 repaint_needed = true; // Some widget has moved
             }
@@ -2372,10 +2537,7 @@ impl ContextImpl {
 
         if repaint_needed {
             self.request_repaint(ended_viewport_id, RepaintCause::new());
-        } else if let Some(delay) = viewport.input.wants_repaint_after() {
-            self.request_repaint_after(delay, ended_viewport_id, RepaintCause::new());
         }
-
         //  -------------------
 
         let all_viewport_ids = self.all_viewport_ids();
@@ -2383,10 +2545,13 @@ impl ContextImpl {
         self.last_viewport = ended_viewport_id;
 
         self.viewports.retain(|&id, viewport| {
+            if id == ViewportId::ROOT {
+                return true; // never remove the root
+            }
+
             let parent = *self.viewport_parents.entry(id).or_default();
 
             if !all_viewport_ids.contains(&parent) {
-                #[cfg(feature = "log")]
                 log::debug!(
                     "Removing viewport {:?} ({:?}): the parent is gone",
                     id,
@@ -2399,7 +2564,6 @@ impl ContextImpl {
             let is_our_child = parent == ended_viewport_id && id != ViewportId::ROOT;
             if is_our_child {
                 if !viewport.used {
-                    #[cfg(feature = "log")]
                     log::debug!(
                         "Removing viewport {:?} ({:?}): it was never used this pass",
                         id,
@@ -2453,6 +2617,10 @@ impl ContextImpl {
         if is_last {
             // Remove dead viewports:
             self.viewports.retain(|id, _| all_viewport_ids.contains(id));
+            debug_assert!(
+                self.viewports.contains_key(&ViewportId::ROOT),
+                "Bug in egui: we removed the root viewport"
+            );
             self.viewport_parents
                 .retain(|id, _| all_viewport_ids.contains(id));
         } else {
@@ -2460,24 +2628,6 @@ impl ContextImpl {
             self.memory.set_viewport_id(viewport_id);
         }
 
-        let active_pixels_per_point: std::collections::BTreeSet<OrderedFloat<f32>> = self
-            .viewports
-            .values()
-            .map(|v| v.input.pixels_per_point.into())
-            .collect();
-        self.fonts.retain(|pixels_per_point, _| {
-            if active_pixels_per_point.contains(pixels_per_point) {
-                true
-            } else {
-                #[cfg(feature = "log")]
-                log::trace!(
-                    "Freeing Fonts with pixels_per_point={} because it is no longer needed",
-                    pixels_per_point.into_inner()
-                );
-                false
-            }
-        });
-
         platform_output.num_completed_passes += 1;
 
         FullOutput {
@@ -2509,22 +2659,16 @@ impl Context {
 
         self.write(|ctx| {
             let tessellation_options = ctx.memory.options.tessellation_options;
-            let texture_atlas = if let Some(fonts) = ctx.fonts.get(&pixels_per_point.into()) {
+            let texture_atlas = if let Some(fonts) = ctx.fonts.as_ref() {
                 fonts.texture_atlas()
             } else {
-                #[cfg(feature = "log")]
                 log::warn!("No font size matching {pixels_per_point} pixels per point found.");
                 ctx.fonts
                     .iter()
                     .next()
                     .expect("No fonts loaded")
-                    .1
                     .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 = {
@@ -2532,8 +2676,8 @@ impl Context {
                 tessellator::Tessellator::new(
                     pixels_per_point,
                     tessellation_options,
-                    font_tex_size,
-                    prepared_discs,
+                    texture_atlas.size(),
+                    texture_atlas.prepared_discs(),
                 )
                 .tessellate_shapes(shapes)
             };
@@ -2544,15 +2688,39 @@ impl Context {
 
     // ---------------------------------------------------------------------
 
-    /// Position and size of the egui area.
-    pub fn screen_rect(&self) -> Rect {
-        self.input(|i| i.screen_rect()).round_ui()
+    /// Returns the position and size of the egui area that is safe for content rendering.
+    ///
+    /// Returns [`Self::viewport_rect`] minus areas that might be partially covered by, for example,
+    /// the OS status bar or display notches.
+    ///
+    /// If you want to render behind e.g. the dynamic island on iOS, use [`Self::viewport_rect`].
+    pub fn content_rect(&self) -> Rect {
+        self.input(|i| i.content_rect()).round_ui()
     }
 
-    /// How much space is still available after panels has been added.
+    /// Returns the position and size of the full area available to egui
     ///
-    /// 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.
+    /// This includes reas that might be partially covered by, for example, the OS status bar or
+    /// display notches. See [`Self::content_rect`] to get a rect that is safe for content.
+    ///
+    /// This rectangle includes e.g. the dynamic island on iOS.
+    /// If you want to only render _below_ the that (not behind), then you should use
+    /// [`Self::content_rect`] instead.
+    ///
+    /// See also [`RawInput::safe_area_insets`].
+    pub fn viewport_rect(&self) -> Rect {
+        self.input(|i| i.viewport_rect()).round_ui()
+    }
+
+    /// Position and size of the egui area.
+    #[deprecated(
+        note = "screen_rect has been split into viewport_rect() and content_rect(). You likely should use content_rect()"
+    )]
+    pub fn screen_rect(&self) -> Rect {
+        self.input(|i| i.content_rect()).round_ui()
+    }
+
+    /// How much space is still available after panels have been added.
     pub fn available_rect(&self) -> Rect {
         self.pass_state(|s| s.available_rect()).round_ui()
     }
@@ -2562,7 +2730,7 @@ impl Context {
         self.write(|ctx| {
             let mut used = ctx.viewport().this_pass.used_by_panels;
             for (_id, window) in ctx.memory.areas().visible_windows() {
-                used = used.union(window.rect());
+                used |= window.rect();
             }
             used.round_ui()
         })
@@ -2629,12 +2797,27 @@ impl Context {
     }
 
     /// Is an egui context menu open?
+    ///
+    /// This only works with the old, deprecated [`crate::menu`] API.
+    #[expect(deprecated)]
+    #[deprecated = "Use `is_popup_open` instead"]
     pub fn is_context_menu_open(&self) -> bool {
         self.data(|d| {
-            d.get_temp::<crate::menu::BarState>(menu::CONTEXT_MENU_ID_STR.into())
+            d.get_temp::<crate::menu::BarState>(crate::menu::CONTEXT_MENU_ID_STR.into())
                 .is_some_and(|state| state.has_root())
         })
     }
+
+    /// Is a popup or (context) menu open?
+    ///
+    /// Will return false for [`crate::Tooltip`]s (which are technically popups as well).
+    pub fn is_popup_open(&self) -> bool {
+        self.pass_state_mut(|fs| {
+            fs.layers
+                .values()
+                .any(|layer| !layer.open_popups.is_empty())
+        })
+    }
 }
 
 // Ergonomic methods to forward some calls often used in 'if let' without holding the borrow
@@ -2679,7 +2862,8 @@ impl Context {
     ///
     /// Can be used to implement pan and zoom (see relevant demo).
     ///
-    /// For a temporary transform, use [`Self::transform_layer_shapes`] instead.
+    /// For a temporary transform, use [`Self::transform_layer_shapes`] or
+    /// [`Ui::with_visual_transform`].
     pub fn set_transform_layer(&self, layer_id: LayerId, transform: TSTransform) {
         self.memory_mut(|m| {
             if transform == TSTransform::IDENTITY {
@@ -2705,21 +2889,6 @@ impl Context {
             .map(|t| t.inverse())
     }
 
-    /// Move all the graphics at the given layer.
-    ///
-    /// Is used to implement drag-and-drop preview.
-    ///
-    /// This only applied to the existing graphics at the layer, not to new graphics added later.
-    ///
-    /// For a persistent transform, use [`Self::set_transform_layer`] instead.
-    #[deprecated = "Use `transform_layer_shapes` instead"]
-    pub fn translate_layer(&self, layer_id: LayerId, delta: Vec2) {
-        if delta != Vec2::ZERO {
-            let transform = emath::TSTransform::from_translation(delta);
-            self.transform_layer_shapes(layer_id, transform);
-        }
-    }
-
     /// Transform all the graphics at the given layer.
     ///
     /// Is used to implement drag-and-drop preview.
@@ -2957,36 +3126,54 @@ impl Context {
     pub fn inspection_ui(&self, ui: &mut Ui) {
         use crate::containers::CollapsingHeader;
 
-        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.focused())
-                .as_ref()
-                .map(Id::short_debug_format)
-                .unwrap_or_default()
-        ))
-        .on_hover_text("Is egui currently listening for text input?");
+        crate::Grid::new("egui-inspection-grid")
+            .num_columns(2)
+            .striped(true)
+            .show(ui, |ui| {
+                ui.label("Total ui frames:");
+                ui.monospace(ui.ctx().cumulative_frame_nr().to_string());
+                ui.end_row();
 
-        let pointer_pos = self
-            .pointer_hover_pos()
-            .map_or_else(String::new, |pos| format!("{pos:?}"));
-        ui.label(format!("Pointer pos: {pointer_pos}"));
+                ui.label("Total ui passes:");
+                ui.monospace(ui.ctx().cumulative_pass_nr().to_string());
+                ui.end_row();
 
-        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.label("Is using pointer")
+                    .on_hover_text("Is egui currently using the pointer actively (e.g. dragging a slider)?");
+                ui.monospace(self.is_using_pointer().to_string());
+                ui.end_row();
+
+                ui.label("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.monospace(self.wants_pointer_input().to_string());
+                ui.end_row();
+
+                ui.label("Wants keyboard input").on_hover_text("Is egui currently listening for text input?");
+                ui.monospace(self.wants_keyboard_input().to_string());
+                ui.end_row();
+
+                ui.label("Keyboard focus widget").on_hover_text("Is egui currently listening for text input?");
+                ui.monospace(self.memory(|m| m.focused())
+                    .as_ref()
+                    .map(Id::short_debug_format)
+                    .unwrap_or_default());
+                ui.end_row();
+
+                let pointer_pos = self
+                    .pointer_hover_pos()
+                    .map_or_else(String::new, |pos| format!("{pos:?}"));
+                ui.label("Pointer pos");
+                ui.monospace(pointer_pos);
+                ui.end_row();
+
+                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("Top layer under mouse");
+                ui.monospace(top_layer);
+                ui.end_row();
+            });
 
         ui.add_space(16.0);
 
@@ -3029,6 +3216,12 @@ impl Context {
                 self.texture_ui(ui);
             });
 
+        CollapsingHeader::new("🖼 Image loaders")
+            .default_open(false)
+            .show(ui, |ui| {
+                self.loaders_ui(ui);
+            });
+
         CollapsingHeader::new("🔠 Font texture")
             .default_open(false)
             .show(ui, |ui| {
@@ -3041,7 +3234,9 @@ impl Context {
             .show(ui, |ui| {
                 ui.label(format!(
                     "{:#?}",
-                    crate::text_selection::LabelSelectionState::load(ui.ctx())
+                    *ui.ctx()
+                        .plugin::<crate::text_selection::LabelSelectionState>()
+                        .lock()
                 ));
             });
 
@@ -3073,6 +3268,8 @@ impl Context {
         ));
         let max_preview_size = vec2(48.0, 32.0);
 
+        let pixels_per_point = self.pixels_per_point();
+
         ui.group(|ui| {
             ScrollArea::vertical()
                 .max_height(300.0)
@@ -3087,15 +3284,16 @@ impl Context {
                         .show(ui, |ui| {
                             for (&texture_id, meta) in textures {
                                 let [w, h] = meta.size;
+                                let point_size = vec2(w as f32, h as f32) / pixels_per_point;
 
-                                let mut size = vec2(w as f32, h as f32);
+                                let mut size = point_size;
                                 size *= (max_preview_size.x / size.x).min(1.0);
                                 size *= (max_preview_size.y / size.y).min(1.0);
                                 ui.image(SizedTexture::new(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);
+                                        let max_size = 0.5 * ui.ctx().content_rect().size();
+                                        let mut size = point_size;
                                         size *= max_size.x / size.x.max(max_size.x);
                                         size *= max_size.y / size.y.max(max_size.y);
                                         ui.image(SizedTexture::new(texture_id, size));
@@ -3111,6 +3309,73 @@ impl Context {
         });
     }
 
+    /// Show stats about different image loaders.
+    pub fn loaders_ui(&self, ui: &mut crate::Ui) {
+        struct LoaderInfo {
+            id: String,
+            byte_size: usize,
+        }
+
+        let mut byte_loaders = vec![];
+        let mut image_loaders = vec![];
+        let mut texture_loaders = vec![];
+
+        {
+            let loaders = self.loaders();
+            let Loaders {
+                include: _,
+                bytes,
+                image,
+                texture,
+            } = loaders.as_ref();
+
+            for loader in bytes.lock().iter() {
+                byte_loaders.push(LoaderInfo {
+                    id: loader.id().to_owned(),
+                    byte_size: loader.byte_size(),
+                });
+            }
+            for loader in image.lock().iter() {
+                image_loaders.push(LoaderInfo {
+                    id: loader.id().to_owned(),
+                    byte_size: loader.byte_size(),
+                });
+            }
+            for loader in texture.lock().iter() {
+                texture_loaders.push(LoaderInfo {
+                    id: loader.id().to_owned(),
+                    byte_size: loader.byte_size(),
+                });
+            }
+        }
+
+        fn loaders_ui(ui: &mut crate::Ui, title: &str, loaders: &[LoaderInfo]) {
+            let heading = format!("{} {title} loaders", loaders.len());
+            crate::CollapsingHeader::new(heading)
+                .default_open(true)
+                .show(ui, |ui| {
+                    Grid::new("loaders")
+                        .striped(true)
+                        .num_columns(2)
+                        .show(ui, |ui| {
+                            ui.label("ID");
+                            ui.label("Size");
+                            ui.end_row();
+
+                            for loader in loaders {
+                                ui.label(&loader.id);
+                                ui.label(format!("{:.3} MB", loader.byte_size as f64 * 1e-6));
+                                ui.end_row();
+                            }
+                        });
+                });
+        }
+
+        loaders_ui(ui, "byte", &byte_loaders);
+        loaders_ui(ui, "image", &image_loaders);
+        loaders_ui(ui, "texture", &texture_loaders);
+    }
+
     /// Shows the contents of [`Self::memory`].
     pub fn memory_ui(&self, ui: &mut crate::Ui) {
         if ui
@@ -3169,13 +3434,14 @@ impl Context {
             }
         });
 
+        #[expect(deprecated)]
         ui.horizontal(|ui| {
             ui.label(format!(
                 "{} menu bars",
-                self.data(|d| d.count::<menu::BarState>())
+                self.data(|d| d.count::<crate::menu::BarState>())
             ));
             if ui.button("Reset").clicked() {
-                self.data_mut(|d| d.remove_by_type::<menu::BarState>());
+                self.data_mut(|d| d.remove_by_type::<crate::menu::BarState>());
             }
         });
 
@@ -3220,45 +3486,15 @@ impl Context {
 
 /// ## 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.
-    #[allow(clippy::unused_self, clippy::let_and_return)]
-    #[inline]
-    pub fn with_accessibility_parent<R>(&self, _id: Id, f: impl FnOnce() -> R) -> R {
-        // TODO(emilk): this isn't thread-safe - another thread can call this function between the push/pop calls
-        #[cfg(feature = "accesskit")]
-        self.pass_state_mut(|fs| {
-            if let Some(state) = fs.accesskit_state.as_mut() {
-                state.parent_stack.push(_id);
-            }
-        });
-
-        let result = f();
-
-        #[cfg(feature = "accesskit")]
-        self.pass_state_mut(|fs| {
-            if let Some(state) = fs.accesskit_state.as_mut() {
-                assert_eq!(state.parent_stack.pop(), Some(_id));
-            }
-        });
-
-        result
-    }
-
     /// 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`].
+    /// For newly created nodes, the parent is the parent [`Ui`]s ID.
+    /// And an [`Ui`]s parent can be set with [`crate::UiBuilder::accessibility_parent`].
     ///
     /// The `Context` lock is held while the given closure is called!
     ///
-    /// Returns `None` if acesskit is off.
+    /// Returns `None` if accesskit is off.
     // TODO(emilk): consider making both read-only and read-write versions
-    #[cfg(feature = "accesskit")]
     pub fn accesskit_node_builder<R>(
         &self,
         id: Id,
@@ -3274,14 +3510,20 @@ impl Context {
         })
     }
 
+    pub(crate) fn register_accesskit_parent(&self, id: Id, parent_id: Id) {
+        self.write(|ctx| {
+            if let Some(state) = ctx.viewport().this_pass.accesskit_state.as_mut() {
+                state.parent_map.insert(id, parent_id);
+            }
+        });
+    }
+
     /// Enable generation of AccessKit tree updates in all future frames.
-    #[cfg(feature = "accesskit")]
     pub fn enable_accesskit(&self) {
         self.write(|ctx| ctx.is_accesskit_enabled = true);
     }
 
     /// Disable generation of AccessKit tree updates in all future frames.
-    #[cfg(feature = "accesskit")]
     pub fn disable_accesskit(&self) {
         self.write(|ctx| ctx.is_accesskit_enabled = false);
     }
@@ -3339,6 +3581,7 @@ impl Context {
     /// Release all memory and textures related to the given image URI.
     ///
     /// If you attempt to load the image again, it will be reloaded from scratch.
+    /// Also this cancels any ongoing loading of the image.
     pub fn forget_image(&self, uri: &str) {
         use load::BytesLoader as _;
 
@@ -3406,9 +3649,10 @@ impl Context {
 
         // Try most recently added loaders first (hence `.rev()`)
         for loader in bytes_loaders.iter().rev() {
-            match loader.load(self, uri) {
-                Err(load::LoadError::NotSupported) => continue,
-                result => return result,
+            let result = loader.load(self, uri);
+            match result {
+                Err(load::LoadError::NotSupported) => {}
+                _ => return result,
             }
         }
 
@@ -3449,10 +3693,9 @@ impl Context {
         // Try most recently added loaders first (hence `.rev()`)
         for loader in image_loaders.iter().rev() {
             match loader.load(self, uri, size_hint) {
-                Err(load::LoadError::NotSupported) => continue,
+                Err(load::LoadError::NotSupported) => {}
                 Err(load::LoadError::FormatNotSupported { detected_format }) => {
                     format = format.or(detected_format);
-                    continue;
                 }
                 result => return result,
             }
@@ -3495,7 +3738,7 @@ impl Context {
         // Try most recently added loaders first (hence `.rev()`)
         for loader in texture_loaders.iter().rev() {
             match loader.load(self, uri, texture_options, size_hint) {
-                Err(load::LoadError::NotSupported) => continue,
+                Err(load::LoadError::NotSupported) => {}
                 result => return result,
             }
         }
@@ -3507,6 +3750,14 @@ impl Context {
     pub fn loaders(&self) -> Arc<Loaders> {
         self.read(|this| this.loaders.clone())
     }
+
+    /// Returns `true` if any image is currently being loaded.
+    pub fn has_pending_images(&self) -> bool {
+        self.read(|this| {
+            this.loaders.image.lock().iter().any(|i| i.has_pending())
+                || this.loaders.bytes.lock().iter().any(|i| i.has_pending())
+        })
+    }
 }
 
 /// ## Viewports
@@ -3555,7 +3806,6 @@ impl Context {
     /// * Set the window attributes (position, size, …) based on [`ImmediateViewport::builder`].
     /// * Call [`Context::run`] with [`ImmediateViewport::viewport_ui_cb`].
     /// * Handle the output from [`Context::run`], including rendering
-    #[allow(clippy::unused_self)]
     pub fn set_immediate_viewport_renderer(
         callback: impl for<'a> Fn(&Self, ImmediateViewport<'a>) + 'static,
     ) {
diff --git a/crates/egui/src/data/input.rs b/crates/egui/src/data/input.rs
index 0bced4270..61f6ae00c 100644
--- a/crates/egui/src/data/input.rs
+++ b/crates/egui/src/data/input.rs
@@ -1,10 +1,10 @@
 //! The input needed by egui.
 
-use epaint::ColorImage;
+use epaint::{ColorImage, MarginF32};
 
 use crate::{
+    Key, OrderedViewportIdMap, Theme, ViewportId, ViewportIdMap,
     emath::{Pos2, Rect, Vec2},
-    Key, Theme, ViewportId, ViewportIdMap,
 };
 
 /// What the integrations provides to egui at the start of each frame.
@@ -27,6 +27,11 @@ pub struct RawInput {
     /// Information about all egui viewports.
     pub viewports: ViewportIdMap<ViewportInfo>,
 
+    /// The insets used to only render content in a mobile safe area
+    ///
+    /// `None` will be treated as "same as last frame"
+    pub safe_area_insets: Option<SafeAreaInsets>,
+
     /// Position and size of the area that egui should use, in points.
     /// Usually you would set this to
     ///
@@ -98,6 +103,7 @@ impl Default for RawInput {
             dropped_files: Default::default(),
             focused: true, // integrations opt into global focus tracking
             system_theme: None,
+            safe_area_insets: Default::default(),
         }
     }
 }
@@ -122,6 +128,7 @@ impl RawInput {
                 .map(|(id, info)| (*id, info.take()))
                 .collect(),
             screen_rect: self.screen_rect.take(),
+            safe_area_insets: self.safe_area_insets.take(),
             max_texture_side: self.max_texture_side.take(),
             time: self.time,
             predicted_dt: self.predicted_dt,
@@ -149,6 +156,7 @@ impl RawInput {
             mut dropped_files,
             focused,
             system_theme,
+            safe_area_insets: safe_area,
         } = newer;
 
         self.viewport_id = viewport_ids;
@@ -163,6 +171,7 @@ impl RawInput {
         self.dropped_files.append(&mut dropped_files);
         self.focused = focused;
         self.system_theme = system_theme;
+        self.safe_area_insets = safe_area;
     }
 }
 
@@ -214,11 +223,21 @@ pub struct ViewportInfo {
     /// The inner rectangle of the native window, in monitor space and ui points scale.
     ///
     /// This is the content rectangle of the viewport.
+    ///
+    /// **`eframe` notes**:
+    ///
+    /// On Android / Wayland, this will always be `None` since getting the
+    /// position of the window is not possible.
     pub inner_rect: Option<Rect>,
 
     /// The outer rectangle of the native window, in monitor space and ui points scale.
     ///
     /// This is the content rectangle plus decoration chrome.
+    ///
+    /// **`eframe` notes**:
+    ///
+    /// On Android / Wayland, this will always be `None` since getting the
+    /// position of the window is not possible.
     pub outer_rect: Option<Rect>,
 
     /// Are we minimized?
@@ -246,9 +265,7 @@ impl ViewportInfo {
     /// If this is not the root viewport,
     /// it is up to the user to hide this viewport the next frame.
     pub fn close_requested(&self) -> bool {
-        self.events
-            .iter()
-            .any(|&event| event == ViewportEvent::Close)
+        self.events.contains(&ViewportEvent::Close)
     }
 
     /// Helper: move [`Self::events`], clone the other fields.
@@ -471,6 +488,9 @@ pub enum Event {
     /// As a user, check [`crate::InputState::smooth_scroll_delta`] to see if the user did any zooming this frame.
     Zoom(f32),
 
+    /// Rotation in radians this frame, measuring clockwise (e.g. from a rotation gesture).
+    Rotate(f32),
+
     /// IME Event
     Ime(ImeEvent),
 
@@ -515,6 +535,11 @@ pub enum Event {
         /// as when swiping down on a touch-screen or track-pad with natural scrolling.
         delta: Vec2,
 
+        /// The phase of the scroll, useful for trackpads.
+        ///
+        /// If unknown set this to [`TouchPhase::Move`].
+        phase: TouchPhase,
+
         /// The state of the modifier keys at the time of the event.
         modifiers: Modifiers,
     },
@@ -523,7 +548,6 @@ pub enum Event {
     WindowFocused(bool),
 
     /// An assistive technology (e.g. screen reader) requested an action.
-    #[cfg(feature = "accesskit")]
     AccessKitActionRequest(accesskit::ActionRequest),
 
     /// The reply of a screenshot requested with [`crate::ViewportCommand::Screenshot`].
@@ -582,7 +606,7 @@ 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`].
+/// The best way to compare [`Modifiers`] is by using [`Modifiers::matches_logically`] or [`Modifiers::matches_exact`].
 ///
 /// NOTE: For cross-platform uses, ALT+SHIFT is a bad combination of modifiers
 /// as on mac that is how you type special characters,
@@ -765,8 +789,8 @@ impl Modifiers {
     /// ```
     /// # use egui::Modifiers;
     /// # let pressed_modifiers = Modifiers::default();
-    /// if pressed_modifiers.matches(Modifiers::ALT | Modifiers::SHIFT) {
-    ///     // Alt and Shift are pressed, and nothing else
+    /// if pressed_modifiers.matches_logically(Modifiers::ALT | Modifiers::SHIFT) {
+    ///     // Alt and Shift are pressed, but not ctrl/command
     /// }
     /// ```
     ///
@@ -807,7 +831,7 @@ impl Modifiers {
     /// ```
     /// # use egui::Modifiers;
     /// # let pressed_modifiers = Modifiers::default();
-    /// if pressed_modifiers.matches(Modifiers::ALT | Modifiers::SHIFT) {
+    /// if pressed_modifiers.matches_exact(Modifiers::ALT | Modifiers::SHIFT) {
     ///     // Alt and Shift are pressed, and nothing else
     /// }
     /// ```
@@ -815,13 +839,13 @@ impl Modifiers {
     /// ## Behavior:
     /// ```
     /// # 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));
+    /// assert!(Modifiers::CTRL.matches_exact(Modifiers::CTRL));
+    /// assert!(!Modifiers::CTRL.matches_exact(Modifiers::CTRL | Modifiers::SHIFT));
+    /// assert!(!(Modifiers::CTRL | Modifiers::SHIFT).matches_exact(Modifiers::CTRL));
+    /// assert!((Modifiers::CTRL | Modifiers::COMMAND).matches_exact(Modifiers::CTRL));
+    /// assert!((Modifiers::CTRL | Modifiers::COMMAND).matches_exact(Modifiers::COMMAND));
+    /// assert!((Modifiers::MAC_CMD | Modifiers::COMMAND).matches_exact(Modifiers::COMMAND));
+    /// assert!(!Modifiers::COMMAND.matches_exact(Modifiers::MAC_CMD));
     /// ```
     pub fn matches_exact(&self, pattern: Self) -> bool {
         // alt and shift must always match the pattern:
@@ -832,9 +856,35 @@ impl Modifiers {
         self.cmd_ctrl_matches(pattern)
     }
 
-    #[deprecated = "Renamed `matches_exact`, but maybe you want to use `matches_logically` instead"]
-    pub fn matches(&self, pattern: Self) -> bool {
-        self.matches_exact(pattern)
+    /// Check if any of the modifiers match exactly.
+    ///
+    /// Returns true if the same modifier is pressed in `self` as in `pattern`,
+    /// for at least one modifier.
+    ///
+    /// ## Behavior:
+    /// ```
+    /// # use egui::Modifiers;
+    /// assert!(Modifiers::CTRL.matches_any(Modifiers::CTRL));
+    /// assert!(Modifiers::CTRL.matches_any(Modifiers::CTRL | Modifiers::SHIFT));
+    /// assert!((Modifiers::CTRL | Modifiers::SHIFT).matches_any(Modifiers::CTRL));
+    /// ```
+    pub fn matches_any(&self, pattern: Self) -> bool {
+        if self.alt && pattern.alt {
+            return true;
+        }
+        if self.shift && pattern.shift {
+            return true;
+        }
+        if self.ctrl && pattern.ctrl {
+            return true;
+        }
+        if self.mac_cmd && pattern.mac_cmd {
+            return true;
+        }
+        if (self.mac_cmd || self.command || self.ctrl) && pattern.command {
+            return true;
+        }
+        false
     }
 
     /// Checks only cmd/ctrl, not alt/shift.
@@ -943,6 +993,19 @@ impl std::ops::BitOr for Modifiers {
     }
 }
 
+impl std::ops::BitOrAssign for Modifiers {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
+}
+
+impl Modifiers {
+    pub fn ui(&self, ui: &mut crate::Ui) {
+        ui.label(ModifierNames::NAMES.format(self, ui.ctx().os().is_mac()));
+    }
+}
+
 // ----------------------------------------------------------------------------
 
 /// Names of different modifier keys.
@@ -1082,10 +1145,15 @@ impl RawInput {
             dropped_files,
             focused,
             system_theme,
+            safe_area_insets: safe_area,
         } = self;
 
-        ui.label(format!("Active viwport: {viewport_id:?}"));
-        for (id, viewport) in viewports {
+        ui.label(format!("Active viewport: {viewport_id:?}"));
+        let ordered_viewports = viewports
+            .iter()
+            .map(|(id, value)| (*id, value))
+            .collect::<OrderedViewportIdMap<_>>();
+        for (id, viewport) in ordered_viewports {
             ui.group(|ui| {
                 ui.label(format!("Viewport {id:?}"));
                 ui.push_id(id, |ui| {
@@ -1107,6 +1175,7 @@ impl RawInput {
         ui.label(format!("dropped_files: {}", dropped_files.len()));
         ui.label(format!("focused: {focused}"));
         ui.label(format!("system_theme: {system_theme:?}"));
+        ui.label(format!("safe_area: {safe_area:?}"));
         ui.scope(|ui| {
             ui.set_min_height(150.0);
             ui.label(format!("events: {events:#?}"))
@@ -1216,7 +1285,7 @@ pub struct EventFilter {
     pub escape: bool,
 }
 
-#[allow(clippy::derivable_impls)] // let's be explicit
+#[expect(clippy::derivable_impls)] // let's be explicit
 impl Default for EventFilter {
     fn default() -> Self {
         Self {
@@ -1243,3 +1312,19 @@ impl EventFilter {
         }
     }
 }
+
+/// The 'safe area' insets of the screen
+///
+/// This represents the area taken up by the status bar, navigation controls, notches,
+/// or any other items that obscure parts of the screen.
+#[derive(Debug, PartialEq, Copy, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct SafeAreaInsets(pub MarginF32);
+
+impl std::ops::Sub<SafeAreaInsets> for Rect {
+    type Output = Self;
+
+    fn sub(self, rhs: SafeAreaInsets) -> Self::Output {
+        self - rhs.0
+    }
+}
diff --git a/crates/egui/src/data/key.rs b/crates/egui/src/data/key.rs
index 602ec5bda..2a0f33fc3 100644
--- a/crates/egui/src/data/key.rs
+++ b/crates/egui/src/data/key.rs
@@ -183,6 +183,11 @@ pub enum Key {
     F33,
     F34,
     F35,
+
+    /// Back navigation key from multimedia keyboard.
+    /// Android sends this key on Back button press.
+    /// Does not work on Web.
+    BrowserBack,
     // When adding keys, remember to also update:
     // * crates/egui-winit/src/lib.rs
     // * Key::ALL
@@ -307,6 +312,8 @@ impl Key {
         Self::F33,
         Self::F34,
         Self::F35,
+        // Navigation keys:
+        Self::BrowserBack,
     ];
 
     /// Converts `"A"` to `Key::A`, `Space` to `Key::Space`, etc.
@@ -435,6 +442,8 @@ impl Key {
             "F34" => Self::F34,
             "F35" => Self::F35,
 
+            "BrowserBack" => Self::BrowserBack,
+
             _ => return None,
         })
     }
@@ -588,6 +597,8 @@ impl Key {
             Self::F33 => "F33",
             Self::F34 => "F34",
             Self::F35 => "F35",
+
+            Self::BrowserBack => "BrowserBack",
         }
     }
 }
@@ -596,7 +607,7 @@ impl Key {
 fn test_key_from_name() {
     assert_eq!(
         Key::ALL.len(),
-        Key::F35 as usize + 1,
+        Key::BrowserBack as usize + 1,
         "Some keys are missing in Key::ALL"
     );
 
diff --git a/crates/egui/src/data/output.rs b/crates/egui/src/data/output.rs
index e1f9086a2..2c6edba84 100644
--- a/crates/egui/src/data/output.rs
+++ b/crates/egui/src/data/output.rs
@@ -1,6 +1,6 @@
 //! All the data egui returns to the backend at the end of each frame.
 
-use crate::{RepaintCause, ViewportIdMap, ViewportOutput, WidgetType};
+use crate::{OrderedViewportIdMap, RepaintCause, ViewportOutput, WidgetType};
 
 /// What egui emits each frame from [`crate::Context::run`].
 ///
@@ -32,12 +32,14 @@ pub struct FullOutput {
     ///
     /// It is up to the integration to spawn a native window for each viewport,
     /// and to close any window that no longer has a viewport in this map.
-    pub viewport_output: ViewportIdMap<ViewportOutput>,
+    pub viewport_output: OrderedViewportIdMap<ViewportOutput>,
 }
 
 impl FullOutput {
     /// Add on new output.
     pub fn append(&mut self, newer: Self) {
+        use std::collections::btree_map::Entry;
+
         let Self {
             platform_output,
             textures_delta,
@@ -53,10 +55,10 @@ impl FullOutput {
 
         for (id, new_viewport) in viewport_output {
             match self.viewport_output.entry(id) {
-                std::collections::hash_map::Entry::Vacant(entry) => {
+                Entry::Vacant(entry) => {
                     entry.insert(new_viewport);
                 }
-                std::collections::hash_map::Entry::Occupied(mut entry) => {
+                Entry::Occupied(mut entry) => {
                     entry.get_mut().append(new_viewport);
                 }
             }
@@ -111,24 +113,6 @@ pub struct PlatformOutput {
     /// Set the cursor to this icon.
     pub cursor_icon: CursorIcon,
 
-    /// If set, open this url.
-    #[deprecated = "Use `Context::open_url` or `PlatformOutput::commands` instead"]
-    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());
-    /// }
-    /// # });
-    /// ```
-    #[deprecated = "Use `Context::copy_text` or `PlatformOutput::commands` instead"]
-    pub copied_text: String,
-
     /// Events that may be useful to e.g. a screen reader.
     pub events: Vec<OutputEvent>,
 
@@ -144,7 +128,6 @@ pub struct PlatformOutput {
     /// The difference in the widget tree since last frame.
     ///
     /// NOTE: this needs to be per-viewport.
-    #[cfg(feature = "accesskit")]
     pub accesskit_update: Option<accesskit::TreeUpdate>,
 
     /// How many ui passes is this the sum of?
@@ -185,17 +168,12 @@ impl PlatformOutput {
 
     /// Add on new output.
     pub fn append(&mut self, newer: Self) {
-        #![allow(deprecated)]
-
         let Self {
             mut commands,
             cursor_icon,
-            open_url,
-            copied_text,
             mut events,
             mutable_text_under_cursor,
             ime,
-            #[cfg(feature = "accesskit")]
             accesskit_update,
             num_completed_passes,
             mut request_discard_reasons,
@@ -203,12 +181,6 @@ impl PlatformOutput {
 
         self.commands.append(&mut commands);
         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.ime = ime.or(self.ime);
@@ -216,12 +188,8 @@ impl PlatformOutput {
         self.request_discard_reasons
             .append(&mut request_discard_reasons);
 
-        #[cfg(feature = "accesskit")]
-        {
-            // egui produces a complete AccessKit tree for each frame,
-            // so overwrite rather than appending.
-            self.accesskit_update = accesskit_update;
-        }
+        // egui produces a complete AccessKit tree for each frame, so overwrite rather than append:
+        self.accesskit_update = accesskit_update;
     }
 
     /// Take everything ephemeral (everything except `cursor_icon` currently)
@@ -252,7 +220,7 @@ pub struct OpenUrl {
 }
 
 impl OpenUrl {
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn same_tab(url: impl ToString) -> Self {
         Self {
             url: url.to_string(),
@@ -260,7 +228,7 @@ impl OpenUrl {
         }
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn new_tab(url: impl ToString) -> Self {
         Self {
             url: url.to_string(),
@@ -292,10 +260,11 @@ pub enum UserAttentionType {
 /// 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)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum CursorIcon {
     /// Normal cursor icon, whatever that is.
+    #[default]
     Default,
 
     /// Show no cursor
@@ -455,12 +424,6 @@ impl CursorIcon {
     ];
 }
 
-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 accessibility, i.e. for screen readers.
@@ -539,6 +502,9 @@ pub struct WidgetInfo {
 
     /// Selected range of characters in [`Self::current_text_value`].
     pub text_selection: Option<std::ops::RangeInclusive<usize>>,
+
+    /// The hint text for text edit fields.
+    pub hint_text: Option<String>,
 }
 
 impl std::fmt::Debug for WidgetInfo {
@@ -552,6 +518,7 @@ impl std::fmt::Debug for WidgetInfo {
             selected,
             value,
             text_selection,
+            hint_text,
         } = self;
 
         let mut s = f.debug_struct("WidgetInfo");
@@ -580,6 +547,9 @@ impl std::fmt::Debug for WidgetInfo {
         if let Some(text_selection) = text_selection {
             s.field("text_selection", text_selection);
         }
+        if let Some(hint_text) = hint_text {
+            s.field("hint_text", hint_text);
+        }
 
         s.finish()
     }
@@ -596,10 +566,11 @@ impl WidgetInfo {
             selected: None,
             value: None,
             text_selection: None,
+            hint_text: None,
         }
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn labeled(typ: WidgetType, enabled: bool, label: impl ToString) -> Self {
         Self {
             enabled,
@@ -609,7 +580,7 @@ impl WidgetInfo {
     }
 
     /// checkboxes, radio-buttons etc
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn selected(typ: WidgetType, enabled: bool, selected: bool, label: impl ToString) -> Self {
         Self {
             enabled,
@@ -627,7 +598,7 @@ impl WidgetInfo {
         }
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn slider(enabled: bool, value: f64, label: impl ToString) -> Self {
         let label = label.to_string();
         Self {
@@ -638,14 +609,16 @@ impl WidgetInfo {
         }
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn text_edit(
         enabled: bool,
         prev_text_value: impl ToString,
         text_value: impl ToString,
+        hint_text: impl ToString,
     ) -> Self {
         let text_value = text_value.to_string();
         let prev_text_value = prev_text_value.to_string();
+        let hint_text = hint_text.to_string();
         let prev_text_value = if text_value == prev_text_value {
             None
         } else {
@@ -655,11 +628,12 @@ impl WidgetInfo {
             enabled,
             current_text_value: Some(text_value),
             prev_text_value,
+            hint_text: Some(hint_text),
             ..Self::new(WidgetType::TextEdit)
         }
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn text_selection_changed(
         enabled: bool,
         text_selection: std::ops::RangeInclusive<usize>,
@@ -684,6 +658,7 @@ impl WidgetInfo {
             selected,
             value,
             text_selection: _,
+            hint_text: _,
         } = self;
 
         // TODO(emilk): localization
@@ -699,9 +674,9 @@ impl WidgetInfo {
             WidgetType::Slider => "slider",
             WidgetType::DragValue => "drag value",
             WidgetType::ColorButton => "color button",
-            WidgetType::ImageButton => "image button",
             WidgetType::Image => "image",
             WidgetType::CollapsingHeader => "collapsing header",
+            WidgetType::Panel => "panel",
             WidgetType::ProgressIndicator => "progress indicator",
             WidgetType::Window => "window",
             WidgetType::Label | WidgetType::Other => "",
@@ -715,7 +690,7 @@ impl WidgetInfo {
                 description = format!("{state} {description}");
             } else {
                 description += if *selected { "selected" } else { "" };
-            };
+            }
         }
 
         if let Some(label) = label {
@@ -727,7 +702,7 @@ impl WidgetInfo {
                 if text_value.is_empty() {
                     "blank".into()
                 } else {
-                    text_value.to_string()
+                    text_value.clone()
                 }
             } else {
                 "blank".into()
diff --git a/crates/egui/src/debug_text.rs b/crates/egui/src/debug_text.rs
index bb9487bd3..cabde8c62 100644
--- a/crates/egui/src/debug_text.rs
+++ b/crates/egui/src/debug_text.rs
@@ -1,24 +1,14 @@
 //! This is an example of how to create a plugin for egui.
 //!
-//! A plugin usually consist of a struct that holds some state,
-//! which is stored using [`Context::data_mut`].
-//! The plugin registers itself onto a specific [`Context`]
-//! to get callbacks on certain events ([`Context::on_begin_pass`], [`Context::on_end_pass`]).
+//! A plugin is a struct that implements the [`Plugin`] trait and holds some state.
+//! The plugin is registered with the [`Context`] using [`Context::add_plugin`]
+//! to get callbacks on certain events ([`Plugin::on_begin_pass`], [`Plugin::on_end_pass`]).
 
 use crate::{
-    text, Align, Align2, Color32, Context, FontFamily, FontId, Id, Rect, Shape, Vec2, WidgetText,
+    Align, Align2, Color32, Context, FontFamily, FontId, Plugin, Rect, Shape, Vec2, WidgetText,
+    text,
 };
 
-/// Register this plugin on the given egui context,
-/// so that it will be called every pass.
-///
-/// This is a built-in plugin in egui,
-/// meaning [`Context`] calls this from its `Default` implementation,
-/// so this is marked as `pub(crate)`.
-pub(crate) fn register(ctx: &Context) {
-    ctx.on_end_pass("debug_text", std::sync::Arc::new(State::end_pass));
-}
-
 /// Print this text next to the cursor at the end of the pass.
 ///
 /// If you call this multiple times, the text will be appended.
@@ -38,15 +28,12 @@ pub fn print(ctx: &Context, text: impl Into<WidgetText>) {
 
     let location = std::panic::Location::caller();
     let location = format!("{}:{}", location.file(), location.line());
-    ctx.data_mut(|data| {
-        // We use `Id::NULL` as the id, since we only have one instance of this plugin.
-        // We use the `temp` version instead of `persisted` since we don't want to
-        // persist state on disk when the egui app is closed.
-        let state = data.get_temp_mut_or_default::<State>(Id::NULL);
-        state.entries.push(Entry {
-            location,
-            text: text.into(),
-        });
+
+    let plugin = ctx.plugin::<DebugTextPlugin>();
+    let mut state = plugin.lock();
+    state.entries.push(Entry {
+        location,
+        text: text.into(),
     });
 }
 
@@ -58,24 +45,26 @@ struct Entry {
 
 /// A plugin for easily showing debug-text on-screen.
 ///
-/// This is a built-in plugin in egui.
+/// This is a built-in plugin in egui, automatically registered during [`Context`] creation.
 #[derive(Clone, Default)]
-struct State {
+pub struct DebugTextPlugin {
     // This gets re-filled every pass.
     entries: Vec<Entry>,
 }
 
-impl State {
-    fn end_pass(ctx: &Context) {
-        let state = ctx.data_mut(|data| data.remove_temp::<Self>(Id::NULL));
-        if let Some(state) = state {
-            state.paint(ctx);
-        }
+impl Plugin for DebugTextPlugin {
+    fn debug_name(&self) -> &'static str {
+        "DebugTextPlugin"
     }
 
-    fn paint(self, ctx: &Context) {
-        let Self { entries } = self;
+    fn on_end_pass(&mut self, ctx: &Context) {
+        let entries = std::mem::take(&mut self.entries);
+        Self::paint_entries(ctx, entries);
+    }
+}
 
+impl DebugTextPlugin {
+    fn paint_entries(ctx: &Context, entries: Vec<Entry>) {
         if entries.is_empty() {
             return;
         }
@@ -83,7 +72,7 @@ impl State {
         // Show debug-text next to the cursor.
         let mut pos = ctx
             .input(|i| i.pointer.latest_pos())
-            .unwrap_or_else(|| ctx.screen_rect().center())
+            .unwrap_or_else(|| ctx.content_rect().center())
             + 8.0 * Vec2::Y;
 
         let painter = ctx.debug_painter();
@@ -98,16 +87,16 @@ impl State {
             {
                 // Paint location to left of `pos`:
                 let location_galley =
-                    ctx.fonts(|f| f.layout(location, font_id.clone(), color, f32::INFINITY));
+                    ctx.fonts_mut(|f| f.layout(location, font_id.clone(), color, f32::INFINITY));
                 let location_rect =
                     Align2::RIGHT_TOP.anchor_size(pos - 4.0 * Vec2::X, location_galley.size());
                 painter.galley(location_rect.min, location_galley, color);
-                bounding_rect = bounding_rect.union(location_rect);
+                bounding_rect |= location_rect;
             }
 
             {
                 // Paint `text` to right of `pos`:
-                let available_width = ctx.screen_rect().max.x - pos.x;
+                let available_width = ctx.content_rect().max.x - pos.x;
                 let galley = text.into_galley_impl(
                     ctx,
                     &ctx.style(),
@@ -117,7 +106,7 @@ impl State {
                 );
                 let rect = Align2::LEFT_TOP.anchor_size(pos, galley.size());
                 painter.galley(rect.min, galley, color);
-                bounding_rect = bounding_rect.union(rect);
+                bounding_rect |= rect;
             }
 
             pos.y = bounding_rect.max.y + 4.0;
diff --git a/crates/egui/src/drag_and_drop.rs b/crates/egui/src/drag_and_drop.rs
index 7f0c01b71..21468ed46 100644
--- a/crates/egui/src/drag_and_drop.rs
+++ b/crates/egui/src/drag_and_drop.rs
@@ -1,44 +1,46 @@
 use std::{any::Any, sync::Arc};
 
-use crate::{Context, CursorIcon, Id};
+use crate::{Context, CursorIcon, Plugin};
 
-/// Tracking of drag-and-drop payload.
+/// Plugin for tracking drag-and-drop payload.
 ///
-/// This is a low-level API.
+/// This plugin stores the current drag-and-drop payload internally and handles
+/// automatic cleanup when the drag operation ends (via Escape key or mouse release).
 ///
-/// For a higher-level API, see:
+/// This is a low-level API. For a higher-level API, see:
 /// - [`crate::Ui::dnd_drag_source`]
 /// - [`crate::Ui::dnd_drop_zone`]
 /// - [`crate::Response::dnd_set_drag_payload`]
 /// - [`crate::Response::dnd_hover_payload`]
 /// - [`crate::Response::dnd_release_payload`]
 ///
-/// See [this example](https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/demo/drag_and_drop.rs).
+/// This is a built-in plugin in egui, automatically registered during [`Context`] creation.
+///
+/// See [this example](https://github.com/emilk/egui/blob/main/crates/egui_demo_lib/src/demo/drag_and_drop.rs).
 #[doc(alias = "drag and drop")]
 #[derive(Clone, Default)]
 pub struct DragAndDrop {
-    /// If set, something is currently being dragged
+    /// The current drag-and-drop payload, if any. Automatically cleared when drag ends.
     payload: Option<Arc<dyn Any + Send + Sync>>,
 }
 
-impl DragAndDrop {
-    pub(crate) fn register(ctx: &Context) {
-        ctx.on_begin_pass("drag_and_drop_begin_pass", Arc::new(Self::begin_pass));
-        ctx.on_end_pass("drag_and_drop_end_pass", Arc::new(Self::end_pass));
+impl Plugin for DragAndDrop {
+    fn debug_name(&self) -> &'static str {
+        "DragAndDrop"
     }
 
     /// Interrupt drag-and-drop if the user presses the escape key.
     ///
     /// This needs to happen at frame start so we can properly capture the escape key.
-    fn begin_pass(ctx: &Context) {
-        let has_any_payload = Self::has_any_payload(ctx);
+    fn on_begin_pass(&mut self, ctx: &Context) {
+        let has_any_payload = self.payload.is_some();
 
         if has_any_payload {
             let abort_dnd_due_to_escape_key =
                 ctx.input_mut(|i| i.consume_key(crate::Modifiers::NONE, crate::Key::Escape));
 
             if abort_dnd_due_to_escape_key {
-                Self::clear_payload(ctx);
+                self.payload = None;
             }
         }
     }
@@ -48,14 +50,14 @@ impl DragAndDrop {
     /// This is a catch-all safety net in case user code doesn't capture the drag payload itself.
     /// This must happen at end-of-frame such that we don't shadow the mouse release event from user
     /// code.
-    fn end_pass(ctx: &Context) {
-        let has_any_payload = Self::has_any_payload(ctx);
+    fn on_end_pass(&mut self, ctx: &Context) {
+        let has_any_payload = self.payload.is_some();
 
         if has_any_payload {
             let abort_dnd_due_to_mouse_release = ctx.input_mut(|i| i.pointer.any_released());
 
             if abort_dnd_due_to_mouse_release {
-                Self::clear_payload(ctx);
+                self.payload = None;
             } else {
                 // We set the cursor icon only if its default, as the user code might have
                 // explicitly set it already.
@@ -67,7 +69,9 @@ impl DragAndDrop {
             }
         }
     }
+}
 
+impl DragAndDrop {
     /// Set a drag-and-drop payload.
     ///
     /// This can be read by [`Self::payload`] until the pointer is released.
@@ -75,18 +79,12 @@ impl DragAndDrop {
     where
         Payload: Any + Send + Sync,
     {
-        ctx.data_mut(|data| {
-            let state = data.get_temp_mut_or_default::<Self>(Id::NULL);
-            state.payload = Some(Arc::new(payload));
-        });
+        ctx.plugin::<Self>().lock().payload = Some(Arc::new(payload));
     }
 
     /// Clears the payload, setting it to `None`.
     pub fn clear_payload(ctx: &Context) {
-        ctx.data_mut(|data| {
-            let state = data.get_temp_mut_or_default::<Self>(Id::NULL);
-            state.payload = None;
-        });
+        ctx.plugin::<Self>().lock().payload = None;
     }
 
     /// Retrieve the payload, if any.
@@ -99,11 +97,13 @@ impl DragAndDrop {
     where
         Payload: Any + Send + Sync,
     {
-        ctx.data(|data| {
-            let state = data.get_temp::<Self>(Id::NULL)?;
-            let payload = state.payload?;
-            payload.downcast().ok()
-        })
+        ctx.plugin::<Self>()
+            .lock()
+            .payload
+            .as_ref()?
+            .clone()
+            .downcast()
+            .ok()
     }
 
     /// Retrieve and clear the payload, if any.
@@ -116,11 +116,7 @@ impl DragAndDrop {
     where
         Payload: Any + Send + Sync,
     {
-        ctx.data_mut(|data| {
-            let state = data.get_temp_mut_or_default::<Self>(Id::NULL);
-            let payload = state.payload.take()?;
-            payload.downcast().ok()
-        })
+        ctx.plugin::<Self>().lock().payload.take()?.downcast().ok()
     }
 
     /// Are we carrying a payload of the given type?
@@ -139,9 +135,6 @@ impl DragAndDrop {
     /// Returns `true` both during a drag and on the frame the pointer is released
     /// (if there is a payload).
     pub fn has_any_payload(ctx: &Context) -> bool {
-        ctx.data(|data| {
-            let state = data.get_temp::<Self>(Id::NULL);
-            state.is_some_and(|state| state.payload.is_some())
-        })
+        ctx.plugin::<Self>().lock().payload.is_some()
     }
 }
diff --git a/crates/egui/src/grid.rs b/crates/egui/src/grid.rs
index 1e341432c..31f9e7a71 100644
--- a/crates/egui/src/grid.rs
+++ b/crates/egui/src/grid.rs
@@ -1,8 +1,8 @@
 use emath::GuiRounding as _;
 
 use crate::{
-    vec2, Align2, Color32, Context, Id, InnerResponse, NumExt, Painter, Rect, Region, Style, Ui,
-    UiBuilder, Vec2,
+    Align2, Color32, Context, Id, InnerResponse, NumExt as _, Painter, Rect, Region, Style, Ui,
+    UiBuilder, Vec2, vec2,
 };
 
 #[cfg(debug_assertions)]
@@ -184,7 +184,7 @@ impl GridLayout {
         Rect::from_min_size(cursor.min, size).round_ui()
     }
 
-    #[allow(clippy::unused_self)]
+    #[expect(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
@@ -456,7 +456,7 @@ impl Grid {
             ui_builder = ui_builder.sizing_pass().invisible();
         }
 
-        ui.allocate_new_ui(ui_builder, |ui| {
+        ui.scope_builder(ui_builder, |ui| {
             ui.horizontal(|ui| {
                 let is_color = color_picker.is_some();
                 let grid = GridLayout {
diff --git a/crates/egui/src/gui_zoom.rs b/crates/egui/src/gui_zoom.rs
index 4e67d1a14..4242d927b 100644
--- a/crates/egui/src/gui_zoom.rs
+++ b/crates/egui/src/gui_zoom.rs
@@ -1,4 +1,4 @@
-//! Helpers for zooming the whole GUI of an app (changing [`Context::pixels_per_point`].
+//! Helpers for zooming the whole GUI of an app (changing [`Context::pixels_per_point`]).
 //!
 use crate::{Button, Context, Key, KeyboardShortcut, Modifiers, Ui};
 
@@ -88,7 +88,6 @@ pub fn zoom_menu_buttons(ui: &mut Ui) {
         .clicked()
     {
         zoom_in(ui.ctx());
-        ui.close_menu();
     }
 
     if ui
@@ -99,7 +98,6 @@ pub fn zoom_menu_buttons(ui: &mut Ui) {
         .clicked()
     {
         zoom_out(ui.ctx());
-        ui.close_menu();
     }
 
     if ui
@@ -110,6 +108,5 @@ pub fn zoom_menu_buttons(ui: &mut Ui) {
         .clicked()
     {
         ui.ctx().set_zoom_factor(1.0);
-        ui.close_menu();
     }
 }
diff --git a/crates/egui/src/hit_test.rs b/crates/egui/src/hit_test.rs
index 910e558b9..954ff5d71 100644
--- a/crates/egui/src/hit_test.rs
+++ b/crates/egui/src/hit_test.rs
@@ -2,7 +2,7 @@ use ahash::HashMap;
 
 use emath::TSTransform;
 
-use crate::{ahash, emath, id::IdSet, LayerId, Pos2, Rect, Sense, WidgetRect, WidgetRects};
+use crate::{LayerId, Pos2, Rect, Sense, WidgetRect, WidgetRects, ahash, emath, id::IdSet};
 
 /// Result of a hit-test against [`WidgetRects`].
 ///
@@ -65,7 +65,7 @@ pub fn hit_test(
         .filter(|layer| layer.order.allow_interaction())
         .flat_map(|&layer_id| widgets.get_layer(layer_id))
         .filter(|&w| {
-            if w.interact_rect.is_negative() {
+            if w.interact_rect.is_negative() || w.interact_rect.any_nan() {
                 return false;
             }
 
@@ -91,6 +91,8 @@ pub fn hit_test(
         }
     }
 
+    close.retain(|rect| !rect.interact_rect.any_nan()); // Protect against bad input and transforms
+
     // When using layer transforms it is common to stack layers close to each other.
     // For instance, you may have a resize-separator on a panel, with two
     // transform-layers on either side.
@@ -175,11 +177,17 @@ pub fn hit_test(
             restore_widget_rect(wr);
         }
         if let Some(wr) = &mut hits.drag {
-            debug_assert!(wr.sense.senses_drag());
+            debug_assert!(
+                wr.sense.senses_drag(),
+                "We should only return drag hits if they sense drag"
+            );
             restore_widget_rect(wr);
         }
         if let Some(wr) = &mut hits.click {
-            debug_assert!(wr.sense.senses_click());
+            debug_assert!(
+                wr.sense.senses_click(),
+                "We should only return click hits if they sense click"
+            );
             restore_widget_rect(wr);
         }
     }
@@ -309,19 +317,18 @@ fn hit_test_on_close(close: &[WidgetRect], pos: Pos2) -> WidgetHits {
                     pos,
                 );
 
-                if let Some(closest_drag) = closest_drag {
-                    if hit_drag
+                if let Some(closest_drag) = closest_drag
+                    && hit_drag
                         .interact_rect
                         .contains_rect(closest_drag.interact_rect)
-                    {
-                        // `hit_drag` is a big background thing and `closest_drag` is something small on top of it.
-                        // Be helpful and return the small things:
-                        return WidgetHits {
-                            click: None,
-                            drag: Some(closest_drag),
-                            ..Default::default()
-                        };
-                    }
+                {
+                    // `hit_drag` is a big background thing and `closest_drag` is something small on top of it.
+                    // Be helpful and return the small things:
+                    return WidgetHits {
+                        click: None,
+                        drag: Some(closest_drag),
+                        ..Default::default()
+                    };
                 }
 
                 WidgetHits {
@@ -417,13 +424,13 @@ fn find_closest_within(
 
         let dist_sq = widget.interact_rect.distance_sq_to_pos(pos);
 
-        if let Some(closest) = closest {
-            if dist_sq == closest_dist_sq {
-                // It's a tie! Pick the thin candidate over the thick one.
-                // This makes it easier to hit a thin resize-handle, for instance:
-                if should_prioritize_hits_on_back(closest.interact_rect, widget.interact_rect) {
-                    continue;
-                }
+        if let Some(closest) = closest
+            && dist_sq == closest_dist_sq
+        {
+            // It's a tie! Pick the thin candidate over the thick one.
+            // This makes it easier to hit a thin resize-handle, for instance:
+            if should_prioritize_hits_on_back(closest.interact_rect, widget.interact_rect) {
+                continue;
             }
         }
 
@@ -460,7 +467,9 @@ fn should_prioritize_hits_on_back(back: Rect, front: Rect) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use emath::{pos2, vec2, Rect};
+    #![expect(clippy::print_stdout)]
+
+    use emath::{Rect, pos2, vec2};
 
     use crate::{Id, Sense};
 
diff --git a/crates/egui/src/id.rs b/crates/egui/src/id.rs
index ddc1a59b7..7484930c8 100644
--- a/crates/egui/src/id.rs
+++ b/crates/egui/src/id.rs
@@ -59,7 +59,7 @@ impl Id {
 
     /// Generate a new [`Id`] by hashing the parent [`Id`] and the given argument.
     pub fn with(self, child: impl std::hash::Hash) -> Self {
-        use std::hash::{BuildHasher, Hasher};
+        use std::hash::{BuildHasher as _, Hasher as _};
         let mut hasher = ahash::RandomState::with_seeds(1, 2, 3, 4).build_hasher();
         hasher.write_u64(self.0.get());
         child.hash(&mut hasher);
@@ -79,10 +79,28 @@ impl Id {
         self.0.get()
     }
 
-    #[cfg(feature = "accesskit")]
     pub(crate) fn accesskit_id(&self) -> accesskit::NodeId {
         self.value().into()
     }
+
+    /// Create a new [`Id`] from a high-entropy value. No hashing is done.
+    ///
+    /// This can be useful if you have an [`Id`] that was converted to some other type
+    /// (e.g. accesskit::NodeId) and you want to convert it back to an [`Id`].
+    ///
+    /// # Safety
+    /// You need to ensure that the value is high-entropy since it might be used in
+    /// a [`IdSet`] or [`IdMap`], which rely on the assumption that [`Id`]s have good entropy.
+    ///
+    /// The method is not unsafe in terms of memory safety.
+    ///
+    /// # Panics
+    /// If the value is zero, this will panic.
+    #[doc(hidden)]
+    #[expect(unsafe_code)]
+    pub unsafe fn from_high_entropy_bits(value: u64) -> Self {
+        Self(NonZeroU64::new(value).expect("Id must be non-zero."))
+    }
 }
 
 impl std::fmt::Debug for Id {
diff --git a/crates/egui/src/input_state/mod.rs b/crates/egui/src/input_state/mod.rs
index 751d635f1..0c99b6ac3 100644
--- a/crates/egui/src/input_state/mod.rs
+++ b/crates/egui/src/input_state/mod.rs
@@ -1,12 +1,17 @@
 mod touch_state;
+mod wheel_state;
 
-use crate::data::input::{
-    Event, EventFilter, KeyboardShortcut, Modifiers, MouseWheelUnit, PointerButton, RawInput,
-    TouchDeviceId, ViewportInfo, NUM_POINTER_BUTTONS,
+use crate::{
+    SafeAreaInsets,
+    emath::{NumExt as _, Pos2, Rect, Vec2, vec2},
+    util::History,
 };
 use crate::{
-    emath::{vec2, NumExt, Pos2, Rect, Vec2},
-    util::History,
+    data::input::{
+        Event, EventFilter, KeyboardShortcut, Modifiers, NUM_POINTER_BUTTONS, PointerButton,
+        RawInput, TouchDeviceId, ViewportInfo,
+    },
+    input_state::wheel_state::WheelState,
 };
 use std::{
     collections::{BTreeMap, HashSet},
@@ -17,10 +22,47 @@ pub use crate::Key;
 pub use touch_state::MultiTouchInfo;
 use touch_state::TouchState;
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum SurrenderFocusOn {
+    /// Surrender focus if the user _presses_ somewhere outside the focused widget.
+    Presses,
+
+    /// Surrender focus if the user _clicks_ somewhere outside the focused widget.
+    #[default]
+    Clicks,
+
+    /// Never surrender focus.
+    Never,
+}
+
+impl SurrenderFocusOn {
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        ui.horizontal(|ui| {
+            ui.selectable_value(self, Self::Presses, "Presses")
+                .on_hover_text(
+                    "Surrender focus if the user presses somewhere outside the focused widget.",
+                );
+            ui.selectable_value(self, Self::Clicks, "Clicks")
+                .on_hover_text(
+                    "Surrender focus if the user clicks somewhere outside the focused widget.",
+                );
+            ui.selectable_value(self, Self::Never, "Never")
+                .on_hover_text("Never surrender focus.");
+        });
+    }
+}
+
 /// Options for input state handling.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct InputOptions {
+    /// Multiplier for the scroll speed when reported in [`crate::MouseWheelUnit::Line`]s.
+    pub line_scroll_speed: f32,
+
+    /// Controls the speed at which we zoom in when doing ctrl/cmd + scroll.
+    pub scroll_zoom_speed: f32,
+
     /// After a pointer-down event, if the pointer moves more than this, it won't become a click.
     pub max_click_dist: f32,
 
@@ -35,14 +77,48 @@ pub struct InputOptions {
     /// The new pointer press must come within this many seconds from previous pointer release
     /// for double click (or when this value is doubled, triple click) to count.
     pub max_double_click_delay: f64,
+
+    /// When this modifier is down, all scroll events are treated as zoom events.
+    ///
+    /// The default is CTRL/CMD, and it is STRONGLY recommended to NOT change this.
+    pub zoom_modifier: Modifiers,
+
+    /// When this modifier is down, all scroll events are treated as horizontal scrolls,
+    /// and when combined with [`Self::zoom_modifier`] it will result in zooming
+    /// on only the horizontal axis.
+    ///
+    /// The default is SHIFT, and it is STRONGLY recommended to NOT change this.
+    pub horizontal_scroll_modifier: Modifiers,
+
+    /// When this modifier is down, all scroll events are treated as vertical scrolls,
+    /// and when combined with [`Self::zoom_modifier`] it will result in zooming
+    /// on only the vertical axis.
+    pub vertical_scroll_modifier: Modifiers,
+
+    /// When should we surrender focus from the focused widget?
+    pub surrender_focus_on: SurrenderFocusOn,
 }
 
 impl Default for InputOptions {
     fn default() -> Self {
+        // TODO(emilk): figure out why these constants need to be different on web and on native (winit).
+        let is_web = cfg!(target_arch = "wasm32");
+        let line_scroll_speed = if is_web {
+            8.0
+        } else {
+            40.0 // Scroll speed decided by consensus: https://github.com/emilk/egui/issues/461
+        };
+
         Self {
+            line_scroll_speed,
+            scroll_zoom_speed: 1.0 / 200.0,
             max_click_dist: 6.0,
             max_click_duration: 0.8,
             max_double_click_delay: 0.3,
+            zoom_modifier: Modifiers::COMMAND,
+            horizontal_scroll_modifier: Modifiers::SHIFT,
+            vertical_scroll_modifier: Modifiers::ALT,
+            surrender_focus_on: SurrenderFocusOn::default(),
         }
     }
 }
@@ -51,39 +127,79 @@ impl InputOptions {
     /// Show the options in the ui.
     pub fn ui(&mut self, ui: &mut crate::Ui) {
         let Self {
+            line_scroll_speed,
+            scroll_zoom_speed,
             max_click_dist,
             max_click_duration,
             max_double_click_delay,
+            zoom_modifier,
+            horizontal_scroll_modifier,
+            vertical_scroll_modifier,
+            surrender_focus_on,
         } = self;
-        crate::containers::CollapsingHeader::new("InputOptions")
-            .default_open(false)
+        crate::Grid::new("InputOptions")
+            .num_columns(2)
+            .striped(true)
             .show(ui, |ui| {
-                ui.horizontal(|ui| {
-                    ui.label("Max click distance");
-                    ui.add(
-                        crate::DragValue::new(max_click_dist)
-                            .range(0.0..=f32::INFINITY)
+                ui.label("Line scroll speed");
+                ui.add(crate::DragValue::new(line_scroll_speed).range(0.0..=f32::INFINITY))
+                    .on_hover_text(
+                        "How many lines to scroll with each tick of the mouse wheel",
+                    );
+                ui.end_row();
+
+                ui.label("Scroll zoom speed");
+                ui.add(
+                    crate::DragValue::new(scroll_zoom_speed)
+                        .range(0.0..=f32::INFINITY)
+                        .speed(0.001),
+                )
+                .on_hover_text("How fast to zoom with ctrl/cmd + scroll");
+                ui.end_row();
+
+                ui.label("Max click distance");
+                ui.add(crate::DragValue::new(max_click_dist).range(0.0..=f32::INFINITY))
+                    .on_hover_text(
+                        "If the pointer moves more than this, it won't become a click",
+                    );
+                ui.end_row();
+
+                ui.label("Max click duration");
+                ui.add(
+                    crate::DragValue::new(max_click_duration)
+                        .range(0.1..=f64::INFINITY)
+                        .speed(0.1),
                     )
-                    .on_hover_text("If the pointer moves more than this, it won't become a click");
-                });
-                ui.horizontal(|ui| {
-                    ui.label("Max click duration");
-                    ui.add(
-                        crate::DragValue::new(max_click_duration)
-                            .range(0.1..=f64::INFINITY)
-                            .speed(0.1),
-                    )
-                    .on_hover_text("If the pointer is down for longer than this it will no longer register as a click");
-                });
-                ui.horizontal(|ui| {
-                    ui.label("Max double click delay");
-                    ui.add(
-                        crate::DragValue::new(max_double_click_delay)
-                            .range(0.01..=f64::INFINITY)
-                            .speed(0.1),
-                    )
-                    .on_hover_text("Max time interval for double click to count");
-                });
+                    .on_hover_text(
+                        "If the pointer is down for longer than this it will no longer register as a click",
+                    );
+                ui.end_row();
+
+                ui.label("Max double click delay");
+                ui.add(
+                    crate::DragValue::new(max_double_click_delay)
+                        .range(0.01..=f64::INFINITY)
+                        .speed(0.1),
+                )
+                .on_hover_text("Max time interval for double click to count");
+                ui.end_row();
+
+                ui.label("zoom_modifier");
+                zoom_modifier.ui(ui);
+                ui.end_row();
+
+                ui.label("horizontal_scroll_modifier");
+                horizontal_scroll_modifier.ui(ui);
+                ui.end_row();
+
+                ui.label("vertical_scroll_modifier");
+                vertical_scroll_modifier.ui(ui);
+                ui.end_row();
+
+                ui.label("surrender_focus_on");
+                surrender_focus_on.ui(ui);
+                ui.end_row();
+
             });
     }
 }
@@ -109,31 +225,8 @@ pub struct InputState {
 
     // ----------------------------------------------
     // Scrolling:
-    //
-    /// Time of the last scroll event.
-    last_scroll_time: f64,
-
-    /// Used for smoothing the scroll delta.
-    unprocessed_scroll_delta: Vec2,
-
-    /// Used for smoothing the scroll delta when zooming.
-    unprocessed_scroll_delta_for_zoom: f32,
-
-    /// You probably want to use [`Self::smooth_scroll_delta`] instead.
-    ///
-    /// The raw input of 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.
-    ///
-    /// When using a notched scroll-wheel this will spike very large for one frame,
-    /// then drop to zero. For a smoother experience, use [`Self::smooth_scroll_delta`].
-    pub raw_scroll_delta: Vec2,
+    #[cfg_attr(feature = "serde", serde(skip))]
+    wheel: WheelState,
 
     /// How many points the user scrolled, smoothed over a few frames.
     ///
@@ -156,9 +249,17 @@ pub struct InputState {
     /// * `zoom > 1`: pinch spread
     zoom_factor_delta: f32,
 
+    /// Rotation in radians this frame, measuring clockwise (e.g. from a rotation gesture).
+    rotation_radians: f32,
+
     // ----------------------------------------------
     /// Position and size of the egui area.
-    pub screen_rect: Rect,
+    ///
+    /// This is including the area that may be covered by the `safe_area_insets`.
+    viewport_rect: Rect,
+
+    /// The safe area insets, subtracted from the `viewport_rect` in [`Self::content_rect`].
+    safe_area_insets: SafeAreaInsets,
 
     /// Also known as device pixel ratio, > 1 for high resolution screens.
     pub pixels_per_point: f32,
@@ -227,7 +328,7 @@ pub struct InputState {
     /// Input state management configuration.
     ///
     /// This gets copied from `egui::Options` at the start of each frame for convenience.
-    input_options: InputOptions,
+    options: InputOptions,
 }
 
 impl Default for InputState {
@@ -237,14 +338,13 @@ impl Default for InputState {
             pointer: Default::default(),
             touch_states: Default::default(),
 
-            last_scroll_time: f64::NEG_INFINITY,
-            unprocessed_scroll_delta: Vec2::ZERO,
-            unprocessed_scroll_delta_for_zoom: 0.0,
-            raw_scroll_delta: Vec2::ZERO,
+            wheel: Default::default(),
             smooth_scroll_delta: Vec2::ZERO,
             zoom_factor_delta: 1.0,
+            rotation_radians: 0.0,
 
-            screen_rect: Rect::from_min_size(Default::default(), vec2(10_000.0, 10_000.0)),
+            viewport_rect: Rect::from_min_size(Default::default(), vec2(10_000.0, 10_000.0)),
+            safe_area_insets: Default::default(),
             pixels_per_point: 1.0,
             max_texture_side: 2048,
             time: 0.0,
@@ -255,7 +355,7 @@ impl Default for InputState {
             modifiers: Default::default(),
             keys_down: Default::default(),
             events: Default::default(),
-            input_options: Default::default(),
+            options: Default::default(),
         }
     }
 }
@@ -267,7 +367,7 @@ impl InputState {
         mut new: RawInput,
         requested_immediate_repaint_prev_frame: bool,
         pixels_per_point: f32,
-        options: &crate::Options,
+        options: InputOptions,
     ) -> Self {
         profiling::function_scope!();
 
@@ -282,7 +382,8 @@ impl InputState {
             new.predicted_dt
         };
 
-        let screen_rect = new.screen_rect.unwrap_or(self.screen_rect);
+        let safe_area_insets = new.safe_area_insets.unwrap_or(self.safe_area_insets);
+        let viewport_rect = new.screen_rect.unwrap_or(self.viewport_rect);
         self.create_touch_states_for_new_devices(&new.events);
         for touch_state in self.touch_states.values_mut() {
             touch_state.begin_pass(time, &new, self.pointer.interact_pos);
@@ -291,12 +392,9 @@ impl InputState {
 
         let mut keys_down = self.keys_down;
         let mut zoom_factor_delta = 1.0; // TODO(emilk): smoothing for zoom factor
-        let mut raw_scroll_delta = Vec2::ZERO;
+        let mut rotation_radians = 0.0;
 
-        let mut unprocessed_scroll_delta = self.unprocessed_scroll_delta;
-        let mut unprocessed_scroll_delta_for_zoom = self.unprocessed_scroll_delta_for_zoom;
-        let mut smooth_scroll_delta = Vec2::ZERO;
-        let mut smooth_scroll_delta_for_zoom = 0.0;
+        self.wheel.smooth_wheel_delta = Vec2::ZERO;
 
         for event in &mut new.events {
             match event {
@@ -316,108 +414,65 @@ impl InputState {
                 Event::MouseWheel {
                     unit,
                     delta,
+                    phase,
                     modifiers,
                 } => {
-                    let mut delta = match unit {
-                        MouseWheelUnit::Point => *delta,
-                        MouseWheelUnit::Line => options.line_scroll_speed * *delta,
-                        MouseWheelUnit::Page => screen_rect.height() * *delta,
-                    };
-
-                    if modifiers.shift {
-                        // Treat as horizontal scrolling.
-                        // Note: one Mac we already get horizontal scroll events when shift is down.
-                        delta = vec2(delta.x + delta.y, 0.0);
-                    }
-
-                    raw_scroll_delta += delta;
-
-                    // Mouse wheels often go very large steps.
-                    // A single notch on a logitech mouse wheel connected to a Macbook returns 14.0 raw_scroll_delta.
-                    // So we smooth it out over several frames for a nicer user experience when scrolling in egui.
-                    // BUT: if the user is using a nice smooth mac trackpad, we don't add smoothing,
-                    // because it adds latency.
-                    let is_smooth = match unit {
-                        MouseWheelUnit::Point => delta.length() < 8.0, // a bit arbitrary here
-                        MouseWheelUnit::Line | MouseWheelUnit::Page => false,
-                    };
-
-                    let is_zoom = modifiers.ctrl || modifiers.mac_cmd || modifiers.command;
-
-                    #[allow(clippy::collapsible_else_if)]
-                    if is_zoom {
-                        if is_smooth {
-                            smooth_scroll_delta_for_zoom += delta.y;
-                        } else {
-                            unprocessed_scroll_delta_for_zoom += delta.y;
-                        }
-                    } else {
-                        if is_smooth {
-                            smooth_scroll_delta += delta;
-                        } else {
-                            unprocessed_scroll_delta += delta;
-                        }
-                    }
+                    self.wheel.on_wheel_event(
+                        viewport_rect,
+                        &options,
+                        time,
+                        *unit,
+                        *delta,
+                        *phase,
+                        *modifiers,
+                    );
                 }
                 Event::Zoom(factor) => {
                     zoom_factor_delta *= *factor;
                 }
+                Event::Rotate(radians) => {
+                    rotation_radians += *radians;
+                }
+                Event::WindowFocused(false) => {
+                    // Example: pressing `Cmd+S` brings up a save-dialog (e.g. using rfd),
+                    // but we get no key-up event for the `S` key (in winit).
+                    // This leads to `S` being mistakenly marked as down when we switch back to the app.
+                    // So we take the safe route and just clear all the keys and modifiers when
+                    // the app loses focus.
+                    keys_down.clear();
+                }
                 _ => {}
             }
         }
 
+        let mut smooth_scroll_delta = Vec2::ZERO;
+
         {
             let dt = stable_dt.at_most(0.1);
-            let t = crate::emath::exponential_smooth_factor(0.90, 0.1, dt); // reach _% in _ seconds. TODO(emilk): parameterize
+            self.wheel.after_events(time, dt);
 
-            if unprocessed_scroll_delta != Vec2::ZERO {
-                for d in 0..2 {
-                    if unprocessed_scroll_delta[d].abs() < 1.0 {
-                        smooth_scroll_delta[d] += unprocessed_scroll_delta[d];
-                        unprocessed_scroll_delta[d] = 0.0;
-                    } else {
-                        let applied = t * unprocessed_scroll_delta[d];
-                        smooth_scroll_delta[d] += applied;
-                        unprocessed_scroll_delta[d] -= applied;
-                    }
-                }
-            }
+            let is_zoom = self.wheel.modifiers.matches_any(options.zoom_modifier);
 
-            {
-                // Smooth scroll-to-zoom:
-                if unprocessed_scroll_delta_for_zoom.abs() < 1.0 {
-                    smooth_scroll_delta_for_zoom += unprocessed_scroll_delta_for_zoom;
-                    unprocessed_scroll_delta_for_zoom = 0.0;
-                } else {
-                    let applied = t * unprocessed_scroll_delta_for_zoom;
-                    smooth_scroll_delta_for_zoom += applied;
-                    unprocessed_scroll_delta_for_zoom -= applied;
-                }
-
-                zoom_factor_delta *=
-                    (options.scroll_zoom_speed * smooth_scroll_delta_for_zoom).exp();
+            if is_zoom {
+                zoom_factor_delta *= (options.scroll_zoom_speed
+                    * (self.wheel.smooth_wheel_delta.x + self.wheel.smooth_wheel_delta.y))
+                    .exp();
+            } else {
+                smooth_scroll_delta = self.wheel.smooth_wheel_delta;
             }
         }
 
-        let is_scrolling = raw_scroll_delta != Vec2::ZERO || smooth_scroll_delta != Vec2::ZERO;
-        let last_scroll_time = if is_scrolling {
-            time
-        } else {
-            self.last_scroll_time
-        };
-
         Self {
             pointer,
             touch_states: self.touch_states,
 
-            last_scroll_time,
-            unprocessed_scroll_delta,
-            unprocessed_scroll_delta_for_zoom,
-            raw_scroll_delta,
+            wheel: self.wheel,
             smooth_scroll_delta,
             zoom_factor_delta,
+            rotation_radians,
 
-            screen_rect,
+            viewport_rect,
+            safe_area_insets,
             pixels_per_point,
             max_texture_side: new.max_texture_side.unwrap_or(self.max_texture_side),
             time,
@@ -429,7 +484,7 @@ impl InputState {
             keys_down,
             events: new.events.clone(), // TODO(emilk): remove clone() and use raw.events
             raw: new,
-            input_options: options.input_options.clone(),
+            options,
         }
     }
 
@@ -439,15 +494,73 @@ impl InputState {
         self.raw.viewport()
     }
 
+    /// Returns the region of the screen that is safe for content rendering
+    ///
+    /// Returns the `viewport_rect` with the `safe_area_insets` removed.
+    ///
+    /// If you want to render behind e.g. the dynamic island on iOS, use [`Self::viewport_rect`].
+    ///
+    /// See also [`RawInput::safe_area_insets`].
     #[inline(always)]
-    pub fn screen_rect(&self) -> Rect {
-        self.screen_rect
+    pub fn content_rect(&self) -> Rect {
+        self.viewport_rect - self.safe_area_insets
     }
 
-    /// Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
+    /// Returns the full area available to egui, including parts that might be partially covered,
+    /// for example, by the OS status bar or notches (see [`Self::safe_area_insets`]).
+    ///
+    /// Usually you want to use [`Self::content_rect`] instead.
+    ///
+    /// This rectangle includes e.g. the dynamic island on iOS.
+    /// If you want to only render _below_ the that (not behind), then you should use
+    /// [`Self::content_rect`] instead.
+    ///
+    /// See also [`RawInput::safe_area_insets`].
+    pub fn viewport_rect(&self) -> Rect {
+        self.viewport_rect
+    }
+
+    /// Position and size of the egui area.
+    #[deprecated(
+        note = "screen_rect has been split into viewport_rect() and content_rect(). You likely should use content_rect()"
+    )]
+    pub fn screen_rect(&self) -> Rect {
+        self.content_rect()
+    }
+
+    /// Get the safe area insets.
+    ///
+    /// This represents the area of the screen covered by status bars, navigation controls, notches,
+    /// or other items that obscure part of the screen.
+    ///
+    /// See [`Self::content_rect`] to get the `viewport_rect` with the safe area insets removed.
+    pub fn safe_area_insets(&self) -> SafeAreaInsets {
+        self.safe_area_insets
+    }
+
+    /// How many points the user scrolled, smoothed over a few frames.
+    ///
+    /// 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.
+    ///
+    /// [`crate::ScrollArea`] will both read and write to this field, so that
+    /// at the end of the frame this will be zero if a scroll-area consumed the delta.
+    pub fn smooth_scroll_delta(&self) -> Vec2 {
+        self.smooth_scroll_delta
+    }
+
+    /// Uniform 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
+    ///
+    /// If your application supports non-proportional zooming,
+    /// then you probably want to use [`Self::zoom_delta_2d`] instead.
     #[inline(always)]
     pub fn zoom_delta(&self) -> f32 {
         // If a multi touch gesture is detected, it measures the exact and linear proportions of
@@ -477,25 +590,72 @@ impl InputState {
         // 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,
-        )
+        if let Some(multi_touch) = self.multi_touch() {
+            multi_touch.zoom_delta_2d
+        } else {
+            let mut zoom = Vec2::splat(self.zoom_factor_delta);
+
+            let is_horizontal = self
+                .modifiers
+                .matches_any(self.options.horizontal_scroll_modifier);
+            let is_vertical = self
+                .modifiers
+                .matches_any(self.options.vertical_scroll_modifier);
+
+            if is_horizontal && !is_vertical {
+                // Horizontal-only zooming.
+                zoom.y = 1.0;
+            }
+            if !is_horizontal && is_vertical {
+                // Vertical-only zooming.
+                zoom.x = 1.0;
+            }
+
+            zoom
+        }
     }
 
-    /// How long has it been (in seconds) since the use last scrolled?
+    /// Rotation in radians this frame, measuring clockwise (e.g. from a rotation gesture).
+    #[inline(always)]
+    pub fn rotation_delta(&self) -> f32 {
+        self.multi_touch()
+            .map_or(self.rotation_radians, |touch| touch.rotation_delta)
+    }
+
+    /// Panning translation in pixels this frame (e.g. from scrolling or a pan gesture)
+    ///
+    /// The delta indicates 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.
+    #[inline(always)]
+    pub fn translation_delta(&self) -> Vec2 {
+        self.multi_touch()
+            .map_or(self.smooth_scroll_delta(), |touch| touch.translation_delta)
+    }
+
+    /// True if there is an active scroll action that might scroll more when using [`Self::smooth_scroll_delta`].
+    pub fn is_scrolling(&self) -> bool {
+        self.wheel.is_scrolling()
+    }
+
+    /// How long has it been (in seconds) since the last scroll event?
     #[inline(always)]
     pub fn time_since_last_scroll(&self) -> f32 {
-        (self.time - self.last_scroll_time) as f32
+        (self.time - self.wheel.last_wheel_event) as f32
     }
 
-    /// The [`crate::Context`] will call this at the end of each frame to see if we need a repaint.
+    /// The [`crate::Context`] will call this at the beginning of each frame to see if we need a repaint.
     ///
     /// Returns how long to wait for a repaint.
-    pub fn wants_repaint_after(&self) -> Option<Duration> {
+    ///
+    /// NOTE: It's important to call this immediately after [`Self::begin_pass`] since calls to
+    /// [`Self::consume_key`] will remove events from the vec, meaning those key presses wouldn't
+    /// cause a repaint.
+    pub(crate) fn wants_repaint_after(&self) -> Option<Duration> {
         if self.pointer.wants_repaint()
-            || self.unprocessed_scroll_delta.abs().max_elem() > 0.2
-            || self.unprocessed_scroll_delta_for_zoom.abs() > 0.2
+            || self.wheel.unprocessed_wheel_delta.abs().max_elem() > 0.2
             || !self.events.is_empty()
         {
             // Immediate repaint
@@ -506,10 +666,10 @@ impl InputState {
             // We need to wake up and check for press-and-hold for the context menu.
             if let Some(press_start_time) = self.pointer.press_start_time {
                 let press_duration = self.time - press_start_time;
-                if self.input_options.max_click_duration.is_finite()
-                    && press_duration < self.input_options.max_click_duration
+                if self.options.max_click_duration.is_finite()
+                    && press_duration < self.options.max_click_duration
                 {
-                    let secs_until_menu = self.input_options.max_click_duration - press_duration;
+                    let secs_until_menu = self.options.max_click_duration - press_duration;
                     return Some(Duration::from_secs_f64(secs_until_menu));
                 }
             }
@@ -695,7 +855,6 @@ impl InputState {
         }
     }
 
-    #[cfg(feature = "accesskit")]
     pub fn accesskit_action_requests(
         &self,
         id: crate::Id,
@@ -703,21 +862,36 @@ impl InputState {
     ) -> 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);
-                }
+            if let Event::AccessKitActionRequest(request) = event
+                && request.target == accesskit_id
+                && request.action == action
+            {
+                return Some(request);
             }
             None
         })
     }
 
-    #[cfg(feature = "accesskit")]
+    pub fn consume_accesskit_action_requests(
+        &mut self,
+        id: crate::Id,
+        mut consume: impl FnMut(&accesskit::ActionRequest) -> bool,
+    ) {
+        let accesskit_id = id.accesskit_id();
+        self.events.retain(|event| {
+            if let Event::AccessKitActionRequest(request) = event
+                && request.target == accesskit_id
+            {
+                return !consume(request);
+            }
+            true
+        });
+    }
+
     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()
     }
@@ -870,7 +1044,7 @@ pub struct PointerState {
     /// Input state management configuration.
     ///
     /// This gets copied from `egui::Options` at the start of each frame for convenience.
-    input_options: InputOptions,
+    options: InputOptions,
 }
 
 impl Default for PointerState {
@@ -893,23 +1067,18 @@ impl Default for PointerState {
             last_last_click_time: f64::NEG_INFINITY,
             last_move_time: f64::NEG_INFINITY,
             pointer_events: vec![],
-            input_options: Default::default(),
+            options: Default::default(),
         }
     }
 }
 
 impl PointerState {
     #[must_use]
-    pub(crate) fn begin_pass(
-        mut self,
-        time: f64,
-        new: &RawInput,
-        options: &crate::Options,
-    ) -> Self {
+    pub(crate) fn begin_pass(mut self, time: f64, new: &RawInput, options: InputOptions) -> Self {
         let was_decidedly_dragging = self.is_decidedly_dragging();
 
         self.time = time;
-        self.input_options = options.input_options.clone();
+        self.options = options;
 
         self.pointer_events.clear();
 
@@ -919,6 +1088,7 @@ impl PointerState {
             self.motion = Some(Vec2::ZERO);
         }
 
+        let mut clear_history_after_velocity_calculation = false;
         for event in &new.events {
             match event {
                 Event::PointerMoved(pos) => {
@@ -929,9 +1099,10 @@ impl PointerState {
 
                     if let Some(press_origin) = self.press_origin {
                         self.has_moved_too_much_for_a_click |=
-                            press_origin.distance(pos) > self.input_options.max_click_dist;
+                            press_origin.distance(pos) > self.options.max_click_dist;
                     }
 
+                    self.last_move_time = time;
                     self.pointer_events.push(PointerEvent::Moved(pos));
                 }
                 Event::PointerButton {
@@ -967,10 +1138,10 @@ impl PointerState {
                         let clicked = self.could_any_button_be_click();
 
                         let click = if clicked {
-                            let double_click = (time - self.last_click_time)
-                                < self.input_options.max_double_click_delay;
+                            let double_click =
+                                (time - self.last_click_time) < self.options.max_double_click_delay;
                             let triple_click = (time - self.last_last_click_time)
-                                < (self.input_options.max_double_click_delay * 2.0);
+                                < (self.options.max_double_click_delay * 2.0);
                             let count = if triple_click {
                                 3
                             } else if double_click {
@@ -1005,7 +1176,10 @@ impl PointerState {
                     // When dragging a slider and the mouse leaves the viewport, we still want the drag to work,
                     // so we don't treat this as a `PointerEvent::Released`.
                     // NOTE: we do NOT clear `self.interact_pos` here. It will be cleared next frame.
-                    self.pos_history.clear();
+
+                    // Delay the clearing until after the final velocity calculation, so we can
+                    // get the final velocity when `drag_stopped` is true.
+                    clear_history_after_velocity_calculation = true;
                 }
                 Event::MouseMoved(delta) => *self.motion.get_or_insert(Vec2::ZERO) += *delta,
                 _ => {}
@@ -1036,6 +1210,9 @@ impl PointerState {
         if self.velocity != Vec2::ZERO {
             self.last_move_time = time;
         }
+        if clear_history_after_velocity_calculation {
+            self.pos_history.clear();
+        }
 
         self.direction = self.pos_history.velocity().unwrap_or_default().normalized();
 
@@ -1086,6 +1263,11 @@ impl PointerState {
         self.press_origin
     }
 
+    /// How far has the pointer moved since the start of the drag (if any)?
+    pub fn total_drag_delta(&self) -> Option<Vec2> {
+        Some(self.latest_pos? - self.press_origin?)
+    }
+
     /// When did the current click/drag originate?
     /// `None` if no mouse button is down.
     #[inline(always)]
@@ -1267,10 +1449,10 @@ impl PointerState {
                 return false;
             }
 
-            if let Some(press_start_time) = self.press_start_time {
-                if self.time - press_start_time > self.input_options.max_click_duration {
-                    return false;
-                }
+            if let Some(press_start_time) = self.press_start_time
+                && self.time - press_start_time > self.options.max_click_duration
+            {
+                return false;
             }
 
             true
@@ -1304,7 +1486,7 @@ impl PointerState {
             && !self.has_moved_too_much_for_a_click
             && self.button_down(PointerButton::Primary)
             && self.press_start_time.is_some_and(|press_start_time| {
-                self.time - press_start_time > self.input_options.max_click_duration
+                self.time - press_start_time > self.options.max_click_duration
             })
     }
 
@@ -1325,6 +1507,21 @@ impl PointerState {
     pub fn middle_down(&self) -> bool {
         self.button_down(PointerButton::Middle)
     }
+
+    /// Is the mouse moving in the direction of the given rect?
+    pub fn is_moving_towards_rect(&self, rect: &Rect) -> bool {
+        if self.is_still() {
+            return false;
+        }
+
+        if let Some(pos) = self.hover_pos() {
+            let dir = self.direction();
+            if dir != Vec2::ZERO {
+                return rect.intersects_ray(pos, self.direction());
+            }
+        }
+        false
+    }
 }
 
 impl InputState {
@@ -1333,15 +1530,12 @@ impl InputState {
             raw,
             pointer,
             touch_states,
-
-            last_scroll_time,
-            unprocessed_scroll_delta,
-            unprocessed_scroll_delta_for_zoom,
-            raw_scroll_delta,
+            wheel,
             smooth_scroll_delta,
-
+            rotation_radians,
             zoom_factor_delta,
-            screen_rect,
+            viewport_rect,
+            safe_area_insets,
             pixels_per_point,
             max_texture_side,
             time,
@@ -1352,7 +1546,7 @@ impl InputState {
             modifiers,
             keys_down,
             events,
-            input_options: _,
+            options: _,
         } = self;
 
         ui.style_mut()
@@ -1375,25 +1569,18 @@ impl InputState {
             });
         }
 
-        ui.label(format!(
-            "Time since last scroll: {:.1} s",
-            time - last_scroll_time
-        ));
-        if cfg!(debug_assertions) {
-            ui.label(format!(
-                "unprocessed_scroll_delta: {unprocessed_scroll_delta:?} points"
-            ));
-            ui.label(format!(
-                "unprocessed_scroll_delta_for_zoom: {unprocessed_scroll_delta_for_zoom:?} points"
-            ));
-        }
-        ui.label(format!("raw_scroll_delta: {raw_scroll_delta:?} points"));
-        ui.label(format!(
-            "smooth_scroll_delta: {smooth_scroll_delta:?} points"
-        ));
-        ui.label(format!("zoom_factor_delta: {zoom_factor_delta:4.2}x"));
+        crate::containers::CollapsingHeader::new("⬍ Scroll")
+            .default_open(false)
+            .show(ui, |ui| {
+                wheel.ui(ui);
+            });
 
-        ui.label(format!("screen_rect: {screen_rect:?} points"));
+        ui.label(format!("smooth_scroll_delta: {smooth_scroll_delta:4.1}x"));
+        ui.label(format!("zoom_factor_delta: {zoom_factor_delta:4.2}x"));
+        ui.label(format!("rotation_radians: {rotation_radians:.3} radians"));
+
+        ui.label(format!("viewport_rect: {viewport_rect:?} points"));
+        ui.label(format!("safe_area_insets: {safe_area_insets:?} points"));
         ui.label(format!(
             "{pixels_per_point} physical pixels for each logical point"
         ));
@@ -1438,7 +1625,7 @@ impl PointerState {
             last_last_click_time,
             pointer_events,
             last_move_time,
-            input_options: _,
+            options: _,
         } = self;
 
         ui.label(format!("latest_pos: {latest_pos:?}"));
diff --git a/crates/egui/src/input_state/touch_state.rs b/crates/egui/src/input_state/touch_state.rs
index 1ff2dc388..102b91fff 100644
--- a/crates/egui/src/input_state/touch_state.rs
+++ b/crates/egui/src/input_state/touch_state.rs
@@ -1,9 +1,9 @@
 use std::{collections::BTreeMap, fmt::Debug};
 
 use crate::{
-    data::input::TouchDeviceId,
-    emath::{normalized_angle, Pos2, Vec2},
     Event, RawInput, TouchId, TouchPhase,
+    data::input::TouchDeviceId,
+    emath::{Pos2, Vec2, normalized_angle},
 };
 
 /// All you probably need to know about a multi-touch gesture.
@@ -174,7 +174,7 @@ impl TouchState {
         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 {
+            if let Some(state) = &mut self.gesture_state {
                 state.previous = None;
             }
         }
@@ -194,7 +194,7 @@ impl TouchState {
 
             let zoom_delta = state.current.avg_distance / state_previous.avg_distance;
 
-            let zoom_delta2 = match state.pinch_type {
+            let zoom_delta_2d = match state.pinch_type {
                 PinchType::Horizontal => Vec2::new(
                     state.current.avg_abs_distance2.x / state_previous.avg_abs_distance2.x,
                     1.0,
@@ -213,7 +213,7 @@ impl TouchState {
                 start_pos: state.start_pointer_pos,
                 num_touches: self.active_touches.len(),
                 zoom_delta,
-                zoom_delta_2d: zoom_delta2,
+                zoom_delta_2d,
                 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,
@@ -224,7 +224,7 @@ impl TouchState {
 
     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 {
+            if let Some(state) = &mut self.gesture_state {
                 // updating an ongoing gesture
                 state.previous = Some(state.current);
                 state.current = dyn_state;
diff --git a/crates/egui/src/input_state/wheel_state.rs b/crates/egui/src/input_state/wheel_state.rs
new file mode 100644
index 000000000..2efbbc1ff
--- /dev/null
+++ b/crates/egui/src/input_state/wheel_state.rs
@@ -0,0 +1,233 @@
+use emath::{Rect, Vec2, vec2};
+
+use crate::{InputOptions, Modifiers, MouseWheelUnit, TouchPhase};
+
+/// The current state of scrolling.
+///
+/// There are two important types of scroll input deviced:
+/// * Discreen scroll wheels on a mouse
+/// * Smooth scroll input from a trackpad
+///
+/// Scroll wheels will usually fire one single scroll event,
+/// so it is important that egui smooths it out over time.
+///
+/// On the contrary, trackpads usually provide smooth scroll input,
+/// and with kinetic scrolling (which on Mac is implemented by the OS)
+/// scroll events can arrive _after_ the user lets go of the trackpad.
+///
+/// In either case, we consider use to be scrolling until there is no more
+/// scroll events expected.
+///
+/// This means there are a few different states we can be in:
+/// * Not scrolling
+/// * "Smooth scrolling" (low-pass filter of discreet scroll events)
+/// * Trackpad-scrolling (we receive begin/end phases for these)
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Status {
+    /// Not scrolling,
+    Static,
+
+    /// We're smoothing out previous scroll events
+    Smoothing,
+
+    // We're in-between [`TouchPhase::Start`] and [`TouchPhase::End`] of a trackpad scroll.
+    InTouch,
+}
+
+/// Keeps track of wheel (scroll) input.
+#[derive(Clone, Debug)]
+pub struct WheelState {
+    /// Are we currently in a scroll action?
+    ///
+    /// This may be true even if no scroll events came in this frame,
+    /// but we are in a kinetic scroll or in a smoothed scroll.
+    pub status: Status,
+
+    /// The modifiers at the start of the scroll.
+    pub modifiers: Modifiers,
+
+    /// Time of the last scroll event.
+    pub last_wheel_event: f64,
+
+    /// Used for smoothing the scroll delta.
+    pub unprocessed_wheel_delta: Vec2,
+
+    /// How many points the user scrolled, smoothed over a few frames.
+    ///
+    /// 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.
+    ///
+    /// [`crate::ScrollArea`] will both read and write to this field, so that
+    /// at the end of the frame this will be zero if a scroll-area consumed the delta.
+    pub smooth_wheel_delta: Vec2,
+}
+
+impl Default for WheelState {
+    fn default() -> Self {
+        Self {
+            status: Status::Static,
+            modifiers: Default::default(),
+            last_wheel_event: f64::NEG_INFINITY,
+            unprocessed_wheel_delta: Vec2::ZERO,
+            smooth_wheel_delta: Vec2::ZERO,
+        }
+    }
+}
+
+impl WheelState {
+    #[expect(clippy::too_many_arguments)]
+    pub fn on_wheel_event(
+        &mut self,
+        viewport_rect: Rect,
+        options: &InputOptions,
+        time: f64,
+        unit: MouseWheelUnit,
+        delta: Vec2,
+        phase: TouchPhase,
+        latest_modifiers: Modifiers,
+    ) {
+        self.last_wheel_event = time;
+        match phase {
+            crate::TouchPhase::Start => {
+                self.status = Status::InTouch;
+                self.modifiers = latest_modifiers;
+            }
+            crate::TouchPhase::Move => {
+                match self.status {
+                    Status::Static | Status::Smoothing => {
+                        self.modifiers = latest_modifiers;
+                        self.status = Status::Smoothing;
+                    }
+                    Status::InTouch => {
+                        // If the user lets go of a modifier - ignore it.
+                        // More kinematic scrolling may arrive.
+                        // But if the users presses down new modifiers - heed it!
+                        self.modifiers |= latest_modifiers;
+                    }
+                }
+
+                let mut delta = match unit {
+                    MouseWheelUnit::Point => delta,
+                    MouseWheelUnit::Line => options.line_scroll_speed * delta,
+                    MouseWheelUnit::Page => viewport_rect.height() * delta,
+                };
+
+                let is_horizontal = self
+                    .modifiers
+                    .matches_any(options.horizontal_scroll_modifier);
+                let is_vertical = self.modifiers.matches_any(options.vertical_scroll_modifier);
+
+                if is_horizontal && !is_vertical {
+                    // Treat all scrolling as horizontal scrolling.
+                    // Note: one Mac we already get horizontal scroll events when shift is down.
+                    delta = vec2(delta.x + delta.y, 0.0);
+                }
+                if !is_horizontal && is_vertical {
+                    // Treat all scrolling as vertical scrolling.
+                    delta = vec2(0.0, delta.x + delta.y);
+                }
+
+                // Mouse wheels often go very large steps.
+                // A single notch on a logitech mouse wheel connected to a Macbook returns 14.0 raw scroll delta.
+                // So we smooth it out over several frames for a nicer user experience when scrolling in egui.
+                // BUT: if the user is using a nice smooth mac trackpad, we don't add smoothing,
+                // because it adds latency.
+                let is_smooth = self.status == Status::InTouch
+                    || match unit {
+                        MouseWheelUnit::Point => delta.length() < 8.0, // a bit arbitrary here
+                        MouseWheelUnit::Line | MouseWheelUnit::Page => false,
+                    };
+
+                if is_smooth {
+                    self.smooth_wheel_delta += delta;
+                } else {
+                    self.unprocessed_wheel_delta += delta;
+                }
+            }
+            crate::TouchPhase::End | crate::TouchPhase::Cancel => {
+                self.status = Status::Static;
+                self.modifiers = Default::default();
+                self.unprocessed_wheel_delta = Default::default();
+                self.smooth_wheel_delta = Default::default();
+            }
+        }
+    }
+
+    pub fn after_events(&mut self, time: f64, dt: f32) {
+        let t = crate::emath::exponential_smooth_factor(0.90, 0.1, dt); // reach _% in _ seconds. TODO(emilk): parameterize
+
+        if self.unprocessed_wheel_delta != Vec2::ZERO {
+            for d in 0..2 {
+                if self.unprocessed_wheel_delta[d].abs() < 1.0 {
+                    self.smooth_wheel_delta[d] += self.unprocessed_wheel_delta[d];
+                    self.unprocessed_wheel_delta[d] = 0.0;
+                } else {
+                    let applied = t * self.unprocessed_wheel_delta[d];
+                    self.smooth_wheel_delta[d] += applied;
+                    self.unprocessed_wheel_delta[d] -= applied;
+                }
+            }
+        }
+
+        let time_since_last_scroll = time - self.last_wheel_event;
+
+        if self.status == Status::Smoothing
+            && self.smooth_wheel_delta == Vec2::ZERO
+            && 0.150 < time_since_last_scroll
+        {
+            // On certain platforms, like web, we don't get the start & stop scrolling events, so
+            // we rely on a timer there.
+            //
+            // Tested on a mac touchpad 2025, where the largest observed gap between scroll events
+            // was 68 ms. But we add some margin to be safe
+            self.status = Status::Static;
+            self.modifiers = Default::default();
+        }
+    }
+
+    /// True if there is an active scroll action that might scroll more when using [`Self::smooth_wheel_delta`].
+    pub fn is_scrolling(&self) -> bool {
+        self.status != Status::Static
+    }
+
+    pub fn ui(&self, ui: &mut crate::Ui) {
+        let Self {
+            status,
+            modifiers,
+            last_wheel_event,
+            unprocessed_wheel_delta,
+            smooth_wheel_delta,
+        } = self;
+
+        let time = ui.input(|i| i.time);
+
+        crate::Grid::new("ScrollState")
+            .num_columns(2)
+            .show(ui, |ui| {
+                ui.label("status");
+                ui.monospace(format!("{status:?}"));
+                ui.end_row();
+
+                ui.label("modifiers");
+                ui.monospace(format!("{modifiers:?}"));
+                ui.end_row();
+
+                ui.label("last_wheel_event");
+                ui.monospace(format!("{:.1}s ago", time - *last_wheel_event));
+                ui.end_row();
+
+                ui.label("unprocessed_wheel_delta");
+                ui.monospace(unprocessed_wheel_delta.to_string());
+                ui.end_row();
+
+                ui.label("smooth_wheel_delta");
+                ui.monospace(smooth_wheel_delta.to_string());
+                ui.end_row();
+            });
+    }
+}
diff --git a/crates/egui/src/interaction.rs b/crates/egui/src/interaction.rs
index b6b63e19d..bfac38da7 100644
--- a/crates/egui/src/interaction.rs
+++ b/crates/egui/src/interaction.rs
@@ -1,6 +1,6 @@
 //! How mouse and touch interzcts with widgets.
 
-use crate::{hit_test, id, input_state, memory, Id, InputState, Key, WidgetRects};
+use crate::{Id, InputState, Key, WidgetRects, hit_test, id, input_state, memory};
 
 use self::{hit_test::WidgetHits, id::IdSet, input_state::PointerEvent, memory::InteractionState};
 
@@ -115,19 +115,19 @@ pub(crate) fn interact(
 ) -> InteractionSnapshot {
     profiling::function_scope!();
 
-    if let Some(id) = interaction.potential_click_id {
-        if !widgets.contains(id) {
-            // The widget we were interested in clicking is gone.
-            interaction.potential_click_id = None;
-        }
+    if let Some(id) = interaction.potential_click_id
+        && !widgets.contains(id)
+    {
+        // The widget we were interested in clicking is gone.
+        interaction.potential_click_id = None;
     }
-    if let Some(id) = interaction.potential_drag_id {
-        if !widgets.contains(id) {
-            // The widget we were interested in dragging is gone.
-            // This is fine! This could be drag-and-drop,
-            // and the widget being dragged is now "in the air" and thus
-            // not registered in the new frame.
-        }
+    if let Some(id) = interaction.potential_drag_id
+        && !widgets.contains(id)
+    {
+        // The widget we were interested in dragging is gone.
+        // This is fine! This could be drag-and-drop,
+        // and the widget being dragged is now "in the air" and thus
+        // not registered in the new frame.
     }
 
     let mut clicked = None;
@@ -172,13 +172,13 @@ pub(crate) fn interact(
             }
 
             PointerEvent::Released { click, button: _ } => {
-                if click.is_some() && !input.pointer.is_decidedly_dragging() {
-                    if let Some(widget) = interaction
+                if click.is_some()
+                    && !input.pointer.is_decidedly_dragging()
+                    && let Some(widget) = interaction
                         .potential_click_id
                         .and_then(|id| widgets.get(id))
-                    {
-                        clicked = Some(widget.id);
-                    }
+                {
+                    clicked = Some(widget.id);
                 }
 
                 interaction.potential_drag_id = None;
@@ -190,21 +190,21 @@ pub(crate) fn interact(
 
     if dragged.is_none() {
         // Check if we started dragging something new:
-        if let Some(widget) = interaction.potential_drag_id.and_then(|id| widgets.get(id)) {
-            if widget.enabled {
-                let is_dragged = if widget.sense.senses_click() && widget.sense.senses_drag() {
-                    // This widget is sensitive to both clicks and drags.
-                    // When the mouse first is pressed, it could be either,
-                    // so we postpone the decision until we know.
-                    input.pointer.is_decidedly_dragging()
-                } else {
-                    // This widget is just sensitive to drags, so we can mark it as dragged right away:
-                    widget.sense.senses_drag()
-                };
+        if let Some(widget) = interaction.potential_drag_id.and_then(|id| widgets.get(id))
+            && widget.enabled
+        {
+            let is_dragged = if widget.sense.senses_click() && widget.sense.senses_drag() {
+                // This widget is sensitive to both clicks and drags.
+                // When the mouse first is pressed, it could be either,
+                // so we postpone the decision until we know.
+                input.pointer.is_decidedly_dragging()
+            } else {
+                // This widget is just sensitive to drags, so we can mark it as dragged right away:
+                widget.sense.senses_drag()
+            };
 
-                if is_dragged {
-                    dragged = Some(widget.id);
-                }
+            if is_dragged {
+                dragged = Some(widget.id);
             }
         }
     }
@@ -293,7 +293,7 @@ pub(crate) fn interact(
         drag_started,
         dragged,
         drag_stopped,
-        contains_pointer,
         hovered,
+        contains_pointer,
     }
 }
diff --git a/crates/egui/src/introspection.rs b/crates/egui/src/introspection.rs
index e21ddb3a5..fa8caa3c8 100644
--- a/crates/egui/src/introspection.rs
+++ b/crates/egui/src/introspection.rs
@@ -1,7 +1,7 @@
 //! Showing UI:s for egui/epaint types.
 use crate::{
-    epaint, memory, pos2, remap_clamp, vec2, Color32, CursorIcon, FontFamily, FontId, Label, Mesh,
-    NumExt, Rect, Response, Sense, Shape, Slider, TextStyle, TextWrapMode, Ui, Widget,
+    Color32, CursorIcon, FontFamily, FontId, Label, Mesh, NumExt as _, Rect, Response, Sense,
+    Shape, Slider, TextStyle, TextWrapMode, Ui, Widget, epaint, memory, pos2, remap_clamp, vec2,
 };
 
 pub fn font_family_ui(ui: &mut Ui, font_family: &mut FontFamily) {
diff --git a/crates/egui/src/layers.rs b/crates/egui/src/layers.rs
index 81a60812e..96ce46489 100644
--- a/crates/egui/src/layers.rs
+++ b/crates/egui/src/layers.rs
@@ -1,8 +1,8 @@
 //! Handles paint layers, i.e. how things
 //! are sometimes painted behind or in front of other things.
 
-use crate::{ahash, epaint, Id, IdMap, Rect};
-use epaint::{emath::TSTransform, ClippedShape, Shape};
+use crate::{Id, IdMap, Rect, ahash, epaint};
+use epaint::{ClippedShape, Shape, emath::TSTransform};
 
 /// Different layer categories
 #[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
@@ -154,7 +154,6 @@ impl PaintList {
     #[inline(always)]
     pub fn set(&mut self, idx: ShapeIdx, clip_rect: Rect, shape: Shape) {
         if self.0.len() <= idx.0 {
-            #[cfg(feature = "log")]
             log::warn!("Index {} is out of bounds for PaintList", idx.0);
             return;
         }
@@ -236,27 +235,28 @@ impl GraphicLayers {
 
             // 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) {
-                        if let Some(to_global) = to_global.get(layer_id) {
-                            for clipped_shape in &mut list.0 {
-                                clipped_shape.clip_rect = *to_global * clipped_shape.clip_rect;
-                                clipped_shape.shape.transform(*to_global);
-                            }
+                if layer_id.order == order
+                    && let Some(list) = order_map.get_mut(&layer_id.id)
+                {
+                    if let Some(to_global) = to_global.get(layer_id) {
+                        for clipped_shape in &mut list.0 {
+                            clipped_shape.transform(*to_global);
                         }
-                        all_shapes.append(&mut list.0);
                     }
+                    all_shapes.append(&mut list.0);
                 }
             }
 
             // Also draw areas that are missing in `area_order`:
+            // NOTE: We don't think we end up here in normal situations.
+            // This is just a safety net in case we have some bug somewhere.
+            #[expect(clippy::iter_over_hash_type)]
             for (id, list) in order_map {
                 let layer_id = LayerId::new(order, *id);
 
                 if let Some(to_global) = to_global.get(&layer_id) {
                     for clipped_shape in &mut list.0 {
-                        clipped_shape.clip_rect = *to_global * clipped_shape.clip_rect;
-                        clipped_shape.shape.transform(*to_global);
+                        clipped_shape.transform(*to_global);
                     }
                 }
 
diff --git a/crates/egui/src/layout.rs b/crates/egui/src/layout.rs
index e967aaa6d..c44c928bb 100644
--- a/crates/egui/src/layout.rs
+++ b/crates/egui/src/layout.rs
@@ -1,8 +1,8 @@
 use emath::GuiRounding as _;
 
 use crate::{
-    emath::{pos2, vec2, Align2, NumExt, Pos2, Rect, Vec2},
     Align,
+    emath::{Align2, NumExt as _, Pos2, Rect, Vec2, pos2, vec2},
 };
 const INFINITY: f32 = f32::INFINITY;
 
@@ -50,8 +50,8 @@ pub(crate) struct Region {
 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);
+        self.min_rect |= rect;
+        self.max_rect |= rect;
     }
 
     /// Ensure we are big enough to contain the given X-coordinate.
@@ -71,9 +71,17 @@ impl Region {
     }
 
     pub fn sanity_check(&self) {
-        debug_assert!(!self.min_rect.any_nan());
-        debug_assert!(!self.max_rect.any_nan());
-        debug_assert!(!self.cursor.any_nan());
+        debug_assert!(
+            !self.min_rect.any_nan(),
+            "min rect has Nan: {:?}",
+            self.min_rect
+        );
+        debug_assert!(
+            !self.max_rect.any_nan(),
+            "max rect has Nan: {:?}",
+            self.max_rect
+        );
+        debug_assert!(!self.cursor.any_nan(), "cursor has Nan: {:?}", self.cursor);
     }
 }
 
@@ -394,8 +402,8 @@ impl Layout {
 /// ## Doing layout
 impl Layout {
     pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect {
-        debug_assert!(size.x >= 0.0 && size.y >= 0.0);
-        debug_assert!(!outer.is_negative());
+        debug_assert!(size.x >= 0.0 && size.y >= 0.0, "Negative size: {size:?}");
+        debug_assert!(!outer.is_negative(), "Negative outer: {outer:?}");
         self.align2().align_size_within_rect(size, outer).round_ui()
     }
 
@@ -421,7 +429,7 @@ impl Layout {
     }
 
     pub(crate) fn region_from_max_rect(&self, max_rect: Rect) -> Region {
-        debug_assert!(!max_rect.any_nan());
+        debug_assert!(!max_rect.any_nan(), "max_rect is not NaN: {max_rect:?}");
         let mut region = Region {
             min_rect: Rect::NOTHING, // temporary
             max_rect,
@@ -454,8 +462,8 @@ impl Layout {
     /// 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 {
-        debug_assert!(!cursor.any_nan());
-        debug_assert!(!max_rect.any_nan());
+        debug_assert!(!cursor.any_nan(), "cursor is NaN: {cursor:?}");
+        debug_assert!(!max_rect.any_nan(), "max_rect is NaN: {max_rect:?}");
 
         // NOTE: in normal top-down layout the cursor has moved below the current max_rect,
         // but the available shouldn't be negative.
@@ -509,7 +517,7 @@ impl Layout {
             avail.max.y = y;
         }
 
-        debug_assert!(!avail.any_nan());
+        debug_assert!(!avail.any_nan(), "avail is NaN: {avail:?}");
 
         avail
     }
@@ -520,7 +528,10 @@ impl Layout {
     /// 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();
-        debug_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+        debug_assert!(
+            child_size.x >= 0.0 && child_size.y >= 0.0,
+            "Negative size: {child_size:?}"
+        );
 
         if self.main_wrap {
             let available_size = self.available_rect_before_wrap(region).size();
@@ -600,7 +611,10 @@ impl Layout {
 
     fn next_frame_ignore_wrap(&self, region: &Region, child_size: Vec2) -> Rect {
         region.sanity_check();
-        debug_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+        debug_assert!(
+            child_size.x >= 0.0 && child_size.y >= 0.0,
+            "Negative size: {child_size:?}"
+        );
 
         let available_rect = self.available_rect_before_wrap(region);
 
@@ -633,16 +647,19 @@ impl Layout {
             frame_rect = frame_rect.translate(Vec2::Y * (region.cursor.top() - frame_rect.top()));
         }
 
-        debug_assert!(!frame_rect.any_nan());
-        debug_assert!(!frame_rect.is_negative());
+        debug_assert!(!frame_rect.any_nan(), "frame_rect is NaN: {frame_rect:?}");
+        debug_assert!(!frame_rect.is_negative(), "frame_rect is negative");
 
         frame_rect.round_ui()
     }
 
     /// 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 {
-        debug_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
-        debug_assert!(!frame.is_negative());
+        debug_assert!(
+            child_size.x >= 0.0 && child_size.y >= 0.0,
+            "Negative size: {child_size:?}"
+        );
+        debug_assert!(!frame.is_negative(), "frame is negative");
 
         if self.horizontal_justify() {
             child_size.x = child_size.x.at_least(frame.width()); // fill full width
@@ -660,8 +677,8 @@ impl Layout {
     ) -> Rect {
         let frame = self.next_frame_ignore_wrap(region, size);
         let rect = self.align_size_within_rect(size, frame);
-        debug_assert!(!rect.any_nan());
-        debug_assert!(!rect.is_negative());
+        debug_assert!(!rect.any_nan(), "rect is NaN: {rect:?}");
+        debug_assert!(!rect.is_negative(), "rect is negative: {rect:?}");
         rect
     }
 
@@ -704,11 +721,11 @@ impl Layout {
         widget_rect: Rect,
         item_spacing: Vec2,
     ) {
-        debug_assert!(!cursor.any_nan());
+        debug_assert!(!cursor.any_nan(), "cursor is NaN: {cursor:?}");
         if self.main_wrap {
             if cursor.intersects(frame_rect.shrink(1.0)) {
                 // make row/column larger if necessary
-                *cursor = cursor.union(frame_rect);
+                *cursor |= 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 {
@@ -736,7 +753,7 @@ impl Layout {
                             pos2(frame_rect.max.x, f32::NAN),
                         );
                     }
-                };
+                }
             }
         } else {
             // Make sure we also expand where we consider adding things (the cursor):
@@ -762,7 +779,7 @@ impl Layout {
             Direction::BottomUp => {
                 cursor.max.y = widget_rect.min.y - item_spacing.y;
             }
-        };
+        }
     }
 
     /// Move to the next row in a wrapping layout.
diff --git a/crates/egui/src/lib.rs b/crates/egui/src/lib.rs
index ff3f1cdf8..bd4319f0b 100644
--- a/crates/egui/src/lib.rs
+++ b/crates/egui/src/lib.rs
@@ -3,7 +3,7 @@
 //! 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.81.0 or later to use `egui`.
+//! You need to have rust 1.88.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).
@@ -143,7 +143,7 @@
 //! }
 //! ```
 //!
-//! For a reference OpenGL renderer, see [the `egui_glow` painter](https://github.com/emilk/egui/blob/master/crates/egui_glow/src/painter.rs).
+//! For a reference OpenGL renderer, see [the `egui_glow` painter](https://github.com/emilk/egui/blob/main/crates/egui_glow/src/painter.rs).
 //!
 //!
 //! ### Debugging your renderer
@@ -161,12 +161,10 @@
 //!
 //! * 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.
+//! * egui prefers gamma color spaces for all blending so:
+//!   * Do NOT use an sRGBA-aware texture (NOT `GL_SRGB8_ALPHA8`).
+//!   * Multiply texture and vertex colors in gamma space
+//!   * Turn OFF sRGBA/gamma framebuffer (NO `GL_FRAMEBUFFER_SRGB`).
 //!
 //!
 //! # Understanding immediate mode
@@ -219,7 +217,7 @@
 //! 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>.
+//! of how egui works: <https://github.com/emilk/egui/blob/main/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>.
 //!
@@ -400,11 +398,15 @@
 //! profile-with-puffin = ["profiling/profile-with-puffin"]
 //! ```
 //!
+//! ## Custom allocator
+//! egui apps can run significantly (~20%) faster by using a custom allocator, like [mimalloc](https://crates.io/crates/mimalloc) or [talc](https://crates.io/crates/talc).
+//!
 
 #![allow(clippy::float_cmp)]
 #![allow(clippy::manual_range_contains)]
 
 mod animation_manager;
+mod atomics;
 pub mod cache;
 pub mod containers;
 mod context;
@@ -422,11 +424,13 @@ pub mod layers;
 mod layout;
 pub mod load;
 mod memory;
+#[deprecated = "Use `egui::containers::menu` instead"]
 pub mod menu;
 pub mod os;
 mod painter;
 mod pass_state;
 pub(crate) mod placer;
+mod plugin;
 pub mod response;
 mod sense;
 pub mod style;
@@ -444,7 +448,6 @@ pub mod widgets;
 #[cfg(debug_assertions)]
 mod callstack;
 
-#[cfg(feature = "accesskit")]
 pub use accesskit;
 
 #[deprecated = "Use the ahash crate directly."]
@@ -458,45 +461,47 @@ pub use epaint::emath;
 pub use ecolor::hex_color;
 pub use ecolor::{Color32, Rgba};
 pub use emath::{
-    lerp, pos2, remap, remap_clamp, vec2, Align, Align2, NumExt, Pos2, Rangef, Rect, Vec2, Vec2b,
+    Align, Align2, NumExt, Pos2, Rangef, Rect, RectAlign, Vec2, Vec2b, lerp, pos2, remap,
+    remap_clamp, vec2,
 };
 pub use epaint::{
-    mutex,
+    ClippedPrimitive, ColorImage, CornerRadius, ImageData, Margin, Mesh, PaintCallback,
+    PaintCallbackInfo, Shadow, Shape, Stroke, StrokeKind, TextureHandle, TextureId, mutex,
     text::{FontData, FontDefinitions, FontFamily, FontId, FontTweak},
     textures::{TextureFilter, TextureOptions, TextureWrapMode, TexturesDelta},
-    ClippedPrimitive, ColorImage, CornerRadius, FontImage, ImageData, Margin, Mesh, PaintCallback,
-    PaintCallbackInfo, Shadow, Shape, Stroke, StrokeKind, TextureHandle, TextureId,
 };
 
 pub mod text {
-    pub use crate::text_selection::{CCursorRange, CursorRange};
+    pub use crate::text_selection::CCursorRange;
     pub use epaint::text::{
-        cursor::CCursor, FontData, FontDefinitions, FontFamily, Fonts, Galley, LayoutJob,
-        LayoutSection, TextFormat, TextWrapping, TAB_SIZE,
+        FontData, FontDefinitions, FontFamily, Fonts, Galley, LayoutJob, LayoutSection, TAB_SIZE,
+        TextFormat, TextWrapping, cursor::CCursor,
     };
 }
 
 pub use self::{
-    containers::*,
+    atomics::*,
+    containers::{menu::MenuBar, *},
     context::{Context, RepaintCause, RequestRepaintInfo},
     data::{
+        Key, UserData,
         input::*,
         output::{
             self, CursorIcon, FullOutput, OpenUrl, OutputCommand, PlatformOutput,
             UserAttentionType, WidgetInfo,
         },
-        Key, UserData,
     },
     drag_and_drop::DragAndDrop,
     epaint::text::TextWrapMode,
     grid::Grid,
     id::{Id, IdMap},
-    input_state::{InputState, MultiTouchInfo, PointerState},
+    input_state::{InputOptions, InputState, MultiTouchInfo, PointerState, SurrenderFocusOn},
     layers::{LayerId, Order},
     layout::*,
     load::SizeHint,
-    memory::{Memory, Options, Theme, ThemePreference},
+    memory::{FocusDirection, Memory, Options, Theme, ThemePreference},
     painter::Painter,
+    plugin::Plugin,
     response::{InnerResponse, Response},
     sense::Sense,
     style::{FontSelection, Spacing, Style, TextStyle, Visuals},
@@ -562,7 +567,7 @@ macro_rules! include_image {
 ///
 /// ```
 /// # egui::__run_test_ui(|ui| {
-/// ui.add(egui::github_link_file_line!("https://github.com/YOUR/PROJECT/blob/master/", "(source code)"));
+/// ui.add(egui::github_link_file_line!("https://github.com/YOUR/PROJECT/blob/main/", "(source code)"));
 /// # });
 /// ```
 #[macro_export]
@@ -577,7 +582,7 @@ macro_rules! github_link_file_line {
 ///
 /// ```
 /// # egui::__run_test_ui(|ui| {
-/// ui.add(egui::github_link_file!("https://github.com/YOUR/PROJECT/blob/master/", "(source code)"));
+/// ui.add(egui::github_link_file!("https://github.com/YOUR/PROJECT/blob/main/", "(source code)"));
 /// # });
 /// ```
 #[macro_export]
@@ -664,12 +669,12 @@ pub enum WidgetType {
 
     ColorButton,
 
-    ImageButton,
-
     Image,
 
     CollapsingHeader,
 
+    Panel,
+
     ProgressIndicator,
 
     Window,
@@ -702,7 +707,6 @@ pub fn __run_test_ui(add_contents: impl Fn(&mut Ui)) {
     });
 }
 
-#[cfg(feature = "accesskit")]
 pub fn accesskit_root_id() -> Id {
     Id::new("accesskit_root")
 }
diff --git a/crates/egui/src/load.rs b/crates/egui/src/load.rs
index 26950eb2a..1c74e5041 100644
--- a/crates/egui/src/load.rs
+++ b/crates/egui/src/load.rs
@@ -64,8 +64,8 @@ use std::{
 
 use ahash::HashMap;
 
-use emath::{Float, OrderedFloat};
-use epaint::{mutex::Mutex, textures::TextureOptions, ColorImage, TextureHandle, TextureId, Vec2};
+use emath::{Float as _, OrderedFloat};
+use epaint::{ColorImage, TextureHandle, TextureId, Vec2, mutex::Mutex, textures::TextureOptions};
 
 use crate::Context;
 
@@ -143,22 +143,53 @@ pub type Result<T, E = LoadError> = std::result::Result<T, E>;
 /// Given as a hint for image loading requests.
 ///
 /// Used mostly for rendering SVG:s to a good size.
-/// The size is measured in texels, with the pixels per point already factored in.
-///
-/// All variants will preserve the original aspect ratio.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+/// The [`SizeHint`] determines at what resolution the image should be rasterized.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum SizeHint {
-    /// Scale original size by some factor.
+    /// Scale original size by some factor, keeping the original aspect ratio.
+    ///
+    /// The original size of the image is usually its texel resolution,
+    /// but for an SVG it's the point size of the SVG.
+    ///
+    /// For instance, setting `Scale(2.0)` will rasterize SVG:s to twice their original size,
+    /// which is useful for high-DPI displays.
     Scale(OrderedFloat<f32>),
 
-    /// Scale to width.
+    /// Scale to exactly this pixel width, keeping the original aspect ratio.
     Width(u32),
 
-    /// Scale to height.
+    /// Scale to exactly this pixel height, keeping the original aspect ratio.
     Height(u32),
 
-    /// Scale to size.
-    Size(u32, u32),
+    /// Scale to this pixel size.
+    Size {
+        width: u32,
+        height: u32,
+
+        /// If true, the image will be as large as possible
+        /// while still fitting within the given width/height.
+        maintain_aspect_ratio: bool,
+    },
+}
+
+impl SizeHint {
+    /// Multiply size hint by a factor.
+    pub fn scale_by(self, factor: f32) -> Self {
+        match self {
+            Self::Scale(scale) => Self::Scale(OrderedFloat(factor * scale.0)),
+            Self::Width(width) => Self::Width((factor * width as f32).round() as _),
+            Self::Height(height) => Self::Height((factor * height as f32).round() as _),
+            Self::Size {
+                width,
+                height,
+                maintain_aspect_ratio,
+            } => Self::Size {
+                width: (factor * width as f32).round() as _,
+                height: (factor * height as f32).round() as _,
+                maintain_aspect_ratio,
+            },
+        }
+    }
 }
 
 impl Default for SizeHint {
@@ -168,13 +199,6 @@ impl Default for SizeHint {
     }
 }
 
-impl From<Vec2> for SizeHint {
-    #[inline]
-    fn from(value: Vec2) -> Self {
-        Self::Size(value.x.round() as u32, value.y.round() as u32)
-    }
-}
-
 /// Represents a byte buffer.
 ///
 /// This is essentially `Cow<'static, [u8]>` but with the `Owned` variant being an `Arc`.
@@ -249,12 +273,16 @@ impl Deref for Bytes {
 pub enum BytesPoll {
     /// Bytes are being loaded.
     Pending {
+        /// Point size of the image.
+        ///
         /// Set if known (e.g. from a HTTP header, or by parsing the image file header).
         size: Option<Vec2>,
     },
 
     /// Bytes are loaded.
     Ready {
+        /// Point size of the image.
+        ///
         /// Set if known (e.g. from a HTTP header, or by parsing the image file header).
         size: Option<Vec2>,
 
@@ -322,12 +350,17 @@ pub trait BytesLoader {
 
     /// Implementations may use this to perform work at the end of a frame,
     /// such as evicting unused entries from a cache.
-    fn end_pass(&self, frame_index: usize) {
-        let _ = frame_index;
+    fn end_pass(&self, pass_index: u64) {
+        let _ = pass_index;
     }
 
     /// If the loader caches any data, this should return the size of that cache.
     fn byte_size(&self) -> usize;
+
+    /// Returns `true` if some data is currently being loaded.
+    fn has_pending(&self) -> bool {
+        false
+    }
 }
 
 /// Represents an image which is currently being loaded.
@@ -339,6 +372,8 @@ pub trait BytesLoader {
 pub enum ImagePoll {
     /// Image is loading.
     Pending {
+        /// Point size of the image.
+        ///
         /// Set if known (e.g. from a HTTP header, or by parsing the image file header).
         size: Option<Vec2>,
     },
@@ -352,7 +387,7 @@ pub type ImageLoadResult = Result<ImagePoll>;
 /// An `ImageLoader` decodes raw bytes into a [`ColorImage`].
 ///
 /// Implementations are expected to cache at least each `URI`.
-pub trait ImageLoader {
+pub trait ImageLoader: std::any::Any {
     /// Unique ID of this loader.
     ///
     /// To reduce the chance of collisions, include `module_path!()` as part of this ID.
@@ -389,18 +424,27 @@ pub trait ImageLoader {
 
     /// Implementations may use this to perform work at the end of a pass,
     /// such as evicting unused entries from a cache.
-    fn end_pass(&self, frame_index: usize) {
-        let _ = frame_index;
+    fn end_pass(&self, pass_index: u64) {
+        let _ = pass_index;
     }
 
     /// If the loader caches any data, this should return the size of that cache.
     fn byte_size(&self) -> usize;
+
+    /// Returns `true` if some image is currently being loaded.
+    ///
+    /// NOTE: You probably also want to check [`BytesLoader::has_pending`].
+    fn has_pending(&self) -> bool {
+        false
+    }
 }
 
 /// A texture with a known size.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct SizedTexture {
     pub id: TextureId,
+
+    /// Point size of the original SVG, or the size of the image in texels.
     pub size: Vec2,
 }
 
@@ -446,6 +490,8 @@ impl<'a> From<&'a TextureHandle> for SizedTexture {
 pub enum TexturePoll {
     /// Texture is loading.
     Pending {
+        /// Point size of the image.
+        ///
         /// Set if known (e.g. from a HTTP header, or by parsing the image file header).
         size: Option<Vec2>,
     },
@@ -455,6 +501,7 @@ pub enum TexturePoll {
 }
 
 impl TexturePoll {
+    /// Point size of the original SVG, or the size of the image in texels.
     #[inline]
     pub fn size(&self) -> Option<Vec2> {
         match self {
@@ -470,6 +517,16 @@ impl TexturePoll {
             Self::Ready { texture } => Some(texture.id),
         }
     }
+
+    #[inline]
+    pub fn is_pending(&self) -> bool {
+        matches!(self, Self::Pending { .. })
+    }
+
+    #[inline]
+    pub fn is_ready(&self) -> bool {
+        matches!(self, Self::Ready { .. })
+    }
 }
 
 pub type TextureLoadResult = Result<TexturePoll>;
@@ -527,8 +584,8 @@ pub trait TextureLoader {
 
     /// Implementations may use this to perform work at the end of a pass,
     /// such as evicting unused entries from a cache.
-    fn end_pass(&self, frame_index: usize) {
-        let _ = frame_index;
+    fn end_pass(&self, pass_index: u64) {
+        let _ = pass_index;
     }
 
     /// If the loader caches any data, this should return the size of that cache.
@@ -560,3 +617,26 @@ impl Default for Loaders {
         }
     }
 }
+
+impl Loaders {
+    /// The given pass has just ended.
+    pub fn end_pass(&self, pass_index: u64) {
+        let Self {
+            include,
+            bytes,
+            image,
+            texture,
+        } = self;
+
+        include.end_pass(pass_index);
+        for loader in bytes.lock().iter() {
+            loader.end_pass(pass_index);
+        }
+        for loader in image.lock().iter() {
+            loader.end_pass(pass_index);
+        }
+        for loader in texture.lock().iter() {
+            loader.end_pass(pass_index);
+        }
+    }
+}
diff --git a/crates/egui/src/load/bytes_loader.rs b/crates/egui/src/load/bytes_loader.rs
index 9c70f54e1..6547a1e1d 100644
--- a/crates/egui/src/load/bytes_loader.rs
+++ b/crates/egui/src/load/bytes_loader.rs
@@ -1,6 +1,6 @@
 use super::{
-    generate_loader_id, Bytes, BytesLoadResult, BytesLoader, BytesPoll, Context, Cow, HashMap,
-    LoadError, Mutex,
+    Bytes, BytesLoadResult, BytesLoader, BytesPoll, Context, Cow, HashMap, LoadError, Mutex,
+    generate_loader_id,
 };
 
 /// Maps URI:s to [`Bytes`], e.g. found with `include_bytes!`.
@@ -19,7 +19,6 @@ impl DefaultBytesLoader {
             .or_insert_with_key(|_uri| {
                 let bytes: Bytes = bytes.into();
 
-                #[cfg(feature = "log")]
                 log::trace!("loaded {} bytes for uri {_uri:?}", bytes.len());
 
                 bytes
@@ -28,7 +27,7 @@ impl DefaultBytesLoader {
 }
 
 impl BytesLoader for DefaultBytesLoader {
-    fn id(&self) -> &str {
+    fn id(&self) -> &'static str {
         generate_loader_id!(DefaultBytesLoader)
     }
 
@@ -53,14 +52,12 @@ impl BytesLoader for DefaultBytesLoader {
     }
 
     fn forget(&self, uri: &str) {
-        #[cfg(feature = "log")]
         log::trace!("forget {uri:?}");
 
         self.cache.lock().remove(uri);
     }
 
     fn forget_all(&self) {
-        #[cfg(feature = "log")]
         log::trace!("forget all");
 
         self.cache.lock().clear();
diff --git a/crates/egui/src/load/texture_loader.rs b/crates/egui/src/load/texture_loader.rs
index a1170257c..e75b05070 100644
--- a/crates/egui/src/load/texture_loader.rs
+++ b/crates/egui/src/load/texture_loader.rs
@@ -1,17 +1,38 @@
-use std::borrow::Cow;
+use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
+
+use emath::Vec2;
 
 use super::{
-    BytesLoader, Context, HashMap, ImagePoll, Mutex, SizeHint, SizedTexture, TextureHandle,
+    BytesLoader as _, Context, HashMap, ImagePoll, Mutex, SizeHint, SizedTexture, TextureHandle,
     TextureLoadResult, TextureLoader, TextureOptions, TexturePoll,
 };
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+struct PrimaryKey {
+    uri: String,
+    texture_options: TextureOptions,
+}
+
+/// SVG:s might have several different sizes loaded
+type Bucket = HashMap<Option<SizeHint>, Entry>;
+
+struct Entry {
+    last_used: AtomicU64,
+
+    /// Size of the original SVG, if any, or the texel size of the image if not an SVG.
+    source_size: Vec2,
+
+    handle: TextureHandle,
+}
+
 #[derive(Default)]
 pub struct DefaultTextureLoader {
-    cache: Mutex<HashMap<(Cow<'static, str>, TextureOptions), TextureHandle>>,
+    pass_index: AtomicU64,
+    cache: Mutex<HashMap<PrimaryKey, Bucket>>,
 }
 
 impl TextureLoader for DefaultTextureLoader {
-    fn id(&self) -> &str {
+    fn id(&self) -> &'static str {
         crate::generate_loader_id!(DefaultTextureLoader)
     }
 
@@ -22,17 +43,47 @@ impl TextureLoader for DefaultTextureLoader {
         texture_options: TextureOptions,
         size_hint: SizeHint,
     ) -> TextureLoadResult {
+        let svg_size_hint = if is_svg(uri) {
+            // For SVGs it's important that we render at the desired size,
+            // or we might get a blurry image when we scale it up.
+            // So we make the size hint a part of the cache key.
+            // This might lead to a lot of extra entries for the same SVG file,
+            // which is potentially wasteful of RAM, but better that than blurry images.
+            Some(size_hint)
+        } else {
+            // For other images we just use one cache value, no matter what the size we render at.
+            None
+        };
+
         let mut cache = self.cache.lock();
-        if let Some(handle) = cache.get(&(Cow::Borrowed(uri), texture_options)) {
-            let texture = SizedTexture::from_handle(handle);
+        let bucket = cache
+            .entry(PrimaryKey {
+                uri: uri.to_owned(),
+                texture_options,
+            })
+            .or_default();
+
+        if let Some(texture) = bucket.get(&svg_size_hint) {
+            texture
+                .last_used
+                .store(self.pass_index.load(Relaxed), Relaxed);
+            let texture = SizedTexture::new(texture.handle.id(), texture.source_size);
             Ok(TexturePoll::Ready { texture })
         } else {
             match ctx.try_load_image(uri, size_hint)? {
                 ImagePoll::Pending { size } => Ok(TexturePoll::Pending { size }),
                 ImagePoll::Ready { image } => {
+                    let source_size = image.source_size;
                     let handle = ctx.load_texture(uri, image, texture_options);
-                    let texture = SizedTexture::from_handle(&handle);
-                    cache.insert((Cow::Owned(uri.to_owned()), texture_options), handle);
+                    let texture = SizedTexture::new(handle.id(), source_size);
+                    bucket.insert(
+                        svg_size_hint,
+                        Entry {
+                            last_used: AtomicU64::new(self.pass_index.load(Relaxed)),
+                            source_size,
+                            handle,
+                        },
+                    );
                     let reduce_texture_memory = ctx.options(|o| o.reduce_texture_memory);
                     if reduce_texture_memory {
                         let loaders = ctx.loaders();
@@ -51,26 +102,46 @@ impl TextureLoader for DefaultTextureLoader {
     }
 
     fn forget(&self, uri: &str) {
-        #[cfg(feature = "log")]
         log::trace!("forget {uri:?}");
 
-        self.cache.lock().retain(|(u, _), _| u != uri);
+        self.cache.lock().retain(|key, _value| key.uri != uri);
     }
 
     fn forget_all(&self) {
-        #[cfg(feature = "log")]
         log::trace!("forget all");
 
         self.cache.lock().clear();
     }
 
-    fn end_pass(&self, _: usize) {}
+    fn end_pass(&self, pass_index: u64) {
+        self.pass_index.store(pass_index, Relaxed);
+        let mut cache = self.cache.lock();
+        cache.retain(|_key, bucket| {
+            if 2 <= bucket.len() {
+                // There are multiple textures of the same URI (e.g. SVGs of different scales).
+                // This could be because someone has an SVG in a resizable container,
+                // and so we get a lot of different sizes of it.
+                // This could wast VRAM, so we remove the ones that are not used in this frame.
+                bucket.retain(|_, texture| pass_index <= texture.last_used.load(Relaxed) + 1);
+            }
+            !bucket.is_empty()
+        });
+    }
 
     fn byte_size(&self) -> usize {
         self.cache
             .lock()
             .values()
-            .map(|texture| texture.byte_size())
+            .map(|bucket| {
+                bucket
+                    .values()
+                    .map(|texture| texture.handle.byte_size())
+                    .sum::<usize>()
+            })
             .sum()
     }
 }
+
+fn is_svg(uri: &str) -> bool {
+    uri.ends_with(".svg")
+}
diff --git a/crates/egui/src/memory/mod.rs b/crates/egui/src/memory/mod.rs
index 2c669f0ff..6192f3e72 100644
--- a/crates/egui/src/memory/mod.rs
+++ b/crates/egui/src/memory/mod.rs
@@ -6,8 +6,8 @@ use ahash::{HashMap, HashSet};
 use epaint::emath::TSTransform;
 
 use crate::{
-    area, vec2, EventFilter, Id, IdMap, LayerId, Order, Pos2, Rangef, RawInput, Rect, Style, Vec2,
-    ViewportId, ViewportIdMap, ViewportIdSet,
+    EventFilter, Id, IdMap, LayerId, Order, Pos2, Rangef, RawInput, Rect, Style, Vec2, ViewportId,
+    ViewportIdMap, ViewportIdSet, area, vec2,
 };
 
 mod theme;
@@ -87,11 +87,6 @@ pub struct Memory {
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub(crate) viewport_id: ViewportId,
 
-    /// 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,
 
@@ -112,6 +107,15 @@ pub struct Memory {
 
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub(crate) focus: ViewportIdMap<Focus>,
+
+    /// Which popup-window is open on a viewport (if any)?
+    /// Could be a combo box, color picker, menu, etc.
+    /// Optionally stores the position of the popup (usually this would be the position where
+    /// the user clicked).
+    /// If position is [`None`], the popup position will be calculated based on some configuration
+    /// (e.g. relative to some other widget).
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    popups: ViewportIdMap<OpenPopup>,
 }
 
 impl Default for Memory {
@@ -126,7 +130,7 @@ impl Default for Memory {
             viewport_id: Default::default(),
             areas: Default::default(),
             to_global: Default::default(),
-            popup: Default::default(),
+            popups: Default::default(),
             everything_is_visible: Default::default(),
             add_fonts: Default::default(),
         };
@@ -136,8 +140,9 @@ impl Default for Memory {
     }
 }
 
+/// A direction in which to move the keyboard focus.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-enum FocusDirection {
+pub enum FocusDirection {
     /// Select the widget closest above the current focused widget.
     Up,
 
@@ -267,27 +272,11 @@ pub struct Options {
     /// which is supported by `eframe`.
     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`], or have a lot of text styles.
-    pub preload_font_glyphs: bool,
-
     /// Check reusing of [`Id`]s, and show a visual warning on screen when one is found.
     ///
     /// By default this is `true` in debug builds.
     pub warn_on_id_clash: bool,
 
-    // ------------------------------
-    // Input:
-    /// Multiplier for the scroll speed when reported in [`crate::MouseWheelUnit::Line`]s.
-    pub line_scroll_speed: f32,
-
-    /// Controls the speed at which we zoom in when doing ctrl/cmd + scroll.
-    pub scroll_zoom_speed: f32,
-
     /// Options related to input state handling.
     pub input_options: crate::input_state::InputOptions,
 
@@ -307,18 +296,10 @@ pub struct Options {
 
 impl Default for Options {
     fn default() -> Self {
-        // TODO(emilk): figure out why these constants need to be different on web and on native (winit).
-        let is_web = cfg!(target_arch = "wasm32");
-        let line_scroll_speed = if is_web {
-            8.0
-        } else {
-            40.0 // Scroll speed decided by consensus: https://github.com/emilk/egui/issues/461
-        };
-
         Self {
             dark_style: std::sync::Arc::new(Theme::Dark.default_style()),
             light_style: std::sync::Arc::new(Theme::Light.default_style()),
-            theme_preference: ThemePreference::System,
+            theme_preference: Default::default(),
             fallback_theme: Theme::Dark,
             system_theme: None,
             zoom_factor: 1.0,
@@ -327,12 +308,9 @@ impl Default for Options {
             repaint_on_widget_change: false,
             max_passes: NonZeroUsize::new(2).unwrap(),
             screen_reader: false,
-            preload_font_glyphs: true,
             warn_on_id_clash: cfg!(debug_assertions),
 
             // Input:
-            line_scroll_speed,
-            scroll_zoom_speed: 1.0 / 200.0,
             input_options: Default::default(),
             reduce_texture_memory: false,
         }
@@ -340,7 +318,9 @@ impl Default for Options {
 }
 
 impl Options {
-    pub(crate) fn begin_pass(&mut self, new_raw_input: &RawInput) {
+    // Needs to be pub because we need to set the system_theme early in the eframe glow renderer.
+    #[doc(hidden)]
+    pub fn begin_pass(&mut self, new_raw_input: &RawInput) {
         self.system_theme = new_raw_input.system_theme;
     }
 
@@ -379,23 +359,19 @@ impl Options {
             theme_preference,
             fallback_theme: _,
             system_theme: _,
-            zoom_factor: _, // TODO(emilk)
+            zoom_factor,
             zoom_with_keyboard,
             tessellation_options,
             repaint_on_widget_change,
             max_passes,
             screen_reader: _, // needs to come from the integration
-            preload_font_glyphs: _,
             warn_on_id_clash,
-
-            line_scroll_speed,
-            scroll_zoom_speed,
             input_options,
             reduce_texture_memory,
         } = self;
 
-        use crate::containers::CollapsingHeader;
         use crate::Widget as _;
+        use crate::containers::CollapsingHeader;
 
         CollapsingHeader::new("⚙ Options")
             .default_open(false)
@@ -410,6 +386,11 @@ impl Options {
                     "Repaint if any widget moves or changes id",
                 );
 
+                ui.horizontal(|ui| {
+                    ui.label("Zoom factor:");
+                    ui.add(crate::DragValue::new(zoom_factor).range(0.10..=10.0));
+                });
+
                 ui.checkbox(
                     zoom_with_keyboard,
                     "Zoom with keyboard (Cmd +, Cmd -, Cmd 0)",
@@ -425,11 +406,11 @@ impl Options {
             .show(ui, |ui| {
                 theme_preference.radio_buttons(ui);
 
-                std::sync::Arc::make_mut(match theme {
+                let style = std::sync::Arc::make_mut(match theme {
                     Theme::Dark => dark_style,
                     Theme::Light => light_style,
-                })
-                .ui(ui);
+                });
+                style.ui(ui);
             });
 
         CollapsingHeader::new("✒ Painting")
@@ -444,22 +425,6 @@ impl Options {
         CollapsingHeader::new("🖱 Input")
             .default_open(false)
             .show(ui, |ui| {
-                ui.horizontal(|ui| {
-                    ui.label("Line scroll speed");
-                    ui.add(crate::DragValue::new(line_scroll_speed).range(0.0..=f32::INFINITY))
-                        .on_hover_text(
-                            "How many lines to scroll with each tick of the mouse wheel",
-                        );
-                });
-                ui.horizontal(|ui| {
-                    ui.label("Scroll zoom speed");
-                    ui.add(
-                        crate::DragValue::new(scroll_zoom_speed)
-                            .range(0.0..=f32::INFINITY)
-                            .speed(0.001),
-                    )
-                    .on_hover_text("How fast to zoom with ctrl/cmd + scroll");
-                });
                 input_options.ui(ui);
             });
 
@@ -505,7 +470,6 @@ pub(crate) struct Focus {
     /// The ID of a widget to give the focus to in the 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.
@@ -564,65 +528,57 @@ impl Focus {
         }
         let event_filter = self.focused_widget.map(|w| w.filter).unwrap_or_default();
 
-        #[cfg(feature = "accesskit")]
-        {
-            self.id_requested_by_accesskit = None;
-        }
+        self.id_requested_by_accesskit = None;
 
         self.focus_direction = FocusDirection::None;
 
         for event in &new_input.events {
-            if !event_filter.matches(event) {
-                if let crate::Event::Key {
+            if !event_filter.matches(event)
+                && let crate::Event::Key {
                     key,
                     pressed: true,
                     modifiers,
                     ..
                 } = event
-                {
-                    if let Some(cardinality) = match key {
-                        crate::Key::ArrowUp => Some(FocusDirection::Up),
-                        crate::Key::ArrowRight => Some(FocusDirection::Right),
-                        crate::Key::ArrowDown => Some(FocusDirection::Down),
-                        crate::Key::ArrowLeft => Some(FocusDirection::Left),
+                && let Some(cardinality) = match key {
+                    crate::Key::ArrowUp => Some(FocusDirection::Up),
+                    crate::Key::ArrowRight => Some(FocusDirection::Right),
+                    crate::Key::ArrowDown => Some(FocusDirection::Down),
+                    crate::Key::ArrowLeft => Some(FocusDirection::Left),
 
-                        crate::Key::Tab => {
-                            if modifiers.shift {
-                                Some(FocusDirection::Previous)
-                            } else {
-                                Some(FocusDirection::Next)
-                            }
+                    crate::Key::Tab => {
+                        if modifiers.shift {
+                            Some(FocusDirection::Previous)
+                        } else {
+                            Some(FocusDirection::Next)
                         }
-                        crate::Key::Escape => {
-                            self.focused_widget = None;
-                            Some(FocusDirection::None)
-                        }
-                        _ => None,
-                    } {
-                        self.focus_direction = cardinality;
                     }
+                    crate::Key::Escape => {
+                        self.focused_widget = None;
+                        Some(FocusDirection::None)
+                    }
+                    _ => None,
                 }
+            {
+                self.focus_direction = cardinality;
             }
 
-            #[cfg(feature = "accesskit")]
+            if let crate::Event::AccessKitActionRequest(accesskit::ActionRequest {
+                action: accesskit::Action::Focus,
+                target,
+                data: None,
+            }) = event
             {
-                if let crate::Event::AccessKitActionRequest(accesskit::ActionRequest {
-                    action: accesskit::Action::Focus,
-                    target,
-                    data: None,
-                }) = event
-                {
-                    self.id_requested_by_accesskit = Some(*target);
-                }
+                self.id_requested_by_accesskit = Some(*target);
             }
         }
     }
 
     pub(crate) fn end_pass(&mut self, used_ids: &IdMap<Rect>) {
-        if self.focus_direction.is_cardinal() {
-            if let Some(found_widget) = self.find_widget_in_direction(used_ids) {
-                self.focused_widget = Some(FocusWidget::new(found_widget));
-            }
+        if self.focus_direction.is_cardinal()
+            && let Some(found_widget) = self.find_widget_in_direction(used_ids)
+        {
+            self.focused_widget = Some(FocusWidget::new(found_widget));
         }
 
         if let Some(focused_widget) = self.focused_widget {
@@ -643,14 +599,11 @@ impl Focus {
     }
 
     fn interested_in_focus(&mut self, id: Id) {
-        #[cfg(feature = "accesskit")]
-        {
-            if self.id_requested_by_accesskit == Some(id.accesskit_id()) {
-                self.focused_widget = Some(FocusWidget::new(id));
-                self.id_requested_by_accesskit = None;
-                self.give_to_next = false;
-                self.reset_focus();
-            }
+        if self.id_requested_by_accesskit == Some(id.accesskit_id()) {
+            self.focused_widget = Some(FocusWidget::new(id));
+            self.id_requested_by_accesskit = None;
+            self.give_to_next = false;
+            self.reset_focus();
         }
 
         // The rect is updated at the end of the frame.
@@ -744,6 +697,8 @@ impl Focus {
         let mut best_score = f32::INFINITY;
         let mut best_id = None;
 
+        // iteration order should only matter in case of a tie, and that should be very rare
+        #[expect(clippy::iter_over_hash_type)]
         for (candidate_id, candidate_rect) in &self.focus_widgets_cache {
             if *candidate_id == current_focused.id {
                 continue;
@@ -786,6 +741,7 @@ impl Memory {
         // Cleanup
         self.interactions.retain(|id, _| viewports.contains(id));
         self.areas.retain(|id, _| viewports.contains(id));
+        self.popups.retain(|id, _| viewports.contains(id));
 
         self.areas.entry(self.viewport_id).or_default();
 
@@ -803,6 +759,15 @@ impl Memory {
         self.caches.update();
         self.areas_mut().end_pass();
         self.focus_mut().end_pass(used_ids);
+
+        // Clean up abandoned popups.
+        if let Some(popup) = self.popups.get_mut(&self.viewport_id) {
+            if popup.open_this_frame {
+                popup.open_this_frame = false;
+            } else {
+                self.popups.remove(&self.viewport_id);
+            }
+        }
     }
 
     pub(crate) fn set_viewport_id(&mut self, viewport_id: ViewportId) {
@@ -823,15 +788,12 @@ impl Memory {
 
     /// Top-most layer at the given position.
     pub fn layer_id_at(&self, pos: Pos2) -> Option<LayerId> {
-        self.areas()
-            .layer_id_at(pos, &self.to_global)
-            .and_then(|layer_id| {
-                if self.is_above_modal_layer(layer_id) {
-                    Some(layer_id)
-                } else {
-                    self.top_modal_layer()
-                }
-            })
+        let layer_id = self.areas().layer_id_at(pos, &self.to_global)?;
+        if self.is_above_modal_layer(layer_id) {
+            Some(layer_id)
+        } else {
+            self.top_modal_layer()
+        }
     }
 
     /// The currently set transform of a layer.
@@ -876,7 +838,7 @@ impl Memory {
 
     /// Which widget has keyboard focus?
     pub fn focused(&self) -> Option<Id> {
-        self.focus().and_then(|f| f.focused())
+        self.focus()?.focused()
     }
 
     /// Set an event filter for a widget.
@@ -886,12 +848,12 @@ impl Memory {
     ///
     /// You must first give focus to the widget before calling this.
     pub fn set_focus_lock_filter(&mut self, id: Id, event_filter: EventFilter) {
-        if self.had_focus_last_frame(id) && self.has_focus(id) {
-            if let Some(focused) = &mut self.focus_mut().focused_widget {
-                if focused.id == id {
-                    focused.filter = event_filter;
-                }
-            }
+        if self.had_focus_last_frame(id)
+            && self.has_focus(id)
+            && let Some(focused) = &mut self.focus_mut().focused_widget
+            && focused.id == id
+        {
+            focused.filter = event_filter;
         }
     }
 
@@ -912,6 +874,11 @@ impl Memory {
         }
     }
 
+    /// Move keyboard focus in a specific direction.
+    pub fn move_focus(&mut self, direction: FocusDirection) {
+        self.focus_mut().focus_direction = direction;
+    }
+
     /// Returns true if
     /// - this layer is the top-most modal layer or above it
     /// - there is no modal layer
@@ -956,13 +923,13 @@ impl Memory {
     /// Limit focus to widgets on the given layer and above.
     /// If this is called multiple times per frame, the top layer wins.
     pub fn set_modal_layer(&mut self, layer_id: LayerId) {
-        if let Some(current) = self.focus().and_then(|f| f.top_modal_layer_current_frame) {
-            if matches!(
+        if let Some(current) = self.focus().and_then(|f| f.top_modal_layer_current_frame)
+            && matches!(
                 self.areas().compare_order(layer_id, current),
                 std::cmp::Ordering::Less
-            ) {
-                return;
-            }
+            )
+        {
+            return;
         }
 
         self.focus_mut().set_modal_layer(layer_id);
@@ -979,62 +946,10 @@ impl Memory {
         self.focus_mut().focused_widget = None;
     }
 
-    /// Is any widget being dragged?
-    #[deprecated = "Use `Context::dragged_id` instead"]
-    #[inline(always)]
-    pub fn is_anything_being_dragged(&self) -> bool {
-        self.interaction().potential_drag_id.is_some()
-    }
-
-    /// Is this specific widget being dragged?
-    ///
-    /// A widget that sense both clicks and drags is only marked as "dragged"
-    /// when the mouse has moved a bit, but `is_being_dragged` will return true immediately.
-    #[deprecated = "Use `Context::is_being_dragged` instead"]
-    #[inline(always)]
-    pub fn is_being_dragged(&self, id: Id) -> bool {
-        self.interaction().potential_drag_id == Some(id)
-    }
-
-    /// Get the id of the widget being dragged, if any.
-    ///
-    /// Note that this is set as soon as the mouse is pressed,
-    /// so the widget may not yet be marked as "dragged",
-    /// as that can only happen after the mouse has moved a bit
-    /// (at least if the widget is interesated in both clicks and drags).
-    #[deprecated = "Use `Context::dragged_id` instead"]
-    #[inline(always)]
-    pub fn dragged_id(&self) -> Option<Id> {
-        self.interaction().potential_drag_id
-    }
-
-    /// Set which widget is being dragged.
-    #[inline(always)]
-    #[deprecated = "Use `Context::set_dragged_id` instead"]
-    pub fn set_dragged_id(&mut self, id: Id) {
-        self.interaction_mut().potential_drag_id = Some(id);
-    }
-
-    /// Stop dragging any widget.
-    #[inline(always)]
-    #[deprecated = "Use `Context::stop_dragging` instead"]
-    pub fn stop_dragging(&mut self) {
-        self.interaction_mut().potential_drag_id = None;
-    }
-
-    /// Is something else being dragged?
-    ///
-    /// Returns true if we are dragging something, but not the given widget.
-    #[inline(always)]
-    #[deprecated = "Use `Context::dragging_something_else` instead"]
-    pub fn dragging_something_else(&self, not_this: Id) -> bool {
-        let drag_id = self.interaction().potential_drag_id;
-        drag_id.is_some() && drag_id != Some(not_this)
-    }
-
     /// Forget window positions, sizes etc.
     /// Can be used to auto-layout windows.
     pub fn reset_areas(&mut self) {
+        #[expect(clippy::iter_over_hash_type)]
         for area in self.areas.values_mut() {
             *area = Default::default();
         }
@@ -1064,41 +979,117 @@ impl Memory {
     }
 }
 
-/// ## Popups
-/// Popups are things like combo-boxes, color pickers, menus etc.
-/// Only one can be open at a time.
+/// State of an open popup.
+#[derive(Clone, Copy, Debug)]
+struct OpenPopup {
+    /// Id of the popup.
+    id: Id,
+
+    /// Optional position of the popup.
+    pos: Option<Pos2>,
+
+    /// Whether this popup was still open this frame. Otherwise it's considered abandoned and `Memory::popup` will be cleared.
+    open_this_frame: bool,
+}
+
+impl OpenPopup {
+    /// Create a new `OpenPopup`.
+    fn new(id: Id, pos: Option<Pos2>) -> Self {
+        Self {
+            id,
+            pos,
+            open_this_frame: true,
+        }
+    }
+}
+
+/// ## Deprecated popup API
+/// Use [`crate::Popup`] instead.
 impl Memory {
     /// Is the given popup open?
+    #[deprecated = "Use Popup::is_id_open instead"]
     pub fn is_popup_open(&self, popup_id: Id) -> bool {
-        self.popup == Some(popup_id) || self.everything_is_visible()
+        self.popups
+            .get(&self.viewport_id)
+            .is_some_and(|state| state.id == popup_id)
+            || self.everything_is_visible()
     }
 
     /// Is any popup open?
+    #[deprecated = "Use Popup::is_any_open instead"]
     pub fn any_popup_open(&self) -> bool {
-        self.popup.is_some() || self.everything_is_visible()
+        self.popups.contains_key(&self.viewport_id) || self.everything_is_visible()
     }
 
     /// Open the given popup and close all others.
+    ///
+    /// Note that you must call `keep_popup_open` on subsequent frames as long as the popup is open.
+    #[deprecated = "Use Popup::open_id instead"]
     pub fn open_popup(&mut self, popup_id: Id) {
-        self.popup = Some(popup_id);
+        self.popups
+            .insert(self.viewport_id, OpenPopup::new(popup_id, None));
     }
 
-    /// Close the open popup, if any.
-    pub fn close_popup(&mut self) {
-        self.popup = None;
+    /// Popups must call this every frame while open.
+    ///
+    /// This is needed because in some cases popups can go away without `close_popup` being
+    /// called. For example, when a context menu is open and the underlying widget stops
+    /// being rendered.
+    #[deprecated = "Use Popup::show instead"]
+    pub fn keep_popup_open(&mut self, popup_id: Id) {
+        if let Some(state) = self.popups.get_mut(&self.viewport_id)
+            && state.id == popup_id
+        {
+            state.open_this_frame = true;
+        }
+    }
+
+    /// Open the popup and remember its position.
+    #[deprecated = "Use Popup with PopupAnchor::Position instead"]
+    pub fn open_popup_at(&mut self, popup_id: Id, pos: impl Into<Option<Pos2>>) {
+        self.popups
+            .insert(self.viewport_id, OpenPopup::new(popup_id, pos.into()));
+    }
+
+    /// Get the position for this popup.
+    #[deprecated = "Use Popup::position_of_id instead"]
+    pub fn popup_position(&self, id: Id) -> Option<Pos2> {
+        let state = self.popups.get(&self.viewport_id)?;
+        if state.id == id { state.pos } else { None }
+    }
+
+    /// Close any currently open popup.
+    #[deprecated = "Use Popup::close_all instead"]
+    pub fn close_all_popups(&mut self) {
+        self.popups.clear();
+    }
+
+    /// Close the given popup, if it is open.
+    ///
+    /// See also [`Self::close_all_popups`] if you want to close any / all currently open popups.
+    #[deprecated = "Use Popup::close_id instead"]
+    pub fn close_popup(&mut self, popup_id: Id) {
+        #[expect(deprecated)]
+        if self.is_popup_open(popup_id) {
+            self.popups.remove(&self.viewport_id);
+        }
     }
 
     /// Toggle the given popup between closed and open.
     ///
     /// Note: At most, only one popup can be open at a time.
+    #[deprecated = "Use Popup::toggle_id instead"]
     pub fn toggle_popup(&mut self, popup_id: Id) {
+        #[expect(deprecated)]
         if self.is_popup_open(popup_id) {
-            self.close_popup();
+            self.close_popup(popup_id);
         } else {
             self.open_popup(popup_id);
         }
     }
+}
 
+impl Memory {
     /// If true, all windows, menus, tooltips, etc., will be visible at once.
     ///
     /// This is useful for testing, benchmarking, pre-caching, etc.
@@ -1199,17 +1190,17 @@ impl Areas {
         layer_to_global: &HashMap<LayerId, TSTransform>,
     ) -> 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 {
-                        if let Some(to_global) = layer_to_global.get(layer) {
-                            rect = *to_global * rect;
-                        }
+            if self.is_visible(layer)
+                && let Some(state) = self.areas.get(&layer.id)
+            {
+                let mut rect = state.rect();
+                if state.interactable {
+                    if let Some(to_global) = layer_to_global.get(layer) {
+                        rect = *to_global * rect;
+                    }
 
-                        if rect.contains(pos) {
-                            return Some(*layer);
-                        }
+                    if rect.contains(pos) {
+                        return Some(*layer);
                     }
                 }
             }
@@ -1246,7 +1237,7 @@ impl Areas {
         self.visible_areas_current_frame.insert(layer_id);
         self.wants_to_be_on_top.insert(layer_id);
 
-        if !self.order.iter().any(|x| *x == layer_id) {
+        if !self.order.contains(&layer_id) {
             self.order.push(layer_id);
         }
     }
@@ -1261,16 +1252,19 @@ impl Areas {
     ///
     /// The two layers must have the same [`LayerId::order`].
     pub fn set_sublayer(&mut self, parent: LayerId, child: LayerId) {
-        debug_assert_eq!(parent.order, child.order,
-            "DEBUG ASSERT: Trying to set sublayers across layers of different order ({:?}, {:?}), which is currently undefined behavior in egui", parent.order, child.order);
+        debug_assert_eq!(
+            parent.order, child.order,
+            "DEBUG ASSERT: Trying to set sublayers across layers of different order ({:?}, {:?}), which is currently undefined behavior in egui",
+            parent.order, child.order
+        );
 
         self.sublayers.entry(parent).or_default().insert(child);
 
         // Make sure the layers are in the order list:
-        if !self.order.iter().any(|x| *x == parent) {
+        if !self.order.contains(&parent) {
             self.order.push(parent);
         }
-        if !self.order.iter().any(|x| *x == child) {
+        if !self.order.contains(&child) {
             self.order.push(child);
         }
     }
@@ -1279,7 +1273,7 @@ impl Areas {
         self.order
             .iter()
             .filter(|layer| layer.order == order && !self.is_sublayer(layer))
-            .last()
+            .next_back()
             .copied()
     }
 
@@ -1320,12 +1314,14 @@ impl Areas {
         wants_to_be_on_top.clear();
 
         // For all layers with sublayers, put the sublayers directly after the parent layer:
-        let sublayers = std::mem::take(sublayers);
-        for (parent, children) in sublayers {
-            let mut moved_layers = vec![parent];
+        // (it doesn't matter in which order we replace parents with their children)
+        #[expect(clippy::iter_over_hash_type)]
+        for (parent, children) in std::mem::take(sublayers) {
+            let mut moved_layers = vec![parent]; // parent first…
+
             order.retain(|l| {
                 if children.contains(l) {
-                    moved_layers.push(*l);
+                    moved_layers.push(*l); // …followed by children
                     false
                 } else {
                     true
@@ -1334,7 +1330,7 @@ impl Areas {
             let Some(parent_pos) = order.iter().position(|l| l == &parent) else {
                 continue;
             };
-            order.splice(parent_pos..=parent_pos, moved_layers);
+            order.splice(parent_pos..=parent_pos, moved_layers); // replace the parent with itself and its children
         }
 
         self.order_map = self
diff --git a/crates/egui/src/memory/theme.rs b/crates/egui/src/memory/theme.rs
index 6d027b3be..555edaedd 100644
--- a/crates/egui/src/memory/theme.rs
+++ b/crates/egui/src/memory/theme.rs
@@ -30,11 +30,7 @@ impl Theme {
 
     /// Chooses between [`Self::Dark`] or [`Self::Light`] based on a boolean value.
     pub fn from_dark_mode(dark_mode: bool) -> Self {
-        if dark_mode {
-            Self::Dark
-        } else {
-            Self::Light
-        }
+        if dark_mode { Self::Dark } else { Self::Light }
     }
 }
 
@@ -66,7 +62,7 @@ impl Theme {
 }
 
 /// The user's theme preference.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum ThemePreference {
     /// Dark mode: light text on a dark background.
@@ -76,6 +72,7 @@ pub enum ThemePreference {
     Light,
 
     /// Follow the system's theme preference.
+    #[default]
     System,
 }
 
@@ -92,9 +89,32 @@ impl ThemePreference {
     /// Show radio-buttons to switch between light mode, dark mode and following the system theme.
     pub fn 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");
-            ui.selectable_value(self, Self::System, "💻 System");
+            let system_theme = ui.ctx().input(|i| i.raw.system_theme);
+
+            ui.selectable_value(self, Self::System, "💻 System")
+                .on_hover_ui(|ui| {
+                    ui.label("Follow the system theme preference.");
+
+                    ui.add_space(4.0);
+
+                    if let Some(system_theme) = system_theme {
+                        ui.label(format!(
+                            "The current system theme is: {}",
+                            match system_theme {
+                                Theme::Dark => "dark",
+                                Theme::Light => "light",
+                            }
+                        ));
+                    } else {
+                        ui.label("The system theme is unknown.");
+                    }
+                });
+
+            ui.selectable_value(self, Self::Dark, "🌙 Dark")
+                .on_hover_text("Use the dark mode theme");
+
+            ui.selectable_value(self, Self::Light, "☀ Light")
+                .on_hover_text("Use the light mode theme");
         });
     }
 }
diff --git a/crates/egui/src/menu.rs b/crates/egui/src/menu.rs
index 7a04087eb..4144a8cd9 100644
--- a/crates/egui/src/menu.rs
+++ b/crates/egui/src/menu.rs
@@ -1,4 +1,5 @@
-//! Menu bar functionality (very basic so far).
+#![allow(deprecated)]
+//! Deprecated menu API - Use [`crate::containers::menu`] instead.
 //!
 //! Usage:
 //! ```
@@ -16,14 +17,13 @@
 //! ```
 
 use super::{
-    style::WidgetVisuals, Align, Context, Id, InnerResponse, PointerState, Pos2, Rect, Response,
-    Sense, TextStyle, Ui, Vec2,
+    Align, Context, Id, InnerResponse, PointerState, Pos2, Rect, Response, Sense, TextStyle, Ui,
+    Vec2, style::WidgetVisuals,
 };
 use crate::{
-    epaint, vec2,
+    Align2, Area, Color32, Frame, Key, LayerId, Layout, NumExt as _, Order, Stroke, Style,
+    TextWrapMode, UiKind, WidgetText, epaint, vec2,
     widgets::{Button, ImageButton},
-    Align2, Area, Color32, Frame, Key, LayerId, Layout, NumExt, Order, Stroke, Style, TextWrapMode,
-    UiKind, WidgetText,
 };
 use epaint::mutex::RwLock;
 use std::sync::Arc;
@@ -75,16 +75,19 @@ impl std::ops::DerefMut for BarState {
 }
 
 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;
+    if style.compact_menu_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 [`crate::Panel::top`],
 /// but can also be placed in a [`crate::Window`].
 /// In the latter case you may want to wrap it in [`Frame`].
+#[deprecated = "Use `egui::MenuBar::new().ui(` instead"]
 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());
@@ -146,7 +149,7 @@ pub fn menu_image_button<R>(
 /// Opens on hover.
 ///
 /// Returns `None` if the menu is not open.
-pub(crate) fn submenu_button<R>(
+pub fn submenu_button<R>(
     ui: &mut Ui,
     parent_state: Arc<RwLock<MenuState>>,
     title: impl Into<WidgetText>,
@@ -267,7 +270,7 @@ fn stationary_menu_button_impl<'c, R>(
 pub(crate) const CONTEXT_MENU_ID_STR: &str = "__egui::context_menu";
 
 /// Response to secondary clicks (right-clicks) by showing the given menu.
-pub(crate) fn context_menu(
+pub fn context_menu(
     response: &Response,
     add_contents: impl FnOnce(&mut Ui),
 ) -> Option<InnerResponse<()>> {
@@ -282,7 +285,7 @@ pub(crate) fn context_menu(
 }
 
 /// Returns `true` if the context menu is opened for this widget.
-pub(crate) fn context_menu_opened(response: &Response) -> bool {
+pub fn context_menu_opened(response: &Response) -> bool {
     let menu_id = Id::new(CONTEXT_MENU_ID_STR);
     let bar_state = BarState::load(&response.ctx, menu_id);
     bar_state.is_menu_open(response.id)
@@ -364,7 +367,10 @@ impl MenuRoot {
             let menu_state = self.menu_state.read();
 
             let escape_pressed = button.ctx.input(|i| i.key_pressed(Key::Escape));
-            if menu_state.response.is_close() || escape_pressed {
+            if menu_state.response.is_close()
+                || escape_pressed
+                || inner_response.response.should_close()
+            {
                 return (MenuResponse::Close, Some(inner_response));
             }
         }
@@ -395,14 +401,14 @@ impl MenuRoot {
 
             if let Some(root) = root.inner.as_mut() {
                 let menu_rect = root.menu_state.read().rect;
-                let screen_rect = button.ctx.input(|i| i.screen_rect);
+                let content_rect = button.ctx.input(|i| i.content_rect());
 
-                if pos.y + menu_rect.height() > screen_rect.max.y {
-                    pos.y = screen_rect.max.y - menu_rect.height() - button.rect.height();
+                if pos.y + menu_rect.height() > content_rect.max.y {
+                    pos.y = content_rect.max.y - menu_rect.height() - button.rect.height();
                 }
 
-                if pos.x + menu_rect.width() > screen_rect.max.x {
-                    pos.x = screen_rect.max.x - menu_rect.width();
+                if pos.x + menu_rect.width() > content_rect.max.x {
+                    pos.x = content_rect.max.x - menu_rect.width();
                 }
             }
 
@@ -414,17 +420,14 @@ impl MenuRoot {
         } else if button
             .ctx
             .input(|i| i.pointer.any_pressed() && i.pointer.primary_down())
+            && let Some(pos) = button.ctx.input(|i| i.pointer.interact_pos())
+            && let Some(root) = root.inner.as_mut()
+            && root.id == id
         {
-            if let Some(pos) = button.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 in_menu = root.menu_state.read().area_contains(pos);
-                        if !in_menu {
-                            return MenuResponse::Close;
-                        }
-                    }
-                }
+            // pressed somewhere while this menu is open
+            let in_menu = root.menu_state.read().area_contains(pos);
+            if !in_menu {
+                return MenuResponse::Close;
             }
         }
         MenuResponse::Stay
@@ -439,12 +442,13 @@ impl MenuRoot {
         response.ctx.input(|input| {
             let pointer = &input.pointer;
             if let Some(pos) = pointer.interact_pos() {
-                let mut in_old_menu = false;
-                let mut destroy = false;
-                if let Some(root) = root {
-                    in_old_menu = root.menu_state.read().area_contains(pos);
-                    destroy = !in_old_menu && pointer.any_pressed() && root.id == response.id;
-                }
+                let (in_old_menu, destroy) = if let Some(root) = root {
+                    let in_old_menu = root.menu_state.read().area_contains(pos);
+                    let destroy = !in_old_menu && pointer.any_pressed() && root.id == response.id;
+                    (in_old_menu, destroy)
+                } else {
+                    (false, false)
+                };
                 if !in_old_menu {
                     if hovered && secondary_clicked {
                         return MenuResponse::Create(pos, response.id);
@@ -667,6 +671,9 @@ impl MenuState {
     ) -> Option<R> {
         let (sub_response, response) = self.submenu(id).map(|sub| {
             let inner_response = menu_popup(ctx, parent_layer, sub, id, add_contents);
+            if inner_response.response.should_close() {
+                sub.write().close();
+            }
             (sub.read().response, inner_response.inner)
         })?;
         self.cascade_close_response(sub_response);
@@ -718,21 +725,21 @@ impl MenuState {
             return false;
         }
 
-        if let Some(sub_menu) = self.current_submenu() {
-            if let Some(pos) = pointer.hover_pos() {
-                let rect = sub_menu.read().rect;
-                return rect.intersects_ray(pos, pointer.direction().normalized());
-            }
+        if let Some(sub_menu) = self.current_submenu()
+            && let Some(pos) = pointer.hover_pos()
+        {
+            let rect = sub_menu.read().rect;
+            return rect.intersects_ray(pos, pointer.direction().normalized());
         }
         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);
-            }
+        if let Some(sub_menu) = self.current_submenu()
+            && let Some(pos) = pointer.hover_pos()
+        {
+            return sub_menu.read().area_contains(pos);
         }
         false
     }
@@ -757,9 +764,8 @@ impl MenuState {
     }
 
     fn submenu(&self, id: Id) -> Option<&Arc<RwLock<Self>>> {
-        self.sub_menu
-            .as_ref()
-            .and_then(|(k, sub)| if id == *k { Some(sub) } else { None })
+        let (k, sub) = self.sub_menu.as_ref()?;
+        if id == *k { Some(sub) } else { None }
     }
 
     /// Open submenu at position, if not already open.
diff --git a/crates/egui/src/os.rs b/crates/egui/src/os.rs
index 766ecf55a..407a5335b 100644
--- a/crates/egui/src/os.rs
+++ b/crates/egui/src/os.rs
@@ -1,5 +1,5 @@
 /// An `enum` of common operating systems.
-#[allow(clippy::upper_case_acronyms)] // `Ios` looks too ugly
+#[expect(clippy::upper_case_acronyms)] // `Ios` looks too ugly
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum OperatingSystem {
     /// Unknown OS - could be wasm
@@ -68,12 +68,16 @@ impl OperatingSystem {
         {
             Self::Nix
         } else {
-            #[cfg(feature = "log")]
             log::warn!(
-                "egui: Failed to guess operating system from User-Agent {:?}. Please file an issue at https://github.com/emilk/egui/issues",
-                user_agent);
+                "egui: Failed to guess operating system from User-Agent {user_agent:?}. Please file an issue at https://github.com/emilk/egui/issues"
+            );
 
             Self::Unknown
         }
     }
+
+    /// Are we either macOS or iOS?
+    pub fn is_mac(&self) -> bool {
+        matches!(self, Self::Mac | Self::IOS)
+    }
 }
diff --git a/crates/egui/src/painter.rs b/crates/egui/src/painter.rs
index 22a0a0a9d..f121c8557 100644
--- a/crates/egui/src/painter.rs
+++ b/crates/egui/src/painter.rs
@@ -2,14 +2,14 @@ use std::sync::Arc;
 
 use emath::GuiRounding as _;
 use epaint::{
-    text::{Fonts, Galley, LayoutJob},
     CircleShape, ClippedShape, CornerRadius, PathStroke, RectShape, Shape, Stroke, StrokeKind,
+    text::{FontsView, Galley, LayoutJob},
 };
 
 use crate::{
+    Color32, Context, FontId,
     emath::{Align2, Pos2, Rangef, Rect, Vec2},
     layers::{LayerId, PaintList, ShapeIdx},
-    Color32, Context, FontId,
 };
 
 /// Helper to paint shapes and text to a specific region on a specific layer.
@@ -83,6 +83,7 @@ impl Painter {
     }
 
     /// If set, colors will be modified to look like this
+    #[deprecated = "Use `multiply_opacity` instead"]
     pub fn set_fade_to_color(&mut self, fade_to_color: Option<Color32>) {
         self.fade_to_color = fade_to_color;
     }
@@ -140,14 +141,22 @@ impl Painter {
         self.pixels_per_point
     }
 
-    /// Read-only access to the shared [`Fonts`].
+    /// Read-only access to the shared [`FontsView`].
     ///
     /// See [`Context`] documentation for how locks work.
     #[inline]
-    pub fn fonts<R>(&self, reader: impl FnOnce(&Fonts) -> R) -> R {
+    pub fn fonts<R>(&self, reader: impl FnOnce(&FontsView<'_>) -> R) -> R {
         self.ctx.fonts(reader)
     }
 
+    /// Read-write access to the shared [`FontsView`].
+    ///
+    /// See [`Context`] documentation for how locks work.
+    #[inline]
+    pub fn fonts_mut<R>(&self, reader: impl FnOnce(&mut FontsView<'_>) -> R) -> R {
+        self.ctx.fonts_mut(reader)
+    }
+
     /// Where we paint
     #[inline]
     pub fn layer_id(&self) -> LayerId {
@@ -294,7 +303,7 @@ impl Painter {
 
 /// ## Debug painting
 impl Painter {
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn debug_rect(&self, rect: Rect, color: Color32, text: impl ToString) {
         self.rect(
             rect,
@@ -320,7 +329,7 @@ impl Painter {
     /// Text with a background.
     ///
     /// See also [`Context::debug_text`].
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn debug_text(
         &self,
         pos: Pos2,
@@ -497,7 +506,7 @@ impl Painter {
     /// [`Self::layout`] or [`Self::layout_no_wrap`].
     ///
     /// Returns where the text ended up.
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn text(
         &self,
         pos: Pos2,
@@ -524,7 +533,7 @@ impl Painter {
         color: crate::Color32,
         wrap_width: f32,
     ) -> Arc<Galley> {
-        self.fonts(|f| f.layout(text, font_id, color, wrap_width))
+        self.fonts_mut(|f| f.layout(text, font_id, color, wrap_width))
     }
 
     /// Will line break at `\n`.
@@ -538,7 +547,7 @@ impl Painter {
         font_id: FontId,
         color: crate::Color32,
     ) -> Arc<Galley> {
-        self.fonts(|f| f.layout(text, font_id, color, f32::INFINITY))
+        self.fonts_mut(|f| f.layout(text, font_id, color, f32::INFINITY))
     }
 
     /// Lay out this text layut job in a galley.
@@ -547,7 +556,7 @@ impl Painter {
     #[inline]
     #[must_use]
     pub fn layout_job(&self, layout_job: LayoutJob) -> Arc<Galley> {
-        self.fonts(|f| f.layout_job(layout_job))
+        self.fonts_mut(|f| f.layout_job(layout_job))
     }
 
     /// Paint text that has already been laid out in a [`Galley`].
@@ -582,16 +591,6 @@ impl Painter {
             ));
         }
     }
-
-    #[deprecated = "Use `Painter::galley` or `Painter::galley_with_override_text_color` instead"]
-    #[inline]
-    pub fn galley_with_color(&self, pos: Pos2, galley: Arc<Galley>, text_color: Color32) {
-        if !galley.is_empty() {
-            self.add(Shape::galley_with_override_text_color(
-                pos, galley, text_color,
-            ));
-        }
-    }
 }
 
 fn tint_shape_towards(shape: &mut Shape, target: Color32) {
diff --git a/crates/egui/src/pass_state.rs b/crates/egui/src/pass_state.rs
index 942001c73..9b323bfa0 100644
--- a/crates/egui/src/pass_state.rs
+++ b/crates/egui/src/pass_state.rs
@@ -1,9 +1,9 @@
 use ahash::HashMap;
 
-use crate::{id::IdSet, style, Align, Id, IdMap, LayerId, Rangef, Rect, Vec2, WidgetRects};
+use crate::{Align, Id, IdMap, LayerId, Rangef, Rect, Vec2, WidgetRects, id::IdSet, style};
 
 #[cfg(debug_assertions)]
-use crate::{pos2, Align2, Color32, FontId, NumExt, Painter};
+use crate::{Align2, Color32, FontId, NumExt as _, Painter, pos2};
 
 /// Reset at the start of each frame.
 #[derive(Clone, Debug, Default)]
@@ -67,11 +67,10 @@ impl ScrollTarget {
     }
 }
 
-#[cfg(feature = "accesskit")]
 #[derive(Clone)]
 pub struct AccessKitPassState {
     pub nodes: IdMap<accesskit::Node>,
-    pub parent_stack: Vec<Id>,
+    pub parent_map: IdMap<Id>,
 }
 
 #[cfg(debug_assertions)]
@@ -137,7 +136,7 @@ impl DebugRect {
             let galley = painter.layout_no_wrap(text, font_id, text_color);
 
             // Position the text either under or above:
-            let screen_rect = ctx.screen_rect();
+            let content_rect = ctx.content_rect();
             let y = if galley.size().y <= rect.top() {
                 // Above
                 rect.top() - galley.size().y - 16.0
@@ -147,12 +146,12 @@ impl DebugRect {
             };
 
             let y = y
-                .at_most(screen_rect.bottom() - galley.size().y)
+                .at_most(content_rect.bottom() - galley.size().y)
                 .at_least(0.0);
 
             let x = rect
                 .left()
-                .at_most(screen_rect.right() - galley.size().x)
+                .at_most(content_rect.right() - galley.size().x)
                 .at_least(0.0);
             let text_pos = pos2(x, y);
 
@@ -202,7 +201,6 @@ pub struct PassState {
 
     /// Starts off as the `screen_rect`, shrinks as panels are added.
     /// The [`crate::CentralPanel`] does not change this.
-    /// This is the area available to Window's.
     pub available_rect: Rect,
 
     /// Starts off as the `screen_rect`, shrinks as panels are added.
@@ -226,7 +224,6 @@ pub struct PassState {
     /// as when swiping down on a touch-screen or track-pad with natural scrolling.
     pub scroll_delta: (Vec2, style::ScrollAnimation),
 
-    #[cfg(feature = "accesskit")]
     pub accesskit_state: Option<AccessKitPassState>,
 
     /// Highlight these widgets the next pass.
@@ -248,7 +245,6 @@ impl Default for PassState {
             used_by_panels: Rect::NAN,
             scroll_target: [None, None],
             scroll_delta: (Vec2::default(), style::ScrollAnimation::none()),
-            #[cfg(feature = "accesskit")]
             accesskit_state: None,
             highlight_next_pass: Default::default(),
 
@@ -259,7 +255,7 @@ impl Default for PassState {
 }
 
 impl PassState {
-    pub(crate) fn begin_pass(&mut self, screen_rect: Rect) {
+    pub(crate) fn begin_pass(&mut self, content_rect: Rect) {
         profiling::function_scope!();
         let Self {
             used_ids,
@@ -271,7 +267,6 @@ impl PassState {
             used_by_panels,
             scroll_target,
             scroll_delta,
-            #[cfg(feature = "accesskit")]
             accesskit_state,
             highlight_next_pass,
 
@@ -283,8 +278,8 @@ impl PassState {
         widgets.clear();
         tooltips.clear();
         layers.clear();
-        *available_rect = screen_rect;
-        *unused_rect = screen_rect;
+        *available_rect = content_rect;
+        *unused_rect = content_rect;
         *used_by_panels = Rect::NOTHING;
         *scroll_target = [None, None];
         *scroll_delta = Default::default();
@@ -294,17 +289,12 @@ impl PassState {
             *debug_rect = None;
         }
 
-        #[cfg(feature = "accesskit")]
-        {
-            *accesskit_state = None;
-        }
+        *accesskit_state = None;
 
         highlight_next_pass.clear();
     }
 
     /// 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 {
         debug_assert!(
             self.available_rect.is_finite(),
@@ -321,7 +311,7 @@ impl PassState {
         );
         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);
+        self.used_by_panels |= panel_rect;
     }
 
     /// Shrink `available_rect`.
@@ -332,7 +322,7 @@ impl PassState {
         );
         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);
+        self.used_by_panels |= panel_rect;
     }
 
     /// Shrink `available_rect`.
@@ -343,7 +333,7 @@ impl PassState {
         );
         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);
+        self.used_by_panels |= panel_rect;
     }
 
     /// Shrink `available_rect`.
@@ -354,13 +344,13 @@ impl PassState {
         );
         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);
+        self.used_by_panels |= 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);
+        self.used_by_panels |= panel_rect;
     }
 }
diff --git a/crates/egui/src/placer.rs b/crates/egui/src/placer.rs
index 2de822c03..b5f68f72d 100644
--- a/crates/egui/src/placer.rs
+++ b/crates/egui/src/placer.rs
@@ -1,4 +1,4 @@
-use crate::{grid, vec2, Layout, Painter, Pos2, Rect, Region, Vec2};
+use crate::{Layout, Painter, Pos2, Rect, Region, Vec2, grid, vec2};
 
 #[cfg(debug_assertions)]
 use crate::{Align2, Color32, Stroke};
@@ -133,8 +133,8 @@ impl Placer {
 
     /// Apply justify or alignment after calling `next_space`.
     pub(crate) fn justify_and_align(&self, rect: Rect, child_size: Vec2) -> Rect {
-        debug_assert!(!rect.any_nan());
-        debug_assert!(!child_size.any_nan());
+        debug_assert!(!rect.any_nan(), "rect: {rect:?}");
+        debug_assert!(!child_size.any_nan(), "child_size is NaN: {child_size:?}");
 
         if let Some(grid) = &self.grid {
             grid.justify_and_align(rect, child_size)
@@ -145,6 +145,8 @@ impl Placer {
 
     /// Advance the cursor by this many points.
     /// [`Self::min_rect`] will expand to contain the cursor.
+    ///
+    /// Note that `advance_cursor` isn't supported when in a grid layout.
     pub(crate) fn advance_cursor(&mut self, amount: f32) {
         debug_assert!(
             self.grid.is_none(),
@@ -164,8 +166,11 @@ impl Placer {
         widget_rect: Rect,
         item_spacing: Vec2,
     ) {
-        debug_assert!(!frame_rect.any_nan());
-        debug_assert!(!widget_rect.any_nan());
+        debug_assert!(!frame_rect.any_nan(), "frame_rect: {frame_rect:?}");
+        debug_assert!(
+            !widget_rect.any_nan(),
+            "widget_rect is NaN: {widget_rect:?}"
+        );
         self.region.sanity_check();
 
         if let Some(grid) = &mut self.grid {
@@ -228,7 +233,7 @@ impl Placer {
         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.max_rect |= 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;
@@ -243,7 +248,7 @@ impl Placer {
         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.max_rect |= 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;
diff --git a/crates/egui/src/plugin.rs b/crates/egui/src/plugin.rs
new file mode 100644
index 000000000..80afc4510
--- /dev/null
+++ b/crates/egui/src/plugin.rs
@@ -0,0 +1,247 @@
+use crate::{Context, FullOutput, RawInput};
+use ahash::HashMap;
+use epaint::mutex::{Mutex, MutexGuard};
+use std::sync::Arc;
+
+/// A plugin to extend egui.
+///
+/// Add plugins via [`Context::add_plugin`].
+///
+/// Plugins should not hold a reference to the [`Context`], since this would create a cycle
+/// (which would prevent the [`Context`] from being dropped).
+#[expect(unused_variables)]
+pub trait Plugin: Send + Sync + std::any::Any + 'static {
+    /// Plugin name.
+    ///
+    /// Used when profiling.
+    fn debug_name(&self) -> &'static str;
+
+    /// Called once, when the plugin is registered.
+    ///
+    /// Useful to e.g. register image loaders.
+    fn setup(&mut self, ctx: &Context) {}
+
+    /// Called at the start of each pass.
+    ///
+    /// Can be used to show ui, e.g. a [`crate::Window`] or [`crate::SidePanel`].
+    fn on_begin_pass(&mut self, ctx: &Context) {}
+
+    /// Called at the end of each pass.
+    ///
+    /// Can be used to show ui, e.g. a [`crate::Window`].
+    fn on_end_pass(&mut self, ctx: &Context) {}
+
+    /// Called just before the input is processed.
+    ///
+    /// Useful to inspect or modify the input.
+    /// Since this is called outside a pass, don't show ui here. Using `Context::debug_painter` is fine though.
+    fn input_hook(&mut self, input: &mut RawInput) {}
+
+    /// Called just before the output is passed to the backend.
+    ///
+    /// Useful to inspect or modify the output.
+    /// Since this is called outside a pass, don't show ui here. Using `Context::debug_painter` is fine though.
+    fn output_hook(&mut self, output: &mut FullOutput) {}
+
+    /// Called when a widget is created and is under the pointer.
+    ///
+    /// Useful for capturing a stack trace so that widgets can be mapped back to their source code.
+    /// Since this is called outside a pass, don't show ui here. Using `Context::debug_painter` is fine though.
+    #[cfg(debug_assertions)]
+    fn on_widget_under_pointer(&mut self, ctx: &Context, widget: &crate::WidgetRect) {}
+}
+
+pub(crate) struct PluginHandle {
+    plugin: Box<dyn Plugin>,
+}
+
+pub struct TypedPluginHandle<P: Plugin> {
+    handle: Arc<Mutex<PluginHandle>>,
+    _type: std::marker::PhantomData<P>,
+}
+
+impl<P: Plugin> TypedPluginHandle<P> {
+    pub(crate) fn new(handle: Arc<Mutex<PluginHandle>>) -> Self {
+        Self {
+            handle,
+            _type: std::marker::PhantomData,
+        }
+    }
+
+    pub fn lock(&self) -> TypedPluginGuard<'_, P> {
+        TypedPluginGuard {
+            guard: self.handle.lock(),
+            _type: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct TypedPluginGuard<'a, P: Plugin> {
+    guard: MutexGuard<'a, PluginHandle>,
+    _type: std::marker::PhantomData<P>,
+}
+
+impl<P: Plugin> TypedPluginGuard<'_, P> {}
+
+impl<P: Plugin> std::ops::Deref for TypedPluginGuard<'_, P> {
+    type Target = P;
+
+    fn deref(&self) -> &Self::Target {
+        self.guard.typed_plugin()
+    }
+}
+
+impl<P: Plugin> std::ops::DerefMut for TypedPluginGuard<'_, P> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.guard.typed_plugin_mut()
+    }
+}
+
+impl PluginHandle {
+    pub fn new<P: Plugin>(plugin: P) -> Arc<Mutex<Self>> {
+        Arc::new(Mutex::new(Self {
+            plugin: Box::new(plugin),
+        }))
+    }
+
+    fn plugin_type_id(&self) -> std::any::TypeId {
+        (*self.plugin).type_id()
+    }
+
+    pub fn dyn_plugin_mut(&mut self) -> &mut dyn Plugin {
+        &mut *self.plugin
+    }
+
+    fn typed_plugin<P: Plugin + 'static>(&self) -> &P {
+        (&*self.plugin as &dyn std::any::Any)
+            .downcast_ref::<P>()
+            .expect("PluginHandle: plugin is not of the expected type")
+    }
+
+    pub fn typed_plugin_mut<P: Plugin + 'static>(&mut self) -> &mut P {
+        (&mut *self.plugin as &mut dyn std::any::Any)
+            .downcast_mut::<P>()
+            .expect("PluginHandle: plugin is not of the expected type")
+    }
+}
+
+/// User-registered plugins.
+#[derive(Clone, Default)]
+pub(crate) struct Plugins {
+    plugins: HashMap<std::any::TypeId, Arc<Mutex<PluginHandle>>>,
+    plugins_ordered: PluginsOrdered,
+}
+
+#[derive(Clone, Default)]
+pub(crate) struct PluginsOrdered(Vec<Arc<Mutex<PluginHandle>>>);
+
+impl PluginsOrdered {
+    fn for_each_dyn<F>(&self, mut f: F)
+    where
+        F: FnMut(&mut dyn Plugin),
+    {
+        for plugin in &self.0 {
+            let mut plugin = plugin.lock();
+            profiling::scope!("plugin", plugin.dyn_plugin_mut().debug_name());
+            f(plugin.dyn_plugin_mut());
+        }
+    }
+
+    pub fn on_begin_pass(&self, ctx: &Context) {
+        profiling::scope!("plugins", "on_begin_pass");
+        self.for_each_dyn(|p| {
+            p.on_begin_pass(ctx);
+        });
+    }
+
+    pub fn on_end_pass(&self, ctx: &Context) {
+        profiling::scope!("plugins", "on_end_pass");
+        self.for_each_dyn(|p| {
+            p.on_end_pass(ctx);
+        });
+    }
+
+    pub fn on_input(&self, input: &mut RawInput) {
+        profiling::scope!("plugins", "on_input");
+        self.for_each_dyn(|plugin| {
+            plugin.input_hook(input);
+        });
+    }
+
+    pub fn on_output(&self, output: &mut FullOutput) {
+        profiling::scope!("plugins", "on_output");
+        self.for_each_dyn(|plugin| {
+            plugin.output_hook(output);
+        });
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn on_widget_under_pointer(&self, ctx: &Context, widget: &crate::WidgetRect) {
+        profiling::scope!("plugins", "on_widget_under_pointer");
+        self.for_each_dyn(|plugin| {
+            plugin.on_widget_under_pointer(ctx, widget);
+        });
+    }
+}
+
+impl Plugins {
+    pub fn ordered_plugins(&self) -> PluginsOrdered {
+        self.plugins_ordered.clone()
+    }
+
+    /// Remember to call [`Plugin::setup`] on the plugin after adding it.
+    ///
+    /// Will not add the plugin if a plugin of the same type already exists.
+    /// Returns `false` if the plugin was not added, `true` if it was added.
+    pub fn add(&mut self, handle: Arc<Mutex<PluginHandle>>) -> bool {
+        profiling::scope!("plugins", "add");
+
+        let type_id = handle.lock().plugin_type_id();
+
+        if self.plugins.contains_key(&type_id) {
+            return false;
+        }
+
+        self.plugins.insert(type_id, handle.clone());
+        self.plugins_ordered.0.push(handle);
+
+        true
+    }
+
+    pub fn get(&self, type_id: std::any::TypeId) -> Option<Arc<Mutex<PluginHandle>>> {
+        self.plugins.get(&type_id).cloned()
+    }
+}
+
+/// Generic event callback.
+pub type ContextCallback = Arc<dyn Fn(&Context) + Send + Sync>;
+
+#[derive(Default)]
+pub(crate) struct CallbackPlugin {
+    pub on_begin_plugins: Vec<(&'static str, ContextCallback)>,
+    pub on_end_plugins: Vec<(&'static str, ContextCallback)>,
+}
+
+impl Plugin for CallbackPlugin {
+    fn debug_name(&self) -> &'static str {
+        "CallbackPlugins"
+    }
+
+    fn on_begin_pass(&mut self, ctx: &Context) {
+        profiling::function_scope!();
+
+        for (_debug_name, cb) in &self.on_begin_plugins {
+            profiling::scope!("on_begin_pass", *_debug_name);
+            (cb)(ctx);
+        }
+    }
+
+    fn on_end_pass(&mut self, ctx: &Context) {
+        profiling::function_scope!();
+
+        for (_debug_name, cb) in &self.on_end_plugins {
+            profiling::scope!("on_end_pass", *_debug_name);
+            (cb)(ctx);
+        }
+    }
+}
diff --git a/crates/egui/src/response.rs b/crates/egui/src/response.rs
index f5861f4f1..e89cb5252 100644
--- a/crates/egui/src/response.rs
+++ b/crates/egui/src/response.rs
@@ -1,9 +1,10 @@
 use std::{any::Any, sync::Arc};
 
 use crate::{
-    emath::{Align, Pos2, Rect, Vec2},
-    menu, pass_state, AreaState, Context, CursorIcon, Id, LayerId, Order, PointerButton, Sense, Ui,
+    Context, CursorIcon, Id, LayerId, PointerButton, Popup, PopupKind, Sense, Tooltip, Ui,
     WidgetRect, WidgetText,
+    emath::{Align, Pos2, Rect, Vec2},
+    pass_state,
 };
 // ----------------------------------------------------------------------------
 
@@ -58,8 +59,8 @@ pub struct Response {
 
     /// The intrinsic / desired size of the widget.
     ///
-    /// For a button, this will be the size of the label + the frames padding,
-    /// even if the button is laid out in a justified layout and the actual size will be larger.
+    /// This is the size that a non-wrapped, non-truncated, non-justified version of the widget
+    /// would have.
     ///
     /// If this is `None`, use [`Self::rect`] instead.
     ///
@@ -133,6 +134,9 @@ bitflags::bitflags! {
         /// Note that this can be `true` even if the user did not interact with the widget,
         /// for instance if an existing slider value was clamped to the given range.
         const CHANGED = 1<<11;
+
+        /// Should this container be closed?
+        const CLOSE = 1<<12;
     }
 }
 
@@ -215,29 +219,44 @@ impl Response {
             && self.ctx.input(|i| i.pointer.button_triple_clicked(button))
     }
 
+    /// Was this widget middle-clicked or clicked while holding down a modifier key?
+    ///
+    /// This is used by [`crate::Hyperlink`] to check if a URL should be opened
+    /// in a new tab, using [`crate::OpenUrl::new_tab`].
+    pub fn clicked_with_open_in_background(&self) -> bool {
+        self.middle_clicked() || self.clicked() && self.ctx.input(|i| i.modifiers.any())
+    }
+
     /// `true` if there was a click *outside* the rect of this widget.
     ///
     /// Clicks on widgets contained in this one counts as clicks inside this widget,
     /// so that clicking a button in an area will not be considered as clicking "elsewhere" from the area.
+    ///
+    /// Clicks on other layers above this widget *will* be considered as clicking elsewhere.
     pub fn clicked_elsewhere(&self) -> bool {
+        let (pointer_interact_pos, any_click) = self
+            .ctx
+            .input(|i| (i.pointer.interact_pos(), i.pointer.any_click()));
+
         // 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() {
-                if self.contains_pointer() || self.hovered() {
-                    false
-                } else if let Some(pos) = pointer.interact_pos() {
-                    !self.interact_rect.contains(pos)
+        if any_click {
+            if self.contains_pointer() || self.hovered() {
+                false
+            } else if let Some(pos) = pointer_interact_pos {
+                let layer_under_pointer = self.ctx.layer_id_at(pos);
+                if layer_under_pointer != Some(self.layer_id) {
+                    true
                 } else {
-                    false // clicked without a pointer, weird
+                    !self.interact_rect.contains(pos)
                 }
             } else {
-                false
+                false // clicked without a pointer, weird
             }
-        })
+        } else {
+            false
+        }
     }
 
     /// Was the widget enabled?
@@ -377,20 +396,7 @@ impl Response {
         self.drag_stopped() && self.ctx.input(|i| i.pointer.button_released(button))
     }
 
-    /// The widget was being dragged, but now it has been released.
-    #[inline]
-    #[deprecated = "Renamed 'drag_stopped'"]
-    pub fn drag_released(&self) -> bool {
-        self.drag_stopped()
-    }
-
-    /// The widget was being dragged by the button, but now it has been released.
-    #[deprecated = "Renamed 'drag_stopped_by'"]
-    pub fn drag_released_by(&self, button: PointerButton) -> bool {
-        self.drag_stopped_by(button)
-    }
-
-    /// If dragged, how many points were we dragged and in what direction?
+    /// If dragged, how many points were we dragged in since last frame?
     #[inline]
     pub fn drag_delta(&self) -> Vec2 {
         if self.dragged() {
@@ -404,7 +410,22 @@ impl Response {
         }
     }
 
-    /// If dragged, how far did the mouse move?
+    /// If dragged, how many points have we been dragged since the start of the drag?
+    #[inline]
+    pub fn total_drag_delta(&self) -> Option<Vec2> {
+        if self.dragged() {
+            let mut delta = self.ctx.input(|i| i.pointer.total_drag_delta())?;
+            if let Some(from_global) = self.ctx.layer_transform_from_global(self.layer_id) {
+                delta *= from_global.scaling;
+            }
+            Some(delta)
+        } else {
+            None
+        }
+    }
+
+    /// If dragged, how far did the mouse move since last frame?
+    ///
     /// This will use raw mouse movement if provided by the integration, otherwise will fall back to [`Response::drag_delta`]
     /// Raw mouse movement is unaccelerated and unclamped by screen boundaries, and does not relate to any position on the screen.
     /// This may be useful in certain situations such as draggable values and 3D cameras, where screen position does not matter.
@@ -528,6 +549,21 @@ impl Response {
         self.flags.set(Flags::CHANGED, true);
     }
 
+    /// Should the container be closed?
+    ///
+    /// Will e.g. be set by calling [`Ui::close`] in a child [`Ui`] or by calling
+    /// [`Self::set_close`].
+    pub fn should_close(&self) -> bool {
+        self.flags.contains(Flags::CLOSE)
+    }
+
+    /// Set the [`Flags::CLOSE`] flag.
+    ///
+    /// Can be used to e.g. signal that a container should be closed.
+    pub fn set_close(&mut self) {
+        self.flags.set(Flags::CLOSE, 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.
@@ -550,36 +586,22 @@ impl Response {
     /// ```
     #[doc(alias = "tooltip")]
     pub fn on_hover_ui(self, add_contents: impl FnOnce(&mut Ui)) -> Self {
-        if self.flags.contains(Flags::ENABLED) && self.should_show_hover_ui() {
-            self.show_tooltip_ui(add_contents);
-        }
+        Tooltip::for_enabled(&self).show(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.should_show_hover_ui() {
-            crate::containers::show_tooltip_for(
-                &self.ctx,
-                self.layer_id,
-                self.id,
-                &self.rect,
-                add_contents,
-            );
-        }
+        Tooltip::for_disabled(&self).show(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.enabled() && self.should_show_hover_ui() {
-            crate::containers::show_tooltip_at_pointer(
-                &self.ctx,
-                self.layer_id,
-                self.id,
-                add_contents,
-            );
-        }
+        Tooltip::for_enabled(&self)
+            .at_pointer()
+            .gap(12.0)
+            .show(add_contents);
         self
     }
 
@@ -587,13 +609,9 @@ impl Response {
     ///
     /// This can be used to give attention to a widget during a tutorial.
     pub fn show_tooltip_ui(&self, add_contents: impl FnOnce(&mut Ui)) {
-        crate::containers::show_tooltip_for(
-            &self.ctx,
-            self.layer_id,
-            self.id,
-            &self.rect,
-            add_contents,
-        );
+        Popup::from_response(self)
+            .kind(PopupKind::Tooltip)
+            .show(add_contents);
     }
 
     /// Always show this tooltip, even if disabled and the user isn't hovering it.
@@ -607,180 +625,7 @@ impl Response {
 
     /// Was the tooltip open last frame?
     pub fn is_tooltip_open(&self) -> bool {
-        crate::popup::was_tooltip_open_last_frame(&self.ctx, self.id)
-    }
-
-    fn should_show_hover_ui(&self) -> bool {
-        if self.ctx.memory(|mem| mem.everything_is_visible()) {
-            return true;
-        }
-
-        let any_open_popups = self.ctx.prev_pass_state(|fs| {
-            fs.layers
-                .get(&self.layer_id)
-                .is_some_and(|layer| !layer.open_popups.is_empty())
-        });
-        if any_open_popups {
-            // Hide tooltips if the user opens a popup (menu, combo-box, etc) in the same layer.
-            return false;
-        }
-
-        let style = self.ctx.style();
-
-        let tooltip_delay = style.interaction.tooltip_delay;
-        let tooltip_grace_time = style.interaction.tooltip_grace_time;
-
-        let (
-            time_since_last_scroll,
-            time_since_last_click,
-            time_since_last_pointer_movement,
-            pointer_pos,
-            pointer_dir,
-        ) = self.ctx.input(|i| {
-            (
-                i.time_since_last_scroll(),
-                i.pointer.time_since_last_click(),
-                i.pointer.time_since_last_movement(),
-                i.pointer.hover_pos(),
-                i.pointer.direction(),
-            )
-        });
-
-        if time_since_last_scroll < tooltip_delay {
-            // See https://github.com/emilk/egui/issues/4781
-            // Note that this means we cannot have `ScrollArea`s in a tooltip.
-            self.ctx
-                .request_repaint_after_secs(tooltip_delay - time_since_last_scroll);
-            return false;
-        }
-
-        let is_our_tooltip_open = self.is_tooltip_open();
-
-        if is_our_tooltip_open {
-            // Check if we should automatically stay open:
-
-            let tooltip_id = crate::next_tooltip_id(&self.ctx, self.id);
-            let tooltip_layer_id = LayerId::new(Order::Tooltip, tooltip_id);
-
-            let tooltip_has_interactive_widget = self.ctx.viewport(|vp| {
-                vp.prev_pass
-                    .widgets
-                    .get_layer(tooltip_layer_id)
-                    .any(|w| w.enabled && w.sense.interactive())
-            });
-
-            if tooltip_has_interactive_widget {
-                // We keep the tooltip open if hovered,
-                // or if the pointer is on its way to it,
-                // so that the user can interact with the tooltip
-                // (i.e. click links that are in it).
-                if let Some(area) = AreaState::load(&self.ctx, tooltip_id) {
-                    let rect = area.rect();
-
-                    if let Some(pos) = pointer_pos {
-                        if rect.contains(pos) {
-                            return true; // hovering interactive tooltip
-                        }
-                        if pointer_dir != Vec2::ZERO
-                            && rect.intersects_ray(pos, pointer_dir.normalized())
-                        {
-                            return true; // on the way to interactive tooltip
-                        }
-                    }
-                }
-            }
-        }
-
-        let clicked_more_recently_than_moved =
-            time_since_last_click < time_since_last_pointer_movement + 0.1;
-        if clicked_more_recently_than_moved {
-            // It is common to click a widget and then rest the mouse there.
-            // It would be annoying to then see a tooltip for it immediately.
-            // Similarly, clicking should hide the existing tooltip.
-            // Only hovering should lead to a tooltip, not clicking.
-            // The offset is only to allow small movement just right after the click.
-            return false;
-        }
-
-        if is_our_tooltip_open {
-            // Check if we should automatically stay open:
-
-            if pointer_pos.is_some_and(|pointer_pos| self.rect.contains(pointer_pos)) {
-                // Handle the case of a big tooltip that covers the widget:
-                return true;
-            }
-        }
-
-        let is_other_tooltip_open = self.ctx.prev_pass_state(|fs| {
-            if let Some(already_open_tooltip) = fs
-                .layers
-                .get(&self.layer_id)
-                .and_then(|layer| layer.widget_with_tooltip)
-            {
-                already_open_tooltip != self.id
-            } else {
-                false
-            }
-        });
-        if is_other_tooltip_open {
-            // We only allow one tooltip per layer. First one wins. It is up to that tooltip to close itself.
-            return false;
-        }
-
-        // Fast early-outs:
-        if self.enabled() {
-            if !self.hovered() || !self.ctx.input(|i| i.pointer.has_pointer()) {
-                return false;
-            }
-        } else if !self.ctx.rect_contains_pointer(self.layer_id, self.rect) {
-            return false;
-        }
-
-        // There is a tooltip_delay before showing the first tooltip,
-        // but once one tooltip is show, moving the mouse cursor to
-        // another widget should show the tooltip for that widget right away.
-
-        // Let the user quickly move over some dead space to hover the next thing
-        let tooltip_was_recently_shown =
-            crate::popup::seconds_since_last_tooltip(&self.ctx) < tooltip_grace_time;
-
-        if !tooltip_was_recently_shown && !is_our_tooltip_open {
-            if style.interaction.show_tooltips_only_when_still {
-                // We only show the tooltip when the mouse pointer is still.
-                if !self
-                    .ctx
-                    .input(|i| i.pointer.is_still() && i.smooth_scroll_delta == Vec2::ZERO)
-                {
-                    // wait for mouse to stop
-                    self.ctx.request_repaint();
-                    return false;
-                }
-            }
-
-            let time_since_last_interaction = time_since_last_scroll
-                .min(time_since_last_pointer_movement)
-                .min(time_since_last_click);
-            let time_til_tooltip = tooltip_delay - time_since_last_interaction;
-
-            if 0.0 < time_til_tooltip {
-                // Wait until the mouse has been still for a while
-                self.ctx.request_repaint_after_secs(time_til_tooltip);
-                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;
-        }
-
-        // All checks passed: show the tooltip!
-
-        true
+        Tooltip::was_tooltip_open_last_frame(&self.ctx, self.id)
     }
 
     /// Like `on_hover_text`, but show the text next to cursor.
@@ -879,10 +724,9 @@ impl Response {
     /// ```
     #[must_use]
     pub fn interact(&self, sense: Sense) -> Self {
-        if (self.sense | sense) == self.sense {
-            // Early-out: we already sense everything we need to sense.
-            return self.clone();
-        }
+        // We could check here if the new Sense equals the old one to avoid the extra create_widget
+        // call. But that would break calling `interact` on a response from `Context::read_response`
+        // or `Ui::response`. (See https://github.com/emilk/egui/pull/7713 for more details.)
 
         self.ctx.create_widget(
             WidgetRect {
@@ -963,7 +807,6 @@ impl Response {
         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());
             });
@@ -973,7 +816,6 @@ impl Response {
     }
 
     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());
         });
@@ -984,7 +826,6 @@ impl Response {
         self.ctx.output_mut(|o| o.events.push(event));
     }
 
-    #[cfg(feature = "accesskit")]
     pub(crate) fn fill_accesskit_node_common(&self, builder: &mut accesskit::Node) {
         if !self.enabled() {
             builder.set_disabled();
@@ -1003,7 +844,6 @@ impl Response {
         }
     }
 
-    #[cfg(feature = "accesskit")]
     fn fill_accesskit_node_from_widget_info(
         &self,
         builder: &mut accesskit::Node,
@@ -1017,18 +857,18 @@ impl Response {
             WidgetType::Label => Role::Label,
             WidgetType::Link => Role::Link,
             WidgetType::TextEdit => Role::TextInput,
-            WidgetType::Button | WidgetType::ImageButton | WidgetType::CollapsingHeader => {
+            WidgetType::Button | WidgetType::CollapsingHeader | WidgetType::SelectableLabel => {
                 Role::Button
             }
             WidgetType::Image => Role::Image,
             WidgetType::Checkbox => Role::CheckBox,
             WidgetType::RadioButton => Role::RadioButton,
             WidgetType::RadioGroup => Role::RadioGroup,
-            WidgetType::SelectableLabel => Role::Button,
             WidgetType::ComboBox => Role::ComboBox,
             WidgetType::Slider => Role::Slider,
             WidgetType::DragValue => Role::SpinButton,
             WidgetType::ColorButton => Role::ColorWell,
+            WidgetType::Panel => Role::Pane,
             WidgetType::ProgressIndicator => Role::ProgressIndicator,
             WidgetType::Window => Role::Window,
             WidgetType::Other => Role::Unknown,
@@ -1059,6 +899,9 @@ impl Response {
             // Indeterminate state
             builder.set_toggled(Toggled::Mixed);
         }
+        if let Some(hint_text) = info.hint_text {
+            builder.set_placeholder(hint_text);
+        }
     }
 
     /// Associate a label with a control for accessibility.
@@ -1075,14 +918,9 @@ impl Response {
     /// # });
     /// ```
     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
     }
@@ -1097,22 +935,22 @@ impl Response {
     /// 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();
+    ///         ui.close();
     ///     }
     /// });
     /// # });
     /// ```
     ///
-    /// See also: [`Ui::menu_button`] and [`Ui::close_menu`].
+    /// See also: [`Ui::menu_button`] and [`Ui::close`].
     pub fn context_menu(&self, add_contents: impl FnOnce(&mut Ui)) -> Option<InnerResponse<()>> {
-        menu::context_menu(self, add_contents)
+        Popup::context_menu(self).show(add_contents)
     }
 
     /// Returns whether a context menu is currently open for this widget.
     ///
     /// See [`Self::context_menu`].
     pub fn context_menu_opened(&self) -> bool {
-        menu::context_menu_opened(self)
+        Popup::context_menu(self).is_open()
     }
 
     /// Draw a debug rectangle over the response displaying the response's id and whether it is
@@ -1148,7 +986,10 @@ impl Response {
     ///
     /// You may not call [`Self::interact`] on the resulting `Response`.
     pub fn union(&self, other: Self) -> Self {
-        assert!(self.ctx == other.ctx);
+        assert!(
+            self.ctx == other.ctx,
+            "Responses must be from the same `Context`"
+        );
         debug_assert!(
             self.layer_id == other.layer_id,
             "It makes no sense to combine Responses from two different layers"
diff --git a/crates/egui/src/style.rs b/crates/egui/src/style.rs
index c84f2dc8a..9982c05bb 100644
--- a/crates/egui/src/style.rs
+++ b/crates/egui/src/style.rs
@@ -2,16 +2,16 @@
 
 #![allow(clippy::if_same_then_else)]
 
+use emath::Align;
+use epaint::{AlphaFromCoverage, CornerRadius, Shadow, Stroke, text::FontTweak};
 use std::{collections::BTreeMap, ops::RangeInclusive, sync::Arc};
 
-use emath::Align;
-use epaint::{text::FontTweak, CornerRadius, Shadow, Stroke};
-
 use crate::{
-    ecolor::Color32,
-    emath::{pos2, vec2, Rangef, Rect, Vec2},
     ComboBox, CursorIcon, FontFamily, FontId, Grid, Margin, Response, RichText, TextWrapMode,
     WidgetText,
+    ecolor::Color32,
+    emath::{Rangef, Rect, Vec2, pos2, vec2},
+    reset_button_with,
 };
 
 /// How to format numbers in e.g. a [`crate::DragValue`].
@@ -121,6 +121,7 @@ impl TextStyle {
 // ----------------------------------------------------------------------------
 
 /// A way to select [`FontId`], either by picking one directly or by using a [`TextStyle`].
+#[derive(Debug, Clone)]
 pub enum FontSelection {
     /// Default text style - will use [`TextStyle::Body`], unless
     /// [`Style::override_font_id`] or [`Style::override_text_style`] is set.
@@ -141,7 +142,18 @@ impl Default for FontSelection {
 }
 
 impl FontSelection {
+    /// Resolve to a [`FontId`].
+    ///
+    /// On [`Self::Default`] and no override in the style, this will
+    /// resolve to [`TextStyle::Body`].
     pub fn resolve(self, style: &Style) -> FontId {
+        self.resolve_with_fallback(style, TextStyle::Body.into())
+    }
+
+    /// Resolve with a final fallback.
+    ///
+    /// Fallback is resolved on [`Self::Default`] and no override in the style.
+    pub fn resolve_with_fallback(self, style: &Style, fallback: Self) -> FontId {
         match self {
             Self::Default => {
                 if let Some(override_font_id) = &style.override_font_id {
@@ -149,7 +161,7 @@ impl FontSelection {
                 } else if let Some(text_style) = &style.override_text_style {
                     text_style.resolve(style)
                 } else {
-                    TextStyle::Body.resolve(style)
+                    fallback.resolve(style)
                 }
             }
             Self::FontId(font_id) => font_id,
@@ -174,6 +186,49 @@ impl From<TextStyle> for FontSelection {
 
 // ----------------------------------------------------------------------------
 
+/// Utility to modify a [`Style`] in some way.
+/// Constructed via [`StyleModifier::from`] from a `Fn(&mut Style)` or a [`Style`].
+#[derive(Clone, Default)]
+pub struct StyleModifier(Option<Arc<dyn Fn(&mut Style) + Send + Sync>>);
+
+impl std::fmt::Debug for StyleModifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("StyleModifier")
+    }
+}
+
+impl<T> From<T> for StyleModifier
+where
+    T: Fn(&mut Style) + Send + Sync + 'static,
+{
+    fn from(f: T) -> Self {
+        Self(Some(Arc::new(f)))
+    }
+}
+
+impl From<Style> for StyleModifier {
+    fn from(style: Style) -> Self {
+        Self(Some(Arc::new(move |s| *s = style.clone())))
+    }
+}
+
+impl StyleModifier {
+    /// Create a new [`StyleModifier`] from a function.
+    pub fn new(f: impl Fn(&mut Style) + Send + Sync + 'static) -> Self {
+        Self::from(f)
+    }
+
+    /// Apply the modification to the given [`Style`].
+    /// Usually used with [`Ui::style_mut`].
+    pub fn apply(&self, style: &mut Style) {
+        if let Some(f) = &self.0 {
+            f(style);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
 /// Specifies the look and feel of egui.
 ///
 /// You can change the visuals of a [`Ui`] with [`Ui::style_mut`]
@@ -290,6 +345,9 @@ pub struct Style {
 
     /// The animation that should be used when scrolling a [`crate::ScrollArea`] using e.g. [`Ui::scroll_to_rect`].
     pub scroll_animation: ScrollAnimation,
+
+    /// Use a more compact style for menus.
+    pub compact_menu_style: bool,
 }
 
 #[test]
@@ -702,7 +760,8 @@ impl ScrollStyle {
 
 // ----------------------------------------------------------------------------
 
-/// Scroll animation configuration, used when programmatically scrolling somewhere (e.g. with `[crate::Ui::scroll_to_cursor]`)
+/// Scroll animation configuration, used when programmatically scrolling somewhere (e.g. with `[crate::Ui::scroll_to_cursor]`).
+///
 /// The animation duration is calculated based on the distance to be scrolled via `[ScrollAnimation::points_per_second]`
 /// and can be clamped to a min / max duration via `[ScrollAnimation::duration]`.
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -874,6 +933,9 @@ pub struct Visuals {
     /// this is more to provide a convenient summary of the rest of the settings.
     pub dark_mode: bool,
 
+    /// ADVANCED: Controls how we render text.
+    pub text_alpha_from_coverage: AlphaFromCoverage,
+
     /// Override default text color for all text.
     ///
     /// This is great for setting the color of text for any widget.
@@ -889,6 +951,17 @@ pub struct Visuals {
     /// it is disabled, non-interactive, hovered etc.
     pub override_text_color: Option<Color32>,
 
+    /// How strong "weak" text is.
+    ///
+    /// Ignored if [`Self::weak_text_color`] is set.
+    pub weak_text_alpha: f32,
+
+    /// Color of "weak" text.
+    ///
+    /// If `None`, the color is [`Self::text_color`]
+    /// multiplied by [`Self::weak_text_alpha`].
+    pub weak_text_color: Option<Color32>,
+
     /// Visual styles of widgets
     pub widgets: Widgets,
 
@@ -906,6 +979,11 @@ pub struct Visuals {
     /// that needs to look different from other interactive stuff.
     pub extreme_bg_color: Color32,
 
+    /// The background color of [`crate::TextEdit`].
+    ///
+    /// Defaults to [`Self::extreme_bg_color`].
+    pub text_edit_bg_color: Option<Color32>,
+
     /// Background color behind code-styled monospaced labels.
     pub code_bg_color: Color32,
 
@@ -944,7 +1022,7 @@ pub struct Visuals {
     /// Show a background behind collapsing headers.
     pub collapsing_header_frame: bool,
 
-    /// Draw a vertical lien left of indented region, in e.g. [`crate::CollapsingHeader`].
+    /// Draw a vertical line 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
@@ -973,6 +1051,9 @@ pub struct Visuals {
 
     /// How to display numeric color values.
     pub numeric_color_space: NumericColorSpace,
+
+    /// How much to modify the alpha of a disabled widget.
+    pub disabled_alpha: f32,
 }
 
 impl Visuals {
@@ -988,7 +1069,8 @@ impl Visuals {
     }
 
     pub fn weak_text_color(&self) -> Color32 {
-        self.gray_out(self.text_color())
+        self.weak_text_color
+            .unwrap_or_else(|| self.text_color().gamma_multiply(self.weak_text_alpha))
     }
 
     #[inline(always)]
@@ -996,6 +1078,11 @@ impl Visuals {
         self.widgets.active.text_color()
     }
 
+    /// The background color of [`crate::TextEdit`].
+    pub fn text_edit_bg_color(&self) -> Color32 {
+        self.text_edit_bg_color.unwrap_or(self.extreme_bg_color)
+    }
+
     /// Window background color.
     #[inline(always)]
     pub fn window_fill(&self) -> Color32 {
@@ -1008,17 +1095,32 @@ impl Visuals {
     }
 
     /// When fading out things, we fade the colors towards this.
-    // TODO(emilk): replace with an alpha
     #[inline(always)]
+    #[deprecated = "Use disabled_alpha(). Fading is now handled by modifying the alpha channel."]
     pub fn fade_out_to_color(&self) -> Color32 {
         self.widgets.noninteractive.weak_bg_fill
     }
 
-    /// Returned a "grayed out" version of the given color.
+    /// Disabled widgets have their alpha modified by this.
+    #[inline(always)]
+    pub fn disabled_alpha(&self) -> f32 {
+        self.disabled_alpha
+    }
+
+    /// Returns a "disabled" version of the given color.
+    ///
+    /// This function modifies the opcacity of the given color.
+    /// If this is undesirable use [`gray_out`](Self::gray_out).
+    #[inline(always)]
+    pub fn disable(&self, color: Color32) -> Color32 {
+        color.gamma_multiply(self.disabled_alpha())
+    }
+
+    /// Returns a "grayed out" version of the given color.
     #[doc(alias = "grey_out")]
     #[inline(always)]
     pub fn gray_out(&self, color: Color32) -> Color32 {
-        crate::ecolor::tint_color_towards(color, self.fade_out_to_color())
+        crate::ecolor::tint_color_towards(color, self.widgets.noninteractive.weak_bg_fill)
     }
 }
 
@@ -1027,7 +1129,10 @@ impl Visuals {
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct Selection {
+    /// Background color behind selected text and other selectable buttons.
     pub bg_fill: Color32,
+
+    /// Color of selected text.
     pub stroke: Stroke,
 }
 
@@ -1205,17 +1310,17 @@ pub fn default_text_styles() -> BTreeMap<TextStyle, FontId> {
 
     [
         (TextStyle::Small, FontId::new(9.0, Proportional)),
-        (TextStyle::Body, FontId::new(12.5, Proportional)),
-        (TextStyle::Button, FontId::new(12.5, Proportional)),
+        (TextStyle::Body, FontId::new(13.0, Proportional)),
+        (TextStyle::Button, FontId::new(13.0, Proportional)),
         (TextStyle::Heading, FontId::new(18.0, Proportional)),
-        (TextStyle::Monospace, FontId::new(12.0, Monospace)),
+        (TextStyle::Monospace, FontId::new(13.0, Monospace)),
     ]
     .into()
 }
 
 impl Default for Style {
     fn default() -> Self {
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         Self {
             override_font_id: None,
             override_text_style: None,
@@ -1228,13 +1333,14 @@ impl Default for Style {
             spacing: Spacing::default(),
             interaction: Interaction::default(),
             visuals: Visuals::default(),
-            animation_time: 1.0 / 12.0,
+            animation_time: 6.0 / 60.0, // If we make this too slow, it will be too obvious that our panel animations look like shit :(
             #[cfg(debug_assertions)]
             debug: Default::default(),
             explanation_tooltips: false,
             url_in_tooltip: false,
             always_scroll_the_only_direction: false,
             scroll_animation: ScrollAnimation::default(),
+            compact_menu_style: true,
         }
     }
 }
@@ -1286,12 +1392,16 @@ impl Visuals {
     pub fn dark() -> Self {
         Self {
             dark_mode: true,
+            text_alpha_from_coverage: AlphaFromCoverage::DARK_MODE_DEFAULT,
             override_text_color: None,
+            weak_text_alpha: 0.6,
+            weak_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
+            text_edit_bg_color: None, // use `extreme_bg_color` by default
             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
@@ -1330,13 +1440,14 @@ impl Visuals {
             striped: false,
 
             slider_trailing_fill: false,
-            handle_shape: HandleShape::Circle,
+            handle_shape: HandleShape::Rect { aspect_ratio: 0.75 },
 
             interact_cursor: None,
 
             image_loading_spinners: true,
 
             numeric_color_space: NumericColorSpace::GammaByte,
+            disabled_alpha: 0.5,
         }
     }
 
@@ -1344,6 +1455,7 @@ impl Visuals {
     pub fn light() -> Self {
         Self {
             dark_mode: false,
+            text_alpha_from_coverage: AlphaFromCoverage::LIGHT_MODE_DEFAULT,
             widgets: Widgets::light(),
             selection: Selection::light(),
             hyperlink_color: Color32::from_rgb(0, 155, 255),
@@ -1510,13 +1622,13 @@ impl Default for Widgets {
 // ----------------------------------------------------------------------------
 
 use crate::{
-    widgets::{reset_button, DragValue, Slider, Widget},
     Ui,
+    widgets::{DragValue, Slider, Widget, reset_button},
 };
 
 impl Style {
     pub fn ui(&mut self, ui: &mut crate::Ui) {
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         let Self {
             override_font_id,
             override_text_style,
@@ -1536,6 +1648,7 @@ impl Style {
             url_in_tooltip,
             always_scroll_the_only_direction,
             scroll_animation,
+            compact_menu_style,
         } = self;
 
         crate::Grid::new("_options").show(ui, |ui| {
@@ -1632,15 +1745,17 @@ impl Style {
             ui.end_row();
         });
 
-        ui.collapsing("🔠 Text Styles", |ui| text_styles_ui(ui, text_styles));
+        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("🔄 Scroll Animation", |ui| scroll_animation.ui(ui));
+        ui.collapsing("🔄 Scroll animation", |ui| scroll_animation.ui(ui));
 
         #[cfg(debug_assertions)]
         ui.collapsing("🐛 Debug", |ui| debug.ui(ui));
 
+        ui.checkbox(compact_menu_style, "Compact menu style");
+
         ui.checkbox(explanation_tooltips, "Explanation tooltips")
             .on_hover_text(
                 "Show explanatory text when hovering DragValue:s and other egui widgets",
@@ -1972,13 +2087,17 @@ impl WidgetVisuals {
 impl Visuals {
     pub fn ui(&mut self, ui: &mut crate::Ui) {
         let Self {
-            dark_mode: _,
+            dark_mode,
+            text_alpha_from_coverage,
             override_text_color: _,
+            weak_text_alpha,
+            weak_text_color,
             widgets,
             selection,
             hyperlink_color,
             faint_bg_color,
             extreme_bg_color,
+            text_edit_bg_color,
             code_bg_color,
             warn_fg_color,
             error_fg_color,
@@ -2013,44 +2132,115 @@ impl Visuals {
             image_loading_spinners,
 
             numeric_color_space,
+            disabled_alpha,
         } = 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");
+        fn ui_optional_color(
+            ui: &mut Ui,
+            color: &mut Option<Color32>,
+            default_value: Color32,
+            label: impl Into<WidgetText>,
+        ) -> Response {
+            let label_response = ui.label(label);
+
+            ui.horizontal(|ui| {
+                let mut set = color.is_some();
+                ui.checkbox(&mut set, "");
+                if set {
+                    let color = color.get_or_insert(default_value);
+                    ui.color_edit_button_srgba(color);
+                } else {
+                    *color = None;
+                }
+            });
+
+            ui.end_row();
+
+            label_response
+        }
+
+        ui.collapsing("Background colors", |ui| {
+            Grid::new("background_colors")
+                .num_columns(2)
+                .show(ui, |ui| {
+                    fn ui_color(
+                        ui: &mut Ui,
+                        color: &mut Color32,
+                        label: impl Into<WidgetText>,
+                    ) -> Response {
+                        let label_response = ui.label(label);
+                        ui.color_edit_button_srgba(color);
+                        ui.end_row();
+                        label_response
+                    }
+
+                    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_optional_color(ui, text_edit_bg_color, *extreme_bg_color, "TextEdit")
+                        .on_hover_text("Background of TextEdit");
+                });
         });
 
         ui.collapsing("Text color", |ui| {
-            ui_text_color(ui, &mut widgets.noninteractive.fg_stroke.color, "Label");
-            ui_text_color(
-                ui,
-                &mut widgets.inactive.fg_stroke.color,
-                "Unhovered button",
-            );
-            ui_text_color(ui, &mut widgets.hovered.fg_stroke.color, "Hovered button");
-            ui_text_color(ui, &mut widgets.active.fg_stroke.color, "Clicked button");
+            fn ui_text_color(ui: &mut Ui, color: &mut Color32, label: impl Into<RichText>) {
+                ui.label(label.into().color(*color));
+                ui.color_edit_button_srgba(color);
+                ui.end_row();
+            }
 
-            ui_text_color(ui, warn_fg_color, RichText::new("Warnings"));
-            ui_text_color(ui, error_fg_color, RichText::new("Errors"));
+            Grid::new("text_color").num_columns(2).show(ui, |ui| {
+                ui_text_color(ui, &mut widgets.noninteractive.fg_stroke.color, "Label");
 
-            ui_text_color(ui, hyperlink_color, "hyperlink_color");
+                ui_text_color(
+                    ui,
+                    &mut widgets.inactive.fg_stroke.color,
+                    "Unhovered button",
+                );
+                ui_text_color(ui, &mut widgets.hovered.fg_stroke.color, "Hovered button");
+                ui_text_color(ui, &mut widgets.active.fg_stroke.color, "Clicked button");
 
-            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_text_color(ui, warn_fg_color, RichText::new("Warnings"));
+                ui_text_color(ui, error_fg_color, RichText::new("Errors"));
+
+                ui_text_color(ui, hyperlink_color, "hyperlink_color");
+
+                ui.label(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_edit_button_srgba(code_bg_color);
+                ui.end_row();
+
+                ui.label("Weak text alpha");
+                ui.add_enabled(
+                    weak_text_color.is_none(),
+                    DragValue::new(weak_text_alpha).speed(0.01).range(0.0..=1.0),
+                );
+                ui.end_row();
+
+                ui_optional_color(
+                    ui,
+                    weak_text_color,
+                    widgets.noninteractive.text_color(),
+                    "Weak text color",
+                );
+            });
+
+            ui.add_space(4.0);
+
+            text_alpha_from_coverage_ui(ui, text_alpha_from_coverage);
         });
 
         ui.collapsing("Text cursor", |ui| {
@@ -2141,12 +2331,60 @@ impl Visuals {
                 ui.label("Color picker type");
                 numeric_color_space.toggle_button_ui(ui);
             });
+
+            ui.add(Slider::new(disabled_alpha, 0.0..=1.0).text("Disabled element alpha"));
         });
 
-        ui.vertical_centered(|ui| reset_button(ui, self, "Reset visuals"));
+        let dark_mode = *dark_mode;
+        ui.vertical_centered(|ui| {
+            reset_button_with(
+                ui,
+                self,
+                "Reset visuals",
+                if dark_mode {
+                    Self::dark()
+                } else {
+                    Self::light()
+                },
+            );
+        });
     }
 }
 
+fn text_alpha_from_coverage_ui(ui: &mut Ui, text_alpha_from_coverage: &mut AlphaFromCoverage) {
+    let mut dark_mode_special =
+        *text_alpha_from_coverage == AlphaFromCoverage::TwoCoverageMinusCoverageSq;
+
+    ui.horizontal(|ui| {
+        ui.label("Text rendering:");
+
+        ui.checkbox(&mut dark_mode_special, "Dark-mode special");
+
+        if dark_mode_special {
+            *text_alpha_from_coverage = AlphaFromCoverage::TwoCoverageMinusCoverageSq;
+        } else {
+            let mut gamma = match text_alpha_from_coverage {
+                AlphaFromCoverage::Linear => 1.0,
+                AlphaFromCoverage::Gamma(gamma) => *gamma,
+                AlphaFromCoverage::TwoCoverageMinusCoverageSq => 0.5, // approximately the same
+            };
+
+            ui.add(
+                DragValue::new(&mut gamma)
+                    .speed(0.01)
+                    .range(0.1..=4.0)
+                    .prefix("Gamma: "),
+            );
+
+            if gamma == 1.0 {
+                *text_alpha_from_coverage = AlphaFromCoverage::Linear;
+            } else {
+                *text_alpha_from_coverage = AlphaFromCoverage::Gamma(gamma);
+            }
+        }
+    });
+}
+
 impl TextCursorStyle {
     fn ui(&mut self, ui: &mut Ui) {
         let Self {
@@ -2260,22 +2498,6 @@ fn two_drag_values(value: &mut Vec2, range: std::ops::RangeInclusive<f32>) -> im
     }
 }
 
-fn ui_color(ui: &mut Ui, color: &mut Color32, label: impl Into<WidgetText>) -> Response {
-    ui.horizontal(|ui| {
-        ui.color_edit_button_srgba(color);
-        ui.label(label);
-    })
-    .response
-}
-
-fn ui_text_color(ui: &mut Ui, color: &mut Color32, label: impl Into<RichText>) -> Response {
-    ui.horizontal(|ui| {
-        ui.color_edit_button_srgba(color);
-        ui.label(label.into().color(*color));
-    })
-    .response
-}
-
 impl HandleShape {
     pub fn ui(&mut self, ui: &mut Ui) {
         ui.horizontal(|ui| {
@@ -2501,7 +2723,7 @@ impl Widget for &mut Stroke {
         let Stroke { width, color } = self;
 
         ui.horizontal(|ui| {
-            ui.add(DragValue::new(width).speed(0.1).range(0.0..=f32::INFINITY))
+            ui.add(DragValue::new(width).speed(0.1).range(0.0..=1e9))
                 .on_hover_text("Width");
             ui.color_edit_button_srgba(color);
 
@@ -2571,7 +2793,6 @@ impl Widget for &mut FontTweak {
                     scale,
                     y_offset_factor,
                     y_offset,
-                    baseline_offset_factor,
                 } = self;
 
                 ui.label("Scale");
@@ -2587,10 +2808,6 @@ impl Widget for &mut FontTweak {
                 ui.add(DragValue::new(y_offset).speed(-0.02));
                 ui.end_row();
 
-                ui.label("baseline_offset_factor");
-                ui.add(DragValue::new(baseline_offset_factor).speed(-0.0025));
-                ui.end_row();
-
                 if ui.button("Reset").clicked() {
                     *self = Default::default();
                 }
diff --git a/crates/egui/src/text_selection/accesskit_text.rs b/crates/egui/src/text_selection/accesskit_text.rs
index dedbc79dc..974a334d0 100644
--- a/crates/egui/src/text_selection/accesskit_text.rs
+++ b/crates/egui/src/text_selection/accesskit_text.rs
@@ -2,13 +2,13 @@ use emath::TSTransform;
 
 use crate::{Context, Galley, Id};
 
-use super::{text_cursor_state::is_word_char, CursorRange};
+use super::{CCursorRange, text_cursor_state::is_word_char};
 
 /// Update accesskit with the current text state.
 pub fn update_accesskit_for_text_widget(
     ctx: &Context,
     widget_id: Id,
-    cursor_range: Option<CursorRange>,
+    cursor_range: Option<CCursorRange>,
     role: accesskit::Role,
     global_from_galley: TSTransform,
     galley: &Galley,
@@ -17,8 +17,8 @@ pub fn update_accesskit_for_text_widget(
         let parent_id = widget_id;
 
         if let Some(cursor_range) = &cursor_range {
-            let anchor = &cursor_range.secondary.rcursor;
-            let focus = &cursor_range.primary.rcursor;
+            let anchor = galley.layout_from_cursor(cursor_range.secondary);
+            let focus = galley.layout_from_cursor(cursor_range.primary);
             builder.set_text_selection(accesskit::TextSelection {
                 anchor: accesskit::TextPosition {
                     node: parent_id.with(anchor.row).accesskit_id(),
@@ -40,60 +40,61 @@ pub fn update_accesskit_for_text_widget(
         return;
     };
 
-    ctx.with_accessibility_parent(parent_id, || {
-        for (row_index, row) in galley.rows.iter().enumerate() {
-            let row_id = parent_id.with(row_index);
-            ctx.accesskit_node_builder(row_id, |builder| {
-                builder.set_role(accesskit::Role::TextRun);
-                let rect = global_from_galley * row.rect;
-                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(accesskit::TextDirection::LeftToRight);
-                // TODO(mwcampbell): Set more node fields for the row
-                // once AccessKit adapters expose text formatting info.
+    for (row_index, row) in galley.rows.iter().enumerate() {
+        let row_id = parent_id.with(row_index);
 
-                let glyph_count = row.glyphs.len();
-                let mut value = String::new();
-                value.reserve(glyph_count);
-                let mut character_lengths = Vec::<u8>::with_capacity(glyph_count);
-                let mut character_positions = Vec::<f32>::with_capacity(glyph_count);
-                let mut character_widths = Vec::<f32>::with_capacity(glyph_count);
-                let mut word_lengths = Vec::<u8>::new();
-                let mut was_at_word_end = false;
-                let mut last_word_start = 0usize;
+        ctx.register_accesskit_parent(row_id, parent_id);
 
-                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.advance_width);
-                }
-
-                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);
+        ctx.accesskit_node_builder(row_id, |builder| {
+            builder.set_role(accesskit::Role::TextRun);
+            let rect = global_from_galley * row.rect_without_leading_space();
+            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(accesskit::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>::with_capacity(glyph_count);
+            let mut character_positions = Vec::<f32>::with_capacity(glyph_count);
+            let mut character_widths = Vec::<f32>::with_capacity(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.pos.x);
+                character_widths.push(glyph.advance_width);
+            }
+
+            if row.ends_with_newline {
+                value.push('\n');
+                character_lengths.push(1);
+                character_positions.push(row.size.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);
+        });
+    }
 }
diff --git a/crates/egui/src/text_selection/cursor_range.rs b/crates/egui/src/text_selection/cursor_range.rs
index bd3f496fd..a816f5f26 100644
--- a/crates/egui/src/text_selection/cursor_range.rs
+++ b/crates/egui/src/text_selection/cursor_range.rs
@@ -1,41 +1,45 @@
-use epaint::{
-    text::cursor::{CCursor, Cursor, PCursor},
-    Galley,
-};
+use epaint::{Galley, text::cursor::CCursor};
 
-use crate::{os::OperatingSystem, Event, Id, Key, Modifiers};
+use crate::{Event, Id, Key, Modifiers, os::OperatingSystem};
 
 use super::text_cursor_state::{ccursor_next_word, ccursor_previous_word, slice_char_range};
 
 /// 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 CursorRange {
+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: Cursor,
+    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: Cursor,
+    pub secondary: CCursor,
+
+    /// Saved horizontal position of the cursor.
+    pub h_pos: Option<f32>,
 }
 
-impl CursorRange {
+impl CCursorRange {
     /// The empty range.
     #[inline]
-    pub fn one(cursor: Cursor) -> Self {
+    pub fn one(ccursor: CCursor) -> Self {
         Self {
-            primary: cursor,
-            secondary: cursor,
+            primary: ccursor,
+            secondary: ccursor,
+            h_pos: None,
         }
     }
 
     #[inline]
-    pub fn two(min: Cursor, max: Cursor) -> Self {
+    pub fn two(min: impl Into<CCursor>, max: impl Into<CCursor>) -> Self {
         Self {
-            primary: max,
-            secondary: min,
+            primary: max.into(),
+            secondary: min.into(),
+            h_pos: None,
         }
     }
 
@@ -44,39 +48,31 @@ impl CursorRange {
         Self::two(galley.begin(), galley.end())
     }
 
-    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,
+            start: start.index,
+            end: end.index,
         }
     }
 
     /// True if the selected range contains no characters.
     #[inline]
     pub fn is_empty(&self) -> bool {
-        self.primary.ccursor == self.secondary.ccursor
+        self.primary == self.secondary
     }
 
     /// Is `self` a super-set of the other range?
-    pub fn contains(&self, other: &Self) -> bool {
+    pub fn contains(&self, other: Self) -> bool {
         let [self_min, self_max] = self.sorted_cursors();
         let [other_min, other_max] = other.sorted_cursors();
-        self_min.ccursor.index <= other_min.ccursor.index
-            && other_max.ccursor.index <= self_max.ccursor.index
+        self_min.index <= other_min.index && other_max.index <= self_max.index
     }
 
     /// If there is a selection, None is returned.
     /// If the two ends are the same, that is returned.
-    pub fn single(&self) -> Option<Cursor> {
+    pub fn single(&self) -> Option<CCursor> {
         if self.is_empty() {
             Some(self.primary)
         } else {
@@ -84,25 +80,16 @@ impl CursorRange {
         }
     }
 
+    #[inline]
     pub fn is_sorted(&self) -> bool {
-        let p = self.primary.ccursor;
-        let s = self.secondary.ccursor;
+        let p = self.primary;
+        let s = self.secondary;
         (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] {
+    /// returns the two ends ordered
+    #[inline]
+    pub fn sorted_cursors(&self) -> [CCursor; 2] {
         if self.is_sorted() {
             [self.primary, self.secondary]
         } else {
@@ -110,9 +97,15 @@ impl CursorRange {
         }
     }
 
+    #[inline]
+    #[deprecated = "Use `self.sorted_cursors` instead."]
+    pub fn sorted(&self) -> [CCursor; 2] {
+        self.sorted_cursors()
+    }
+
     pub fn slice_str<'s>(&self, text: &'s str) -> &'s str {
         let [min, max] = self.sorted_cursors();
-        slice_char_range(text, min.ccursor.index..max.ccursor.index)
+        slice_char_range(text, min.index..max.index)
     }
 
     /// Check for key presses that are moving the cursor.
@@ -146,7 +139,14 @@ impl CursorRange {
             | Key::ArrowDown
             | Key::Home
             | Key::End => {
-                move_single_cursor(os, &mut self.primary, galley, key, modifiers);
+                move_single_cursor(
+                    os,
+                    &mut self.primary,
+                    &mut self.h_pos,
+                    galley,
+                    key,
+                    modifiers,
+                );
                 if !modifiers.shift {
                     self.secondary = self.primary;
                 }
@@ -156,7 +156,14 @@ impl CursorRange {
             Key::P | Key::N | Key::B | Key::F | Key::A | Key::E
                 if os == OperatingSystem::Mac && modifiers.ctrl && !modifiers.shift =>
             {
-                move_single_cursor(os, &mut self.primary, galley, key, modifiers);
+                move_single_cursor(
+                    os,
+                    &mut self.primary,
+                    &mut self.h_pos,
+                    galley,
+                    key,
+                    modifiers,
+                );
                 self.secondary = self.primary;
                 true
             }
@@ -183,7 +190,6 @@ impl CursorRange {
                 ..
             } => self.on_key_press(os, galley, modifiers, *key),
 
-            #[cfg(feature = "accesskit")]
             Event::AccessKitActionRequest(accesskit::ActionRequest {
                 action: accesskit::Action::SetTextSelection,
                 target,
@@ -196,8 +202,9 @@ impl CursorRange {
                         ccursor_from_accesskit_text_position(_widget_id, galley, &selection.anchor);
                     if let (Some(primary), Some(secondary)) = (primary, secondary) {
                         *self = Self {
-                            primary: galley.from_ccursor(primary),
-                            secondary: galley.from_ccursor(secondary),
+                            primary,
+                            secondary,
+                            h_pos: None,
                         };
                         return true;
                     }
@@ -210,74 +217,8 @@ impl CursorRange {
     }
 }
 
-/// 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.
-    #[inline]
-    pub fn one(ccursor: CCursor) -> Self {
-        Self {
-            primary: ccursor,
-            secondary: ccursor,
-        }
-    }
-
-    #[inline]
-    pub fn two(min: impl Into<CCursor>, max: impl Into<CCursor>) -> Self {
-        Self {
-            primary: max.into(),
-            secondary: min.into(),
-        }
-    }
-
-    #[inline]
-    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
-    #[inline]
-    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,
-}
-
 // ----------------------------------------------------------------------------
 
-#[cfg(feature = "accesskit")]
 fn ccursor_from_accesskit_text_position(
     id: Id,
     galley: &Galley,
@@ -304,78 +245,83 @@ fn ccursor_from_accesskit_text_position(
 /// Move a text cursor based on keyboard
 fn move_single_cursor(
     os: OperatingSystem,
-    cursor: &mut Cursor,
+    cursor: &mut CCursor,
+    h_pos: &mut Option<f32>,
     galley: &Galley,
     key: Key,
     modifiers: &Modifiers,
 ) {
-    if os == OperatingSystem::Mac && 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, cursor.ccursor));
-            } else if modifiers.mac_cmd {
-                *cursor = galley.cursor_begin_of_row(cursor);
-            } else {
-                *cursor = galley.cursor_left_one_character(cursor);
+    let (new_cursor, new_h_pos) =
+        if os == OperatingSystem::Mac && modifiers.ctrl && !modifiers.shift {
+            match key {
+                Key::A => (galley.cursor_begin_of_row(cursor), None),
+                Key::E => (galley.cursor_end_of_row(cursor), None),
+                Key::P => galley.cursor_up_one_row(cursor, *h_pos),
+                Key::N => galley.cursor_down_one_row(cursor, *h_pos),
+                Key::B => (galley.cursor_left_one_character(cursor), None),
+                Key::F => (galley.cursor_right_one_character(cursor), None),
+                _ => return,
             }
-        }
-        Key::ArrowRight => {
-            if modifiers.alt || modifiers.ctrl {
-                // alt on mac, ctrl on windows
-                *cursor = galley.from_ccursor(ccursor_next_word(galley, 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 = galley.begin();
-            } 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);
-            }
-        }
+        } else {
+            match key {
+                Key::ArrowLeft => {
+                    if modifiers.alt || modifiers.ctrl {
+                        // alt on mac, ctrl on windows
+                        (ccursor_previous_word(galley, *cursor), None)
+                    } else if modifiers.mac_cmd {
+                        (galley.cursor_begin_of_row(cursor), None)
+                    } else {
+                        (galley.cursor_left_one_character(cursor), None)
+                    }
+                }
+                Key::ArrowRight => {
+                    if modifiers.alt || modifiers.ctrl {
+                        // alt on mac, ctrl on windows
+                        (ccursor_next_word(galley, *cursor), None)
+                    } else if modifiers.mac_cmd {
+                        (galley.cursor_end_of_row(cursor), None)
+                    } else {
+                        (galley.cursor_right_one_character(cursor), None)
+                    }
+                }
+                Key::ArrowUp => {
+                    if modifiers.command {
+                        // mac and windows behavior
+                        (galley.begin(), None)
+                    } else {
+                        galley.cursor_up_one_row(cursor, *h_pos)
+                    }
+                }
+                Key::ArrowDown => {
+                    if modifiers.command {
+                        // mac and windows behavior
+                        (galley.end(), None)
+                    } else {
+                        galley.cursor_down_one_row(cursor, *h_pos)
+                    }
+                }
 
-        Key::Home => {
-            if modifiers.ctrl {
-                // windows behavior
-                *cursor = galley.begin();
-            } 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);
-            }
-        }
+                Key::Home => {
+                    if modifiers.ctrl {
+                        // windows behavior
+                        (galley.begin(), None)
+                    } else {
+                        (galley.cursor_begin_of_row(cursor), None)
+                    }
+                }
+                Key::End => {
+                    if modifiers.ctrl {
+                        // windows behavior
+                        (galley.end(), None)
+                    } else {
+                        (galley.cursor_end_of_row(cursor), None)
+                    }
+                }
 
-        _ => unreachable!(),
-    }
+                _ => unreachable!(),
+            }
+        };
+
+    *cursor = new_cursor;
+    *h_pos = new_h_pos;
 }
diff --git a/crates/egui/src/text_selection/label_text_selection.rs b/crates/egui/src/text_selection/label_text_selection.rs
index aa9f0986a..bc2884441 100644
--- a/crates/egui/src/text_selection/label_text_selection.rs
+++ b/crates/egui/src/text_selection/label_text_selection.rs
@@ -3,14 +3,14 @@ use std::sync::Arc;
 use emath::TSTransform;
 
 use crate::{
-    layers::ShapeIdx, text::CCursor, text_selection::CCursorRange, Context, CursorIcon, Event,
-    Galley, Id, LayerId, Pos2, Rect, Response, Ui,
+    Context, CursorIcon, Event, Galley, Id, LayerId, Plugin, Pos2, Rect, Response, Ui,
+    layers::ShapeIdx, text::CCursor, text_selection::CCursorRange,
 };
 
 use super::{
+    TextCursorState,
     text_cursor_state::cursor_rect,
-    visuals::{paint_text_selection, RowVertexIndices},
-    CursorRange, TextCursorState,
+    visuals::{RowVertexIndices, paint_text_selection},
 };
 
 /// Turn on to help debug this
@@ -44,7 +44,7 @@ impl WidgetTextCursor {
 }
 
 fn pos_in_galley(galley: &Galley, ccursor: CCursor) -> Pos2 {
-    galley.pos_from_ccursor(ccursor).center()
+    galley.pos_from_cursor(ccursor).center()
 }
 
 impl std::fmt::Debug for WidgetTextCursor {
@@ -123,70 +123,53 @@ impl Default for LabelSelectionState {
     }
 }
 
-impl LabelSelectionState {
-    pub(crate) fn register(ctx: &Context) {
-        ctx.on_begin_pass("LabelSelectionState", std::sync::Arc::new(Self::begin_pass));
-        ctx.on_end_pass("LabelSelectionState", std::sync::Arc::new(Self::end_pass));
+impl Plugin for LabelSelectionState {
+    fn debug_name(&self) -> &'static str {
+        "LabelSelectionState"
     }
 
-    pub fn load(ctx: &Context) -> Self {
-        let id = Id::new(ctx.viewport_id());
-        ctx.data(|data| data.get_temp::<Self>(id))
-            .unwrap_or_default()
-    }
-
-    pub fn store(self, ctx: &Context) {
-        let id = Id::new(ctx.viewport_id());
-        ctx.data_mut(|data| {
-            data.insert_temp(id, self);
-        });
-    }
-
-    fn begin_pass(ctx: &Context) {
-        let mut state = Self::load(ctx);
-
+    fn on_begin_pass(&mut self, ctx: &Context) {
         if ctx.input(|i| i.pointer.any_pressed() && !i.modifiers.shift) {
             // Maybe a new selection is about to begin, but the old one is over:
             // state.selection = None; // TODO(emilk): this makes sense, but doesn't work as expected.
         }
 
-        state.selection_bbox_last_frame = state.selection_bbox_this_frame;
-        state.selection_bbox_this_frame = Rect::NOTHING;
+        self.selection_bbox_last_frame = self.selection_bbox_this_frame;
+        self.selection_bbox_this_frame = Rect::NOTHING;
 
-        state.any_hovered = false;
-        state.has_reached_primary = false;
-        state.has_reached_secondary = false;
-        state.text_to_copy.clear();
-        state.last_copied_galley_rect = None;
-        state.painted_selections.clear();
-
-        state.store(ctx);
+        self.any_hovered = false;
+        self.has_reached_primary = false;
+        self.has_reached_secondary = false;
+        self.text_to_copy.clear();
+        self.last_copied_galley_rect = None;
+        self.painted_selections.clear();
     }
 
-    fn end_pass(ctx: &Context) {
-        let mut state = Self::load(ctx);
-
-        if state.is_dragging {
+    fn on_end_pass(&mut self, ctx: &Context) {
+        if self.is_dragging {
             ctx.set_cursor_icon(CursorIcon::Text);
         }
 
-        if !state.has_reached_primary || !state.has_reached_secondary {
+        if !self.has_reached_primary || !self.has_reached_secondary {
             // We didn't see both cursors this frame,
             // maybe because they are outside the visible area (scrolling),
             // or one disappeared. In either case we will have horrible glitches, so let's just deselect.
 
-            let prev_selection = state.selection.take();
+            let prev_selection = self.selection.take();
             if let Some(selection) = prev_selection {
                 // This was the first frame of glitch, so hide the
                 // glitching by removing all painted selections:
                 ctx.graphics_mut(|layers| {
                     if let Some(list) = layers.get_mut(selection.layer_id) {
-                        for (shape_idx, row_selections) in state.painted_selections.drain(..) {
+                        for (shape_idx, row_selections) in self.painted_selections.drain(..) {
                             list.mutate_shape(shape_idx, |shape| {
                                 if let epaint::Shape::Text(text_shape) = &mut shape.shape {
                                     let galley = Arc::make_mut(&mut text_shape.galley);
                                     for row_selection in row_selections {
-                                        if let Some(row) = galley.rows.get_mut(row_selection.row) {
+                                        if let Some(placed_row) =
+                                            galley.rows.get_mut(row_selection.row)
+                                        {
+                                            let row = Arc::make_mut(&mut placed_row.row);
                                             for vertex_index in row_selection.vertex_indices {
                                                 if let Some(vertex) = row
                                                     .visuals
@@ -208,25 +191,25 @@ impl LabelSelectionState {
         }
 
         let pressed_escape = ctx.input(|i| i.key_pressed(crate::Key::Escape));
-        let clicked_something_else = ctx.input(|i| i.pointer.any_pressed()) && !state.any_hovered;
+        let clicked_something_else = ctx.input(|i| i.pointer.any_pressed()) && !self.any_hovered;
         let delected_everything = pressed_escape || clicked_something_else;
 
         if delected_everything {
-            state.selection = None;
+            self.selection = None;
         }
 
         if ctx.input(|i| i.pointer.any_released()) {
-            state.is_dragging = false;
+            self.is_dragging = false;
         }
 
-        let text_to_copy = std::mem::take(&mut state.text_to_copy);
+        let text_to_copy = std::mem::take(&mut self.text_to_copy);
         if !text_to_copy.is_empty() {
             ctx.copy_text(text_to_copy);
         }
-
-        state.store(ctx);
     }
+}
 
+impl LabelSelectionState {
     pub fn has_selection(&self) -> bool {
         self.selection.is_some()
     }
@@ -235,7 +218,7 @@ impl LabelSelectionState {
         self.selection = None;
     }
 
-    fn copy_text(&mut self, new_galley_rect: Rect, galley: &Galley, cursor_range: &CursorRange) {
+    fn copy_text(&mut self, new_galley_rect: Rect, galley: &Galley, cursor_range: &CCursorRange) {
         let new_text = selected_text(galley, cursor_range);
         if new_text.is_empty() {
             return;
@@ -294,7 +277,8 @@ impl LabelSelectionState {
         fallback_color: epaint::Color32,
         underline: epaint::Stroke,
     ) {
-        let mut state = Self::load(ui.ctx());
+        let plugin = ui.ctx().plugin::<Self>();
+        let mut state = plugin.lock();
         let new_vertex_indices = state.on_label(ui, response, galley_pos, &mut galley);
 
         let shape_idx = ui.painter().add(
@@ -306,8 +290,6 @@ impl LabelSelectionState {
                 .painted_selections
                 .push((shape_idx, new_vertex_indices));
         }
-
-        state.store(ui.ctx());
     }
 
     fn cursor_for(
@@ -334,74 +316,74 @@ impl LabelSelectionState {
         let may_select_widget =
             multi_widget_text_select || selection.primary.widget_id == response.id;
 
-        if self.is_dragging && may_select_widget {
-            if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
-                let galley_rect =
-                    global_from_galley * Rect::from_min_size(Pos2::ZERO, galley.size());
-                let galley_rect = galley_rect.intersect(ui.clip_rect());
+        if self.is_dragging
+            && may_select_widget
+            && let Some(pointer_pos) = ui.ctx().pointer_interact_pos()
+        {
+            let galley_rect = global_from_galley * Rect::from_min_size(Pos2::ZERO, galley.size());
+            let galley_rect = galley_rect.intersect(ui.clip_rect());
 
-                let is_in_same_column = galley_rect
-                    .x_range()
-                    .intersects(self.selection_bbox_last_frame.x_range());
+            let is_in_same_column = galley_rect
+                .x_range()
+                .intersects(self.selection_bbox_last_frame.x_range());
 
-                let has_reached_primary =
-                    self.has_reached_primary || response.id == selection.primary.widget_id;
-                let has_reached_secondary =
-                    self.has_reached_secondary || response.id == selection.secondary.widget_id;
+            let has_reached_primary =
+                self.has_reached_primary || response.id == selection.primary.widget_id;
+            let has_reached_secondary =
+                self.has_reached_secondary || response.id == selection.secondary.widget_id;
 
-                let new_primary = if response.contains_pointer() {
-                    // Dragging into this widget - easy case:
-                    Some(galley.cursor_from_pos((galley_from_global * pointer_pos).to_vec2()))
-                } else if is_in_same_column
-                    && !self.has_reached_primary
-                    && selection.primary.pos.y <= selection.secondary.pos.y
-                    && pointer_pos.y <= galley_rect.top()
-                    && galley_rect.top() <= selection.secondary.pos.y
-                {
-                    // The user is dragging the text selection upwards, above the first selected widget (this one):
-                    if DEBUG {
-                        ui.ctx()
-                            .debug_text(format!("Upwards drag; include {:?}", response.id));
-                    }
-                    Some(galley.begin())
-                } else if is_in_same_column
-                    && has_reached_secondary
-                    && has_reached_primary
-                    && selection.secondary.pos.y <= selection.primary.pos.y
-                    && selection.secondary.pos.y <= galley_rect.bottom()
-                    && galley_rect.bottom() <= pointer_pos.y
-                {
-                    // The user is dragging the text selection downwards, below this widget.
-                    // We move the cursor to the end of this widget,
-                    // (and we may do the same for the next widget too).
-                    if DEBUG {
-                        ui.ctx()
-                            .debug_text(format!("Downwards drag; include {:?}", response.id));
-                    }
-                    Some(galley.end())
-                } else {
-                    None
-                };
+            let new_primary = if response.contains_pointer() {
+                // Dragging into this widget - easy case:
+                Some(galley.cursor_from_pos((galley_from_global * pointer_pos).to_vec2()))
+            } else if is_in_same_column
+                && !self.has_reached_primary
+                && selection.primary.pos.y <= selection.secondary.pos.y
+                && pointer_pos.y <= galley_rect.top()
+                && galley_rect.top() <= selection.secondary.pos.y
+            {
+                // The user is dragging the text selection upwards, above the first selected widget (this one):
+                if DEBUG {
+                    ui.ctx()
+                        .debug_text(format!("Upwards drag; include {:?}", response.id));
+                }
+                Some(galley.begin())
+            } else if is_in_same_column
+                && has_reached_secondary
+                && has_reached_primary
+                && selection.secondary.pos.y <= selection.primary.pos.y
+                && selection.secondary.pos.y <= galley_rect.bottom()
+                && galley_rect.bottom() <= pointer_pos.y
+            {
+                // The user is dragging the text selection downwards, below this widget.
+                // We move the cursor to the end of this widget,
+                // (and we may do the same for the next widget too).
+                if DEBUG {
+                    ui.ctx()
+                        .debug_text(format!("Downwards drag; include {:?}", response.id));
+                }
+                Some(galley.end())
+            } else {
+                None
+            };
 
-                if let Some(new_primary) = new_primary {
-                    selection.primary =
-                        WidgetTextCursor::new(response.id, new_primary, global_from_galley, galley);
+            if let Some(new_primary) = new_primary {
+                selection.primary =
+                    WidgetTextCursor::new(response.id, new_primary, global_from_galley, galley);
 
-                    // We don't want the latency of `drag_started`.
-                    let drag_started = ui.input(|i| i.pointer.any_pressed());
-                    if drag_started {
-                        if selection.layer_id == response.layer_id {
-                            if ui.input(|i| i.modifiers.shift) {
-                                // A continuation of a previous selection.
-                            } else {
-                                // A new selection in the same layer.
-                                selection.secondary = selection.primary;
-                            }
+                // We don't want the latency of `drag_started`.
+                let drag_started = ui.input(|i| i.pointer.any_pressed());
+                if drag_started {
+                    if selection.layer_id == response.layer_id {
+                        if ui.input(|i| i.modifiers.shift) {
+                            // A continuation of a previous selection.
                         } else {
-                            // A new selection in a new layer.
-                            selection.layer_id = response.layer_id;
+                            // A new selection in the same layer.
                             selection.secondary = selection.primary;
                         }
+                    } else {
+                        // A new selection in a new layer.
+                        selection.layer_id = response.layer_id;
+                        selection.secondary = selection.primary;
                     }
                 }
             }
@@ -433,7 +415,11 @@ impl LabelSelectionState {
         match (primary, secondary) {
             (Some(primary), Some(secondary)) => {
                 // This is the only selected label.
-                TextCursorState::from(CCursorRange { primary, secondary })
+                TextCursorState::from(CCursorRange {
+                    primary,
+                    secondary,
+                    h_pos: None,
+                })
             }
 
             (Some(primary), None) => {
@@ -442,12 +428,16 @@ impl LabelSelectionState {
                     // Secondary was before primary.
                     // Select everything up to the cursor.
                     // We assume normal left-to-right and top-down layout order here.
-                    galley.begin().ccursor
+                    galley.begin()
                 } else {
                     // Select everything from the cursor onward:
-                    galley.end().ccursor
+                    galley.end()
                 };
-                TextCursorState::from(CCursorRange { primary, secondary })
+                TextCursorState::from(CCursorRange {
+                    primary,
+                    secondary,
+                    h_pos: None,
+                })
             }
 
             (None, Some(secondary)) => {
@@ -456,12 +446,16 @@ impl LabelSelectionState {
                     // Primary was before secondary.
                     // Select everything up to the cursor.
                     // We assume normal left-to-right and top-down layout order here.
-                    galley.begin().ccursor
+                    galley.begin()
                 } else {
                     // Select everything from the cursor onward:
-                    galley.end().ccursor
+                    galley.end()
                 };
-                TextCursorState::from(CCursorRange { primary, secondary })
+                TextCursorState::from(CCursorRange {
+                    primary,
+                    secondary,
+                    h_pos: None,
+                })
             }
 
             (None, None) => {
@@ -517,33 +511,33 @@ impl LabelSelectionState {
 
         let old_range = cursor_state.range(galley);
 
-        if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
-            if response.contains_pointer() {
-                let cursor_at_pointer =
-                    galley.cursor_from_pos((galley_from_global * pointer_pos).to_vec2());
+        if let Some(pointer_pos) = ui.ctx().pointer_interact_pos()
+            && response.contains_pointer()
+        {
+            let cursor_at_pointer =
+                galley.cursor_from_pos((galley_from_global * pointer_pos).to_vec2());
 
-                // This is where we handle start-of-drag and double-click-to-select.
-                // Actual drag-to-select happens elsewhere.
-                let dragged = false;
-                cursor_state.pointer_interaction(ui, response, cursor_at_pointer, galley, dragged);
-            }
+            // This is where we handle start-of-drag and double-click-to-select.
+            // Actual drag-to-select happens elsewhere.
+            let dragged = false;
+            cursor_state.pointer_interaction(ui, response, cursor_at_pointer, galley, dragged);
         }
 
         if let Some(mut cursor_range) = cursor_state.range(galley) {
             let galley_rect = global_from_galley * Rect::from_min_size(Pos2::ZERO, galley.size());
-            self.selection_bbox_this_frame = self.selection_bbox_this_frame.union(galley_rect);
+            self.selection_bbox_this_frame |= galley_rect;
 
-            if let Some(selection) = &self.selection {
-                if selection.primary.widget_id == response.id {
-                    process_selection_key_events(ui.ctx(), galley, response.id, &mut cursor_range);
-                }
+            if let Some(selection) = &self.selection
+                && selection.primary.widget_id == response.id
+            {
+                process_selection_key_events(ui.ctx(), galley, response.id, &mut cursor_range);
             }
 
             if got_copy_event(ui.ctx()) {
                 self.copy_text(galley_rect, galley, &cursor_range);
             }
 
-            cursor_state.set_range(Some(cursor_range));
+            cursor_state.set_char_range(Some(cursor_range));
         }
 
         // Look for changes due to keyboard and/or mouse interaction:
@@ -601,7 +595,7 @@ impl LabelSelectionState {
             let old_primary = old_selection.map(|s| s.primary);
             let new_primary = self.selection.as_ref().map(|s| s.primary);
             if let Some(new_primary) = new_primary {
-                let primary_changed = old_primary.map_or(true, |old| {
+                let primary_changed = old_primary.is_none_or(|old| {
                     old.widget_id != new_primary.widget_id || old.ccursor != new_primary.ccursor
                 });
                 if primary_changed && new_primary.widget_id == widget_id {
@@ -630,7 +624,6 @@ impl LabelSelectionState {
             );
         }
 
-        #[cfg(feature = "accesskit")]
         super::accesskit_text::update_accesskit_for_text_widget(
             ui.ctx(),
             response.id,
@@ -657,7 +650,7 @@ fn process_selection_key_events(
     ctx: &Context,
     galley: &Galley,
     widget_id: Id,
-    cursor_range: &mut CursorRange,
+    cursor_range: &mut CCursorRange,
 ) -> bool {
     let os = ctx.os();
 
@@ -674,10 +667,10 @@ fn process_selection_key_events(
     changed
 }
 
-fn selected_text(galley: &Galley, cursor_range: &CursorRange) -> String {
+fn selected_text(galley: &Galley, cursor_range: &CCursorRange) -> String {
     // This logic means we can select everything in an elided label (including the `…`)
     // and still copy the entire un-elided text!
-    let everything_is_selected = cursor_range.contains(&CursorRange::select_all(galley));
+    let everything_is_selected = cursor_range.contains(CCursorRange::select_all(galley));
 
     let copy_everything = cursor_range.is_empty() || everything_is_selected;
 
@@ -689,8 +682,8 @@ fn selected_text(galley: &Galley, cursor_range: &CursorRange) -> String {
 }
 
 fn estimate_row_height(galley: &Galley) -> f32 {
-    if let Some(row) = galley.rows.first() {
-        row.rect.height()
+    if let Some(placed_row) = galley.rows.first() {
+        placed_row.height()
     } else {
         galley.size().y
     }
diff --git a/crates/egui/src/text_selection/mod.rs b/crates/egui/src/text_selection/mod.rs
index 5be95eb53..cbd51c31a 100644
--- a/crates/egui/src/text_selection/mod.rs
+++ b/crates/egui/src/text_selection/mod.rs
@@ -1,6 +1,5 @@
 //! Helpers regarding text selection for labels and text edit.
 
-#[cfg(feature = "accesskit")]
 pub mod accesskit_text;
 
 mod cursor_range;
@@ -8,6 +7,6 @@ mod label_text_selection;
 pub mod text_cursor_state;
 pub mod visuals;
 
-pub use cursor_range::{CCursorRange, CursorRange, PCursorRange};
+pub use cursor_range::CCursorRange;
 pub use label_text_selection::LabelSelectionState;
 pub use text_cursor_state::TextCursorState;
diff --git a/crates/egui/src/text_selection/text_cursor_state.rs b/crates/egui/src/text_selection/text_cursor_state.rs
index ebc618b2c..2a02e4577 100644
--- a/crates/egui/src/text_selection/text_cursor_state.rs
+++ b/crates/egui/src/text_selection/text_cursor_state.rs
@@ -1,13 +1,11 @@
 //! Text cursor changes/interaction, without modifying the text.
 
-use epaint::text::{
-    cursor::{CCursor, Cursor},
-    Galley,
-};
+use epaint::text::{Galley, cursor::CCursor};
+use unicode_segmentation::UnicodeSegmentation as _;
 
-use crate::{epaint, NumExt, Rect, Response, Ui};
+use crate::{NumExt as _, Rect, Response, Ui, epaint};
 
-use super::{CCursorRange, CursorRange};
+use super::CCursorRange;
 
 /// The state of a text cursor selection.
 ///
@@ -16,29 +14,12 @@ use super::{CCursorRange, CursorRange};
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct TextCursorState {
-    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>,
 }
 
-impl From<CursorRange> for TextCursorState {
-    fn from(cursor_range: CursorRange) -> Self {
-        Self {
-            cursor_range: Some(cursor_range),
-            ccursor_range: Some(CCursorRange {
-                primary: cursor_range.primary.ccursor,
-                secondary: cursor_range.secondary.ccursor,
-            }),
-        }
-    }
-}
-
 impl From<CCursorRange> for TextCursorState {
     fn from(ccursor_range: CCursorRange) -> Self {
         Self {
-            cursor_range: None,
             ccursor_range: Some(ccursor_range),
         }
     }
@@ -46,50 +27,28 @@ impl From<CCursorRange> for TextCursorState {
 
 impl TextCursorState {
     pub fn is_empty(&self) -> bool {
-        self.cursor_range.is_none() && self.ccursor_range.is_none()
+        self.ccursor_range.is_none()
     }
 
     /// The currently selected range of characters.
     pub fn char_range(&self) -> Option<CCursorRange> {
-        self.ccursor_range.or_else(|| {
-            self.cursor_range
-                .map(|cursor_range| cursor_range.as_ccursor_range())
-        })
+        self.ccursor_range
     }
 
-    pub fn range(&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),
-                })
-            })
+    /// The currently selected range of characters, clamped within the character
+    /// range of the given [`Galley`].
+    pub fn range(&self, galley: &Galley) -> Option<CCursorRange> {
+        self.ccursor_range.map(|mut range| {
+            range.primary = galley.clamp_cursor(&range.primary);
+            range.secondary = galley.clamp_cursor(&range.secondary);
+            range
+        })
     }
 
     /// Sets the currently selected range of characters.
     pub fn set_char_range(&mut self, ccursor_range: Option<CCursorRange>) {
-        self.cursor_range = None;
         self.ccursor_range = ccursor_range;
     }
-
-    pub fn set_range(&mut self, cursor_range: Option<CursorRange>) {
-        self.cursor_range = cursor_range;
-        self.ccursor_range = None;
-    }
 }
 
 impl TextCursorState {
@@ -100,7 +59,7 @@ impl TextCursorState {
         &mut self,
         ui: &Ui,
         response: &Response,
-        cursor_at_pointer: Cursor,
+        cursor_at_pointer: CCursor,
         galley: &Galley,
         is_being_dragged: bool,
     ) -> bool {
@@ -108,19 +67,13 @@ impl TextCursorState {
 
         if response.double_clicked() {
             // Select word:
-            let ccursor_range = select_word_at(text, cursor_at_pointer.ccursor);
-            self.set_range(Some(CursorRange {
-                primary: galley.from_ccursor(ccursor_range.primary),
-                secondary: galley.from_ccursor(ccursor_range.secondary),
-            }));
+            let ccursor_range = select_word_at(text, cursor_at_pointer);
+            self.set_char_range(Some(ccursor_range));
             true
         } else if response.triple_clicked() {
             // Select line:
-            let ccursor_range = select_line_at(text, cursor_at_pointer.ccursor);
-            self.set_range(Some(CursorRange {
-                primary: galley.from_ccursor(ccursor_range.primary),
-                secondary: galley.from_ccursor(ccursor_range.secondary),
-            }));
+            let ccursor_range = select_line_at(text, cursor_at_pointer);
+            self.set_char_range(Some(ccursor_range));
             true
         } else if response.sense.senses_drag() {
             if response.hovered() && ui.input(|i| i.pointer.any_pressed()) {
@@ -128,19 +81,19 @@ impl TextCursorState {
                 if ui.input(|i| i.modifiers.shift) {
                     if let Some(mut cursor_range) = self.range(galley) {
                         cursor_range.primary = cursor_at_pointer;
-                        self.set_range(Some(cursor_range));
+                        self.set_char_range(Some(cursor_range));
                     } else {
-                        self.set_range(Some(CursorRange::one(cursor_at_pointer)));
+                        self.set_char_range(Some(CCursorRange::one(cursor_at_pointer)));
                     }
                 } else {
-                    self.set_range(Some(CursorRange::one(cursor_at_pointer)));
+                    self.set_char_range(Some(CCursorRange::one(cursor_at_pointer)));
                 }
                 true
             } else if is_being_dragged {
                 // Drag to select text:
                 if let Some(mut cursor_range) = self.range(galley) {
                     cursor_range.primary = cursor_at_pointer;
-                    self.set_range(Some(cursor_range));
+                    self.set_char_range(Some(cursor_range));
                 }
                 true
             } else {
@@ -224,7 +177,7 @@ fn select_line_at(text: &str, ccursor: CCursor) -> CCursorRange {
 
 pub fn ccursor_next_word(text: &str, ccursor: CCursor) -> CCursor {
     CCursor {
-        index: next_word_boundary_char_index(text.chars(), ccursor.index),
+        index: next_word_boundary_char_index(text, ccursor.index),
         prefer_next_row: false,
     }
 }
@@ -238,9 +191,10 @@ fn ccursor_next_line(text: &str, ccursor: CCursor) -> CCursor {
 
 pub fn ccursor_previous_word(text: &str, ccursor: CCursor) -> CCursor {
     let num_chars = text.chars().count();
+    let reversed: String = text.graphemes(true).rev().collect();
     CCursor {
         index: num_chars
-            - next_word_boundary_char_index(text.chars().rev(), num_chars - ccursor.index),
+            - next_word_boundary_char_index(&reversed, num_chars - ccursor.index).min(num_chars),
         prefer_next_row: true,
     }
 }
@@ -254,22 +208,25 @@ fn ccursor_previous_line(text: &str, ccursor: CCursor) -> CCursor {
     }
 }
 
-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;
-            }
+fn next_word_boundary_char_index(text: &str, index: usize) -> usize {
+    for word in text.split_word_bound_indices() {
+        // Splitting considers contiguous whitespace as one word, such words must be skipped,
+        // this handles cases for example ' abc' (a space and a word), the cursor is at the beginning
+        // (before space) - this jumps at the end of 'abc' (this is consistent with text editors
+        // or browsers)
+        let ci = char_index_from_byte_index(text, word.0);
+        if ci > index && !skip_word(word.1) {
+            return ci;
         }
     }
-    index
+
+    char_index_from_byte_index(text, text.len())
+}
+
+fn skip_word(text: &str) -> bool {
+    // skip words that contain anything other than alphanumeric characters and underscore
+    // (i.e. whitespace, dashes, etc.)
+    !text.chars().any(|c| !is_word_char(c))
 }
 
 fn next_line_boundary_char_index(it: impl Iterator<Item = char>, mut index: usize) -> usize {
@@ -291,7 +248,7 @@ fn next_line_boundary_char_index(it: impl Iterator<Item = char>, mut index: usiz
 }
 
 pub fn is_word_char(c: char) -> bool {
-    c.is_ascii_alphanumeric() || c == '_'
+    c.is_alphanumeric() || c == '_'
 }
 
 fn is_linebreak(c: char) -> bool {
@@ -328,16 +285,31 @@ pub fn byte_index_from_char_index(s: &str, char_index: usize) -> usize {
     s.len()
 }
 
+pub fn char_index_from_byte_index(input: &str, byte_index: usize) -> usize {
+    for (ci, (bi, _)) in input.char_indices().enumerate() {
+        if bi == byte_index {
+            return ci;
+        }
+    }
+
+    input.char_indices().last().map_or(0, |(i, _)| i + 1)
+}
+
 pub fn slice_char_range(s: &str, char_range: std::ops::Range<usize>) -> &str {
-    assert!(char_range.start <= char_range.end);
+    assert!(
+        char_range.start <= char_range.end,
+        "Invalid range, start must be less than end, but start = {}, end = {}",
+        char_range.start,
+        char_range.end
+    );
     let start_byte = byte_index_from_char_index(s, char_range.start);
     let end_byte = byte_index_from_char_index(s, char_range.end);
     &s[start_byte..end_byte]
 }
 
 /// The thin rectangle of one end of the selection, e.g. the primary cursor, in local galley coordinates.
-pub fn cursor_rect(galley: &Galley, cursor: &Cursor, row_height: f32) -> Rect {
-    let mut cursor_pos = galley.pos_from_cursor(cursor);
+pub fn cursor_rect(galley: &Galley, cursor: &CCursor, row_height: f32) -> Rect {
+    let mut cursor_pos = galley.pos_from_cursor(*cursor);
 
     // Handle completely empty galleys
     cursor_pos.max.y = cursor_pos.max.y.at_least(cursor_pos.min.y + row_height);
@@ -346,3 +318,38 @@ pub fn cursor_rect(galley: &Galley, cursor: &Cursor, row_height: f32) -> Rect {
 
     cursor_pos
 }
+
+#[cfg(test)]
+mod test {
+    use crate::text_selection::text_cursor_state::next_word_boundary_char_index;
+
+    #[test]
+    fn test_next_word_boundary_char_index() {
+        // ASCII only
+        let text = "abc d3f g_h i-j";
+        assert_eq!(next_word_boundary_char_index(text, 1), 3);
+        assert_eq!(next_word_boundary_char_index(text, 3), 7);
+        assert_eq!(next_word_boundary_char_index(text, 9), 11);
+        assert_eq!(next_word_boundary_char_index(text, 12), 13);
+        assert_eq!(next_word_boundary_char_index(text, 13), 15);
+        assert_eq!(next_word_boundary_char_index(text, 15), 15);
+
+        assert_eq!(next_word_boundary_char_index("", 0), 0);
+        assert_eq!(next_word_boundary_char_index("", 1), 0);
+
+        // Unicode graphemes, some of which consist of multiple Unicode characters,
+        // !!! Unicode character is not always what is tranditionally considered a character,
+        // the values below are correct despite not seeming that way on the first look,
+        // handling of and around emojis is kind of weird and is not consistent across
+        // text editors and browsers
+        let text = "❤️👍 skvělá knihovna 👍❤️";
+        assert_eq!(next_word_boundary_char_index(text, 0), 2);
+        assert_eq!(next_word_boundary_char_index(text, 2), 3); // this does not skip the space between thumbs-up and 'skvělá'
+        assert_eq!(next_word_boundary_char_index(text, 6), 10);
+        assert_eq!(next_word_boundary_char_index(text, 9), 10);
+        assert_eq!(next_word_boundary_char_index(text, 12), 19);
+        assert_eq!(next_word_boundary_char_index(text, 15), 19);
+        assert_eq!(next_word_boundary_char_index(text, 19), 20);
+        assert_eq!(next_word_boundary_char_index(text, 20), 21);
+    }
+}
diff --git a/crates/egui/src/text_selection/visuals.rs b/crates/egui/src/text_selection/visuals.rs
index dd7c867a2..50bb1a34d 100644
--- a/crates/egui/src/text_selection/visuals.rs
+++ b/crates/egui/src/text_selection/visuals.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use crate::{pos2, vec2, Galley, Painter, Rect, Ui, Visuals};
+use crate::{Galley, Painter, Rect, Ui, Visuals, pos2, vec2};
 
-use super::CursorRange;
+use super::CCursorRange;
 
 #[derive(Clone, Debug)]
 pub struct RowVertexIndices {
@@ -14,7 +14,7 @@ pub struct RowVertexIndices {
 pub fn paint_text_selection(
     galley: &mut Arc<Galley>,
     visuals: &Visuals,
-    cursor_range: &CursorRange,
+    cursor_range: &CCursorRange,
     mut new_vertex_indices: Option<&mut Vec<RowVertexIndices>>,
 ) {
     if cursor_range.is_empty() {
@@ -25,32 +25,61 @@ pub fn paint_text_selection(
     // and so we need to clone it if it is shared:
     let galley: &mut Galley = Arc::make_mut(galley);
 
-    let color = visuals.selection.bg_fill;
+    let background_color = visuals.selection.bg_fill;
+    let text_color = visuals.selection.stroke.color;
+
     let [min, max] = cursor_range.sorted_cursors();
-    let min = min.rcursor;
-    let max = max.rcursor;
+    let min = galley.layout_from_cursor(min);
+    let max = galley.layout_from_cursor(max);
 
     for ri in min.row..=max.row {
-        let row = &mut galley.rows[ri];
+        let placed_row = &mut galley.rows[ri];
+        let row = Arc::make_mut(&mut placed_row.row);
+
         let left = if ri == min.row {
             row.x_offset(min.column)
         } else {
-            row.rect.left()
+            0.0
         };
         let right = if ri == max.row {
             row.x_offset(max.column)
         } else {
-            let newline_size = if row.ends_with_newline {
+            let newline_size = if placed_row.ends_with_newline {
                 row.height() / 2.0 // visualize that we select the newline
             } else {
                 0.0
             };
-            row.rect.right() + newline_size
+            row.size.x + newline_size
         };
 
-        let rect = Rect::from_min_max(pos2(left, row.min_y()), pos2(right, row.max_y()));
+        let rect = Rect::from_min_max(pos2(left, 0.0), pos2(right, row.size.y));
         let mesh = &mut row.visuals.mesh;
 
+        if !row.glyphs.is_empty() {
+            // Change color of the selected text:
+            let first_glyph_index = if ri == min.row { min.column } else { 0 };
+            let last_glyph_index = if ri == max.row {
+                max.column
+            } else {
+                row.glyphs.len() - 1
+            };
+
+            let first_vertex_index = row
+                .glyphs
+                .get(first_glyph_index)
+                .map_or(row.visuals.glyph_vertex_range.start, |g| {
+                    g.first_vertex as _
+                });
+            let last_vertex_index = row
+                .glyphs
+                .get(last_glyph_index)
+                .map_or(row.visuals.glyph_vertex_range.end, |g| g.first_vertex as _);
+
+            for vi in first_vertex_index..last_vertex_index {
+                mesh.vertices[vi].color = text_color;
+            }
+        }
+
         // Time to insert the selection rectangle into the row mesh.
         // It should be on top (after) of any background in the galley,
         // but behind (before) any glyphs. The row visuals has this information:
@@ -58,8 +87,12 @@ pub fn paint_text_selection(
 
         // Start by appending the selection rectangle to end of the mesh, as two triangles (= 6 indices):
         let num_indices_before = mesh.indices.len();
-        mesh.add_colored_rect(rect, color);
-        assert_eq!(num_indices_before + 6, mesh.indices.len());
+        mesh.add_colored_rect(rect, background_color);
+        assert_eq!(
+            num_indices_before + 6,
+            mesh.indices.len(),
+            "We expect exactly 6 new indices"
+        );
 
         // Copy out the new triangles:
         let selection_triangles = [
diff --git a/crates/egui/src/ui.rs b/crates/egui/src/ui.rs
index e7aaaa915..3c7fca2f3 100644
--- a/crates/egui/src/ui.rs
+++ b/crates/egui/src/ui.rs
@@ -1,36 +1,34 @@
 #![warn(missing_docs)] // Let's keep `Ui` well-documented.
 #![allow(clippy::use_self)]
 
-use std::{any::Any, hash::Hash, sync::Arc};
-
 use emath::GuiRounding as _;
 use epaint::mutex::RwLock;
+use epaint::text::FontsView;
+use std::{any::Any, hash::Hash, sync::Arc};
 
+use crate::ClosableTag;
+#[cfg(debug_assertions)]
+use crate::Stroke;
+use crate::containers::menu;
 use crate::{
+    Align, Color32, Context, CursorIcon, DragAndDrop, Id, InnerResponse, InputState, IntoAtoms,
+    LayerId, Memory, Order, Painter, PlatformOutput, Pos2, Rangef, Rect, Response, Rgba, RichText,
+    Sense, Style, TextStyle, TextWrapMode, UiBuilder, UiKind, UiStack, UiStackInfo, Vec2,
+    WidgetRect, WidgetText,
     containers::{CollapsingHeader, CollapsingResponse, Frame},
     ecolor::Hsva,
-    emath, epaint,
-    epaint::text::Fonts,
-    grid,
+    emath, epaint, grid,
     layout::{Direction, Layout},
-    menu,
-    menu::MenuState,
     pass_state,
     placer::Placer,
     pos2, style,
     util::IdTypeMap,
     vec2, widgets,
     widgets::{
-        color_picker, Button, Checkbox, DragValue, Hyperlink, Image, ImageSource, Label, Link,
-        RadioButton, SelectableLabel, Separator, Spinner, TextEdit, Widget,
+        Button, Checkbox, DragValue, Hyperlink, Image, ImageSource, Label, Link, RadioButton,
+        Separator, Spinner, TextEdit, Widget, color_picker,
     },
-    Align, Color32, Context, CursorIcon, DragAndDrop, Id, InnerResponse, InputState, LayerId,
-    Memory, Order, Painter, PlatformOutput, Pos2, Rangef, Rect, Response, Rgba, RichText, Sense,
-    Style, TextStyle, TextWrapMode, UiBuilder, UiStack, UiStackInfo, Vec2, WidgetRect, WidgetText,
 };
-
-#[cfg(debug_assertions)]
-use crate::Stroke;
 // ----------------------------------------------------------------------------
 
 /// This is what you use to place widgets.
@@ -99,7 +97,8 @@ pub struct Ui {
     sizing_pass: bool,
 
     /// Indicates whether this Ui belongs to a Menu.
-    menu_state: Option<Arc<RwLock<MenuState>>>,
+    #[expect(deprecated)]
+    menu_state: Option<Arc<RwLock<crate::menu::MenuState>>>,
 
     /// The [`UiStack`] for this [`Ui`].
     stack: Arc<UiStack>,
@@ -124,6 +123,7 @@ impl Ui {
     pub fn new(ctx: Context, id: Id, ui_builder: UiBuilder) -> Self {
         let UiBuilder {
             id_salt,
+            global_scope: _,
             ui_stack_info,
             layer_id,
             max_rect,
@@ -133,6 +133,7 @@ impl Ui {
             sizing_pass,
             style,
             sense,
+            accessibility_parent,
         } = ui_builder;
 
         let layer_id = layer_id.unwrap_or(LayerId::background());
@@ -142,7 +143,7 @@ impl Ui {
             "Top-level Ui:s should not have an id_salt"
         );
 
-        let max_rect = max_rect.unwrap_or_else(|| ctx.screen_rect());
+        let max_rect = max_rect.unwrap_or_else(|| ctx.content_rect());
         let clip_rect = max_rect;
         let layout = layout.unwrap_or_default();
         let disabled = disabled || invisible;
@@ -173,6 +174,11 @@ impl Ui {
             min_rect_already_remembered: false,
         };
 
+        if let Some(accessibility_parent) = accessibility_parent {
+            ui.ctx()
+                .register_accesskit_parent(ui.unique_id, accessibility_parent);
+        }
+
         // Register in the widget stack early, to ensure we are behind all widgets we contain:
         let start_rect = Rect::NOTHING; // This will be overwritten when `remember_min_rect` is called
         ui.ctx().create_widget(
@@ -194,6 +200,10 @@ impl Ui {
             ui.set_invisible();
         }
 
+        ui.ctx().accesskit_node_builder(ui.unique_id, |node| {
+            node.set_role(accesskit::Role::GenericContainer);
+        });
+
         ui
     }
 
@@ -250,6 +260,7 @@ impl Ui {
     pub fn new_child(&mut self, ui_builder: UiBuilder) -> Self {
         let UiBuilder {
             id_salt,
+            global_scope,
             ui_stack_info,
             layer_id,
             max_rect,
@@ -259,6 +270,7 @@ impl Ui {
             sizing_pass,
             style,
             sense,
+            accessibility_parent,
         } = ui_builder;
 
         let mut painter = self.painter.clone();
@@ -286,9 +298,15 @@ impl Ui {
             }
         }
 
-        debug_assert!(!max_rect.any_nan());
-        let stable_id = self.id.with(id_salt);
-        let unique_id = stable_id.with(self.next_auto_id_salt);
+        debug_assert!(!max_rect.any_nan(), "max_rect is NaN: {max_rect:?}");
+        let (stable_id, unique_id) = if global_scope {
+            (id_salt, id_salt)
+        } else {
+            let stable_id = self.id.with(id_salt);
+            let unique_id = stable_id.with(self.next_auto_id_salt);
+
+            (stable_id, unique_id)
+        };
         let next_auto_id_salt = unique_id.value().wrapping_add(1);
 
         self.next_auto_id_salt = self.next_auto_id_salt.wrapping_add(1);
@@ -321,6 +339,11 @@ impl Ui {
             child_ui.disable();
         }
 
+        child_ui.ctx().register_accesskit_parent(
+            child_ui.unique_id,
+            accessibility_parent.unwrap_or(self.unique_id),
+        );
+
         // Register in the widget stack early, to ensure we are behind all widgets we contain:
         let start_rect = Rect::NOTHING; // This will be overwritten when `remember_min_rect` is called
         child_ui.ctx().create_widget(
@@ -335,6 +358,12 @@ impl Ui {
             true,
         );
 
+        child_ui
+            .ctx()
+            .accesskit_node_builder(child_ui.unique_id, |node| {
+                node.set_role(accesskit::Role::GenericContainer);
+            });
+
         child_ui
     }
 
@@ -369,7 +398,7 @@ impl Ui {
     ///
     /// However, it is not necessarily globally unique.
     /// For instance, sibling `Ui`s share the same [`Self::id`]
-    /// unless they where explicitly given different id salts using
+    /// unless they were explicitly given different id salts using
     /// [`UiBuilder::id_salt`].
     #[inline]
     pub fn id(&self) -> Id {
@@ -522,7 +551,7 @@ impl Ui {
         self.enabled = false;
         if self.is_visible() {
             self.painter
-                .set_fade_to_color(Some(self.visuals().fade_out_to_color()));
+                .multiply_opacity(self.visuals().disabled_alpha());
         }
     }
 
@@ -666,7 +695,7 @@ impl Ui {
     ///
     /// This is determined first by [`Style::wrap_mode`], and then by the layout of this [`Ui`].
     pub fn wrap_mode(&self) -> TextWrapMode {
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         if let Some(wrap_mode) = self.style.wrap_mode {
             wrap_mode
         }
@@ -727,7 +756,7 @@ impl Ui {
     ///
     /// Returns a value rounded to [`emath::GUI_ROUNDING`].
     pub fn text_style_height(&self, style: &TextStyle) -> f32 {
-        self.fonts(|f| f.row_height(&style.resolve(self.style())))
+        self.fonts_mut(|f| f.row_height(&style.resolve(self.style())))
     }
 
     /// Screen-space rectangle for clipping what we paint in this ui.
@@ -839,11 +868,17 @@ impl Ui {
         self.ctx().output_mut(writer)
     }
 
-    /// Read-only access to [`Fonts`].
+    /// Read-only access to [`FontsView`].
     #[inline]
-    pub fn fonts<R>(&self, reader: impl FnOnce(&Fonts) -> R) -> R {
+    pub fn fonts<R>(&self, reader: impl FnOnce(&FontsView<'_>) -> R) -> R {
         self.ctx().fonts(reader)
     }
+
+    /// Read-write access to [`FontsView`].
+    #[inline]
+    pub fn fonts_mut<R>(&self, reader: impl FnOnce(&mut FontsView<'_>) -> R) -> R {
+        self.ctx().fonts_mut(reader)
+    }
 }
 
 // ------------------------------------------------------------------------
@@ -914,17 +949,47 @@ impl Ui {
     /// 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) {
-        debug_assert!(0.0 <= width);
+        debug_assert!(
+            0.0 <= width,
+            "Negative width makes no sense, but got: {width}"
+        );
         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) {
-        debug_assert!(0.0 <= height);
+        debug_assert!(
+            0.0 <= height,
+            "Negative height makes no sense, but got: {height}"
+        );
         self.placer.set_min_height(height);
     }
 
+    /// Makes the ui always fill up the available space.
+    ///
+    /// This can be useful to call inside a panel with `resizable == true`
+    /// to make sure the resized space is used.
+    pub fn take_available_space(&mut self) {
+        self.set_min_size(self.available_size());
+    }
+
+    /// Makes the ui always fill up the available space in the x axis.
+    ///
+    /// This can be useful to call inside a side panel with
+    /// `resizable == true` to make sure the resized space is used.
+    pub fn take_available_width(&mut self) {
+        self.set_min_width(self.available_width());
+    }
+
+    /// Makes the ui always fill up the available space in the y axis.
+    ///
+    /// This can be useful to call inside a top bottom panel with
+    /// `resizable == true` to make sure the resized space is used.
+    pub fn take_available_height(&mut self) {
+        self.set_min_height(self.available_height());
+    }
+
     // ------------------------------------------------------------------------
 
     /// Helper: shrinks the max width to the current width,
@@ -1058,6 +1123,8 @@ impl Ui {
 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().register_accesskit_parent(id, self.unique_id);
+
         self.ctx().create_widget(
             WidgetRect {
                 id,
@@ -1095,7 +1162,8 @@ impl Ui {
         // This is the inverse of Context::read_response. We prefer a response
         // based on last frame's widget rect since the one from this frame is Rect::NOTHING until
         // Ui::interact_bg is called or the Ui is dropped.
-        self.ctx()
+        let mut response = self
+            .ctx()
             .viewport(|viewport| {
                 viewport
                     .prev_pass
@@ -1107,7 +1175,11 @@ impl Ui {
             .map(|widget_rect| self.ctx().get_response(widget_rect))
             .expect(
                 "Since we always call Context::create_widget in Ui::new, this should never be None",
-            )
+            );
+        if self.should_close() {
+            response.set_close();
+        }
+        response
     }
 
     /// Update the [`WidgetRect`] created in [`Ui::new`] or [`Ui::new_child`] with the current
@@ -1121,7 +1193,7 @@ impl Ui {
             fs.used_ids.remove(&self.unique_id);
         });
         // This will update the WidgetRect that was first created in `Ui::new`.
-        self.ctx().create_widget(
+        let mut response = self.ctx().create_widget(
             WidgetRect {
                 id: self.unique_id,
                 layer_id: self.layer_id(),
@@ -1131,7 +1203,11 @@ impl Ui {
                 enabled: self.enabled,
             },
             false,
-        )
+        );
+        if self.should_close() {
+            response.set_close();
+        }
+        response
     }
 
     /// Interact with the background of this [`Ui`],
@@ -1165,6 +1241,102 @@ impl Ui {
     pub fn ui_contains_pointer(&self) -> bool {
         self.rect_contains_pointer(self.min_rect())
     }
+
+    /// Find and close the first closable parent.
+    ///
+    /// Use [`UiBuilder::closable`] to make a [`Ui`] closable.
+    /// You can then use [`Ui::should_close`] to check if it should be closed.
+    ///
+    /// This is implemented for all egui containers, e.g. [`crate::Popup`], [`crate::Modal`],
+    /// [`crate::Area`], [`crate::Window`], [`crate::CollapsingHeader`], etc.
+    ///
+    /// What exactly happens when you close a container depends on the container implementation.
+    /// [`crate::Area`] e.g. will return true from it's [`Response::should_close`] method.
+    ///
+    /// If you want to close a specific kind of container, use [`Ui::close_kind`] instead.
+    ///
+    /// Also note that this won't bubble up across [`crate::Area`]s. If needed, you can check
+    /// `response.should_close()` and close the parent manually. ([`menu`] does this for example).
+    ///
+    /// See also:
+    /// - [`Ui::close_kind`]
+    /// - [`Ui::should_close`]
+    /// - [`Ui::will_parent_close`]
+    pub fn close(&self) {
+        let tag = self.stack.iter().find_map(|stack| {
+            stack
+                .info
+                .tags
+                .get_downcast::<ClosableTag>(ClosableTag::NAME)
+        });
+        if let Some(tag) = tag {
+            tag.set_close();
+        } else {
+            log::warn!("Called ui.close() on a Ui that has no closable parent.");
+        }
+    }
+
+    /// Find and close the first closable parent of a specific [`UiKind`].
+    ///
+    /// This is useful if you want to e.g. close a [`crate::Window`]. Since it contains a
+    /// `Collapsible`, [`Ui::close`] would close the `Collapsible` instead.
+    /// You can close the [`crate::Window`] by calling `ui.close_kind(UiKind::Window)`.
+    ///
+    /// See also:
+    /// - [`Ui::close`]
+    /// - [`Ui::should_close`]
+    /// - [`Ui::will_parent_close`]
+    pub fn close_kind(&self, ui_kind: UiKind) {
+        let tag = self
+            .stack
+            .iter()
+            .filter(|stack| stack.info.kind == Some(ui_kind))
+            .find_map(|stack| {
+                stack
+                    .info
+                    .tags
+                    .get_downcast::<ClosableTag>(ClosableTag::NAME)
+            });
+        if let Some(tag) = tag {
+            tag.set_close();
+        } else {
+            log::warn!("Called ui.close_kind({ui_kind:?}) on ui with no such closable parent.");
+        }
+    }
+
+    /// Was [`Ui::close`] called on this [`Ui`] or any of its children?
+    /// Only works if the [`Ui`] was created with [`UiBuilder::closable`].
+    ///
+    /// You can also check via this [`Ui`]'s [`Response::should_close`].
+    ///
+    /// See also:
+    /// - [`Ui::will_parent_close`]
+    /// - [`Ui::close`]
+    /// - [`Ui::close_kind`]
+    /// - [`Response::should_close`]
+    pub fn should_close(&self) -> bool {
+        self.stack
+            .info
+            .tags
+            .get_downcast(ClosableTag::NAME)
+            .is_some_and(|tag: &ClosableTag| tag.should_close())
+    }
+
+    /// Will this [`Ui`] or any of its parents close this frame?
+    ///
+    /// See also
+    /// - [`Ui::should_close`]
+    /// - [`Ui::close`]
+    /// - [`Ui::close_kind`]
+    pub fn will_parent_close(&self) -> bool {
+        self.stack.iter().any(|stack| {
+            stack
+                .info
+                .tags
+                .get_downcast::<ClosableTag>(ClosableTag::NAME)
+                .is_some_and(|tag| tag.should_close())
+        })
+    }
 }
 
 /// # Allocating space: where do I put my widgets?
@@ -1292,7 +1464,7 @@ impl Ui {
     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);
-        debug_assert!(!frame_rect.any_nan());
+        debug_assert!(!frame_rect.any_nan(), "frame_rect is nan in allocate_space");
         let widget_rect = self.placer.justify_and_align(frame_rect, desired_size);
 
         self.placer
@@ -1315,7 +1487,7 @@ impl Ui {
 
     /// Allocate a rect without interacting with it.
     pub fn advance_cursor_after_rect(&mut self, rect: Rect) -> Id {
-        debug_assert!(!rect.any_nan());
+        debug_assert!(!rect.any_nan(), "rect is nan in advance_cursor_after_rect");
         let rect = rect.round_ui();
 
         let item_spacing = self.spacing().item_spacing;
@@ -1387,11 +1559,14 @@ impl Ui {
         layout: Layout,
         add_contents: Box<dyn FnOnce(&mut Self) -> R + 'c>,
     ) -> InnerResponse<R> {
-        debug_assert!(desired_size.x >= 0.0 && desired_size.y >= 0.0);
+        debug_assert!(
+            desired_size.x >= 0.0 && desired_size.y >= 0.0,
+            "Negative desired size: {desired_size:?}"
+        );
         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);
-        self.allocate_new_ui(
+        self.scope_dyn(
             UiBuilder::new().max_rect(child_rect).layout(layout),
             add_contents,
         )
@@ -1408,7 +1583,7 @@ impl Ui {
         max_rect: Rect,
         add_contents: impl FnOnce(&mut Self) -> R,
     ) -> InnerResponse<R> {
-        self.allocate_new_ui(UiBuilder::new().max_rect(max_rect), add_contents)
+        self.scope_builder(UiBuilder::new().max_rect(max_rect), add_contents)
     }
 
     /// Allocated space (`UiBuilder::max_rect`) and then add content to it.
@@ -1416,27 +1591,13 @@ impl Ui {
     /// If the contents overflow, more space will be allocated.
     /// When finished, the amount of space actually used (`min_rect`) will be allocated in the parent.
     /// So you can request a lot of space and then use less.
+    #[deprecated = "Use `scope_builder` instead"]
     pub fn allocate_new_ui<R>(
         &mut self,
         ui_builder: UiBuilder,
         add_contents: impl FnOnce(&mut Self) -> R,
     ) -> InnerResponse<R> {
-        self.allocate_new_ui_dyn(ui_builder, Box::new(add_contents))
-    }
-
-    fn allocate_new_ui_dyn<'c, R>(
-        &mut self,
-        ui_builder: UiBuilder,
-        add_contents: Box<dyn FnOnce(&mut Self) -> R + 'c>,
-    ) -> InnerResponse<R> {
-        let mut child_ui = self.new_child(ui_builder);
-        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);
-        register_rect(self, rect);
-        let response = self.interact(rect, child_ui.unique_id, Sense::hover());
-        InnerResponse::new(inner, response)
+        self.scope_dyn(ui_builder, Box::new(add_contents))
     }
 
     /// Convenience function to get a region to paint on.
@@ -1600,7 +1761,7 @@ impl Ui {
     /// 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`].
+    /// See also [`Self::add_sized`], [`Self::place`] and [`Self::put`].
     ///
     /// ```
     /// # egui::__run_test_ui(|ui| {
@@ -1619,7 +1780,7 @@ impl Ui {
     ///
     /// To fill all remaining area, use `ui.add_sized(ui.available_size(), widget);`
     ///
-    /// See also [`Self::add`] and [`Self::put`].
+    /// See also [`Self::add`], [`Self::place`] and [`Self::put`].
     ///
     /// ```
     /// # egui::__run_test_ui(|ui| {
@@ -1638,11 +1799,25 @@ impl Ui {
             .inner
     }
 
-    /// Add a [`Widget`] to this [`Ui`] at a specific location (manual layout).
+    /// Add a [`Widget`] to this [`Ui`] at a specific location (manual layout) without
+    /// affecting this [`Ui`]s cursor.
     ///
-    /// See also [`Self::add`] and [`Self::add_sized`].
+    /// See also [`Self::add`] and [`Self::add_sized`] and [`Self::put`].
+    pub fn place(&mut self, max_rect: Rect, widget: impl Widget) -> Response {
+        self.new_child(
+            UiBuilder::new()
+                .max_rect(max_rect)
+                .layout(Layout::centered_and_justified(Direction::TopDown)),
+        )
+        .add(widget)
+    }
+
+    /// Add a [`Widget`] to this [`Ui`] at a specific location (manual layout) and advance the
+    /// cursor after the widget.
+    ///
+    /// See also [`Self::add`], [`Self::add_sized`], and [`Self::place`].
     pub fn put(&mut self, max_rect: Rect, widget: impl Widget) -> Response {
-        self.allocate_new_ui(
+        self.scope_builder(
             UiBuilder::new()
                 .max_rect(max_rect)
                 .layout(Layout::centered_and_justified(Direction::TopDown)),
@@ -1775,6 +1950,7 @@ impl Ui {
     /// Add extra space before the next widget.
     ///
     /// The direction is dependent on the layout.
+    /// Note that `add_space` isn't supported when in a grid layout.
     ///
     /// This will be in addition to the [`crate::style::Spacing::item_spacing`]
     /// that is always added, but `item_spacing` won't be added _again_ by `add_space`.
@@ -1782,6 +1958,7 @@ impl Ui {
     /// [`Self::min_rect`] will expand to contain the space.
     #[inline]
     pub fn add_space(&mut self, amount: f32) {
+        debug_assert!(!self.is_grid(), "add_space makes no sense in a grid layout");
         self.placer.advance_cursor(amount.round_ui());
     }
 
@@ -1953,8 +2130,8 @@ impl Ui {
     /// ```
     #[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)
+    pub fn button<'a>(&mut self, atoms: impl IntoAtoms<'a>) -> Response {
+        Button::new(atoms).ui(self)
     }
 
     /// A button as small as normal body text.
@@ -1971,17 +2148,17 @@ impl Ui {
     ///
     /// 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)
+    pub fn checkbox<'a>(&mut self, checked: &'a mut bool, atoms: impl IntoAtoms<'a>) -> Response {
+        Checkbox::new(checked, atoms).ui(self)
     }
 
-    /// Acts like a checkbox, but looks like a [`SelectableLabel`].
+    /// Acts like a checkbox, but looks like a [`Button::selectable`].
     ///
     /// 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);
+    pub fn toggle_value<'a>(&mut self, selected: &mut bool, atoms: impl IntoAtoms<'a>) -> Response {
+        let mut response = self.selectable_label(*selected, atoms);
         if response.clicked() {
             *selected = !*selected;
             response.mark_changed();
@@ -1993,8 +2170,8 @@ impl Ui {
     /// 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)
+    pub fn radio<'a>(&mut self, selected: bool, atoms: impl IntoAtoms<'a>) -> Response {
+        RadioButton::new(selected, atoms).ui(self)
     }
 
     /// Show a [`RadioButton`]. It is selected if `*current_value == selected_value`.
@@ -2016,13 +2193,13 @@ impl Ui {
     /// }
     /// # });
     /// ```
-    pub fn radio_value<Value: PartialEq>(
+    pub fn radio_value<'a, Value: PartialEq>(
         &mut self,
         current_value: &mut Value,
         alternative: Value,
-        text: impl Into<WidgetText>,
+        atoms: impl IntoAtoms<'a>,
     ) -> Response {
-        let mut response = self.radio(*current_value == alternative, text);
+        let mut response = self.radio(*current_value == alternative, atoms);
         if response.clicked() && *current_value != alternative {
             *current_value = alternative;
             response.mark_changed();
@@ -2032,10 +2209,10 @@ impl Ui {
 
     /// Show a label which can be selected or not.
     ///
-    /// See also [`SelectableLabel`] and [`Self::toggle_value`].
+    /// See also [`Button::selectable`] 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)
+    pub fn selectable_label<'a>(&mut self, checked: bool, text: impl IntoAtoms<'a>) -> Response {
+        Button::selectable(checked, text).ui(self)
     }
 
     /// Show selectable text. It is selected if `*current_value == selected_value`.
@@ -2043,12 +2220,12 @@ impl Ui {
     ///
     /// Example: `ui.selectable_value(&mut my_enum, Enum::Alternative, "Alternative")`.
     ///
-    /// See also [`SelectableLabel`] and [`Self::toggle_value`].
-    pub fn selectable_value<Value: PartialEq>(
+    /// See also [`Button::selectable`] and [`Self::toggle_value`].
+    pub fn selectable_value<'a, Value: PartialEq>(
         &mut self,
         current_value: &mut Value,
         selected_value: Value,
-        text: impl Into<WidgetText>,
+        text: impl IntoAtoms<'a>,
     ) -> Response {
         let mut response = self.selectable_label(*current_value == selected_value, text);
         if response.clicked() && *current_value != selected_value {
@@ -2147,18 +2324,21 @@ impl Ui {
 /// # 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 {
@@ -2166,6 +2346,7 @@ impl Ui {
     }
 
     /// 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 {
@@ -2173,6 +2354,7 @@ impl Ui {
     }
 
     /// 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 {
@@ -2183,6 +2365,7 @@ impl Ui {
     }
 
     /// 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.
@@ -2195,6 +2378,7 @@ impl Ui {
     }
 
     /// 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 {
@@ -2214,6 +2398,7 @@ impl Ui {
     }
 
     /// 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.
@@ -2533,7 +2718,7 @@ impl Ui {
     /// 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.allocate_new_ui(
+        self.scope_builder(
             UiBuilder::new().layout(Layout::top_down(Align::Min)),
             add_contents,
         )
@@ -2555,7 +2740,7 @@ impl Ui {
         &mut self,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
-        self.allocate_new_ui(
+        self.scope_builder(
             UiBuilder::new().layout(Layout::top_down(Align::Center)),
             add_contents,
         )
@@ -2576,7 +2761,7 @@ impl Ui {
         &mut self,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
-        self.allocate_new_ui(
+        self.scope_builder(
             UiBuilder::new().layout(Layout::top_down(Align::Center).with_cross_justify(true)),
             add_contents,
         )
@@ -2602,7 +2787,7 @@ impl Ui {
         layout: Layout,
         add_contents: impl FnOnce(&mut Self) -> R,
     ) -> InnerResponse<R> {
-        self.allocate_new_ui(UiBuilder::new().layout(layout), add_contents)
+        self.scope_builder(UiBuilder::new().layout(layout), add_contents)
     }
 
     /// This will make the next added widget centered and justified in the available space.
@@ -2612,7 +2797,7 @@ impl Ui {
         &mut self,
         add_contents: impl FnOnce(&mut Self) -> R,
     ) -> InnerResponse<R> {
-        self.allocate_new_ui(
+        self.scope_builder(
             UiBuilder::new().layout(Layout::centered_and_justified(Direction::TopDown)),
             add_contents,
         )
@@ -2853,8 +3038,8 @@ impl Ui {
 
         if is_anything_being_dragged && !can_accept_what_is_being_dragged {
             // When dragging something else, show that it can't be dropped here:
-            fill = self.visuals().gray_out(fill);
-            stroke.color = self.visuals().gray_out(stroke.color);
+            fill = self.visuals().disable(fill);
+            stroke.color = self.visuals().disable(stroke.color);
         }
 
         frame.frame.fill = fill;
@@ -2900,14 +3085,16 @@ impl Ui {
     /// 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;
+    #[deprecated = "Use `ui.close()` or `ui.close_kind(UiKind::Menu)` instead"]
+    pub fn close_menu(&self) {
+        self.close_kind(UiKind::Menu);
     }
 
-    pub(crate) fn set_menu_state(&mut self, menu_state: Option<Arc<RwLock<MenuState>>>) {
+    #[expect(deprecated)]
+    pub(crate) fn set_menu_state(
+        &mut self,
+        menu_state: Option<Arc<RwLock<crate::menu::MenuState>>>,
+    ) {
         self.menu_state = menu_state;
     }
 
@@ -2921,24 +3108,25 @@ impl Ui {
     /// ui.menu_button("My menu", |ui| {
     ///     ui.menu_button("My sub-menu", |ui| {
     ///         if ui.button("Close the menu").clicked() {
-    ///             ui.close_menu();
+    ///             ui.close();
     ///         }
     ///     });
     /// });
     /// # });
     /// ```
     ///
-    /// See also: [`Self::close_menu`] and [`Response::context_menu`].
-    pub fn menu_button<R>(
+    /// See also: [`Self::close`] and [`Response::context_menu`].
+    pub fn menu_button<'a, R>(
         &mut self,
-        title: impl Into<WidgetText>,
+        atoms: impl IntoAtoms<'a>,
         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)
+        let (response, inner) = if menu::is_in_menu(self) {
+            menu::SubMenuButton::new(atoms).ui(self, add_contents)
         } else {
-            menu::menu_button(self, title, add_contents)
-        }
+            menu::MenuButton::new(atoms).ui(self, add_contents)
+        };
+        InnerResponse::new(inner.map(|i| i.inner), response)
     }
 
     /// Create a menu button with an image that when clicked will show the given menu.
@@ -2952,7 +3140,7 @@ impl Ui {
     /// ui.menu_image_button(title, img, |ui| {
     ///     ui.menu_button("My sub-menu", |ui| {
     ///         if ui.button("Close the menu").clicked() {
-    ///             ui.close_menu();
+    ///             ui.close();
     ///         }
     ///     });
     /// });
@@ -2960,18 +3148,22 @@ impl Ui {
     /// ```
     ///
     ///
-    /// See also: [`Self::close_menu`] and [`Response::context_menu`].
+    /// See also: [`Self::close`] and [`Response::context_menu`].
     #[inline]
     pub fn menu_image_button<'a, R>(
         &mut self,
         image: impl Into<Image<'a>>,
         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)
+        let (response, inner) = if menu::is_in_menu(self) {
+            menu::SubMenuButton::from_button(
+                Button::image(image).right_text(menu::SubMenuButton::RIGHT_ARROW),
+            )
+            .ui(self, add_contents)
         } else {
-            menu::menu_custom_button(self, Button::image(image), add_contents)
-        }
+            menu::MenuButton::from_button(Button::image(image)).ui(self, add_contents)
+        };
+        InnerResponse::new(inner.map(|i| i.inner), response)
     }
 
     /// Create a menu button with an image and a text that when clicked will show the given menu.
@@ -2986,14 +3178,14 @@ impl Ui {
     /// ui.menu_image_text_button(img, title, |ui| {
     ///     ui.menu_button("My sub-menu", |ui| {
     ///         if ui.button("Close the menu").clicked() {
-    ///             ui.close_menu();
+    ///             ui.close();
     ///         }
     ///     });
     /// });
     /// # });
     /// ```
     ///
-    /// See also: [`Self::close_menu`] and [`Response::context_menu`].
+    /// See also: [`Self::close`] and [`Response::context_menu`].
     #[inline]
     pub fn menu_image_text_button<'a, R>(
         &mut self,
@@ -3001,11 +3193,16 @@ impl Ui {
         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)
+        let (response, inner) = if menu::is_in_menu(self) {
+            menu::SubMenuButton::from_button(
+                Button::image_and_text(image, title).right_text(menu::SubMenuButton::RIGHT_ARROW),
+            )
+            .ui(self, add_contents)
         } else {
-            menu::menu_custom_button(self, Button::image_and_text(image, title), add_contents)
-        }
+            menu::MenuButton::from_button(Button::image_and_text(image, title))
+                .ui(self, add_contents)
+        };
+        InnerResponse::new(inner.map(|i| i.inner), response)
     }
 }
 
@@ -3034,7 +3231,7 @@ impl Drop for Ui {
 /// Show this rectangle to the user if certain debug options are set.
 #[cfg(debug_assertions)]
 fn register_rect(ui: &Ui, rect: Rect) {
-    use emath::{Align2, GuiRounding};
+    use emath::{Align2, GuiRounding as _};
 
     let debug = ui.style().debug;
 
diff --git a/crates/egui/src/ui_builder.rs b/crates/egui/src/ui_builder.rs
index d13748543..686fdcb47 100644
--- a/crates/egui/src/ui_builder.rs
+++ b/crates/egui/src/ui_builder.rs
@@ -1,9 +1,9 @@
 use std::{hash::Hash, sync::Arc};
 
-use crate::{Id, LayerId, Layout, Rect, Sense, Style, UiStackInfo};
-
-#[allow(unused_imports)] // Used for doclinks
+use crate::ClosableTag;
+#[expect(unused_imports)] // Used for doclinks
 use crate::Ui;
+use crate::{Id, LayerId, Layout, Rect, Sense, Style, UiStackInfo};
 
 /// Build a [`Ui`] as the child of another [`Ui`].
 ///
@@ -14,6 +14,7 @@ use crate::Ui;
 #[derive(Clone, Default)]
 pub struct UiBuilder {
     pub id_salt: Option<Id>,
+    pub global_scope: bool,
     pub ui_stack_info: UiStackInfo,
     pub layer_id: Option<LayerId>,
     pub max_rect: Option<Rect>,
@@ -23,6 +24,7 @@ pub struct UiBuilder {
     pub sizing_pass: bool,
     pub style: Option<Arc<Style>>,
     pub sense: Option<Sense>,
+    pub accessibility_parent: Option<Id>,
 }
 
 impl UiBuilder {
@@ -42,6 +44,34 @@ impl UiBuilder {
         self
     }
 
+    /// Set an id of the new `Ui` that is independent of the parent `Ui`.
+    /// This way child widgets can be moved in the ui tree without losing state.
+    /// You have to ensure that in a frame the child widgets do not get rendered in multiple places.
+    ///
+    /// You should set the same unique `id` at every place in the ui tree where you want the
+    /// child widgets to share state.
+    /// If the child widgets are not moved in the ui tree, use [`UiBuilder::id_salt`] instead.
+    ///
+    /// This is a shortcut for `.id_salt(my_id).global_scope(true)`.
+    #[inline]
+    pub fn id(mut self, id: impl Hash) -> Self {
+        self.id_salt = Some(Id::new(id));
+        self.global_scope = true;
+        self
+    }
+
+    /// Make the new `Ui` child ids independent of the parent `Ui`.
+    /// This way child widgets can be moved in the ui tree without losing state.
+    /// You have to ensure that in a frame the child widgets do not get rendered in multiple places.
+    ///
+    /// You should set the same globally unique `id_salt` at every place in the ui tree where you want the
+    /// child widgets to share state.
+    #[inline]
+    pub fn global_scope(mut self, global_scope: bool) -> Self {
+        self.global_scope = global_scope;
+        self
+    }
+
     /// Provide some information about the new `Ui` being built.
     #[inline]
     pub fn ui_stack_info(mut self, ui_stack_info: UiStackInfo) -> Self {
@@ -125,6 +155,7 @@ impl UiBuilder {
     }
 
     /// Set if you want sense clicks and/or drags. Default is [`Sense::hover`].
+    ///
     /// The sense will be registered below the Senses of any widgets contained in this [`Ui`], so
     /// if the user clicks a button contained within this [`Ui`], that button will receive the click
     /// instead.
@@ -135,4 +166,29 @@ impl UiBuilder {
         self.sense = Some(sense);
         self
     }
+
+    /// Make this [`Ui`] closable.
+    ///
+    /// Calling [`Ui::close`] in a child [`Ui`] will mark this [`Ui`] for closing.
+    /// After [`Ui::close`] was called, [`Ui::should_close`] and [`crate::Response::should_close`] will
+    /// return `true` (for this frame).
+    ///
+    /// This works by adding a [`ClosableTag`] to the [`UiStackInfo`].
+    #[inline]
+    pub fn closable(mut self) -> Self {
+        self.ui_stack_info
+            .tags
+            .insert(ClosableTag::NAME, Some(Arc::new(ClosableTag::default())));
+        self
+    }
+
+    /// Set the accessibility parent for this [`Ui`].
+    ///
+    /// This will override the automatic parent assignment for accessibility purposes.
+    /// If not set, the parent [`Ui`]'s ID will be used as the accessibility parent.
+    #[inline]
+    pub fn accessibility_parent(mut self, parent_id: Id) -> Self {
+        self.accessibility_parent = Some(parent_id);
+        self
+    }
 }
diff --git a/crates/egui/src/ui_stack.rs b/crates/egui/src/ui_stack.rs
index 099d79db4..0caf97f4f 100644
--- a/crates/egui/src/ui_stack.rs
+++ b/crates/egui/src/ui_stack.rs
@@ -53,6 +53,9 @@ pub enum UiKind {
 
     /// An [`crate::Area`] that is not of any other kind.
     GenericArea,
+
+    /// A collapsible container, e.g. a [`crate::CollapsingHeader`].
+    Collapsible,
 }
 
 impl UiKind {
@@ -81,6 +84,7 @@ impl UiKind {
             | Self::Frame
             | Self::ScrollArea
             | Self::Resize
+            | Self::Collapsible
             | Self::TableCell => false,
 
             Self::Window
@@ -254,7 +258,7 @@ impl UiStack {
 // these methods act on the entire stack
 impl UiStack {
     /// Return an iterator that walks the stack from this node to the root.
-    #[allow(clippy::iter_without_into_iter)]
+    #[expect(clippy::iter_without_into_iter)]
     pub fn iter(&self) -> UiStackIterator<'_> {
         UiStackIterator { next: Some(self) }
     }
diff --git a/crates/egui/src/util/id_type_map.rs b/crates/egui/src/util/id_type_map.rs
index a7b8f18c9..395d1b6ca 100644
--- a/crates/egui/src/util/id_type_map.rs
+++ b/crates/egui/src/util/id_type_map.rs
@@ -291,7 +291,6 @@ 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 = "log")]
             log::warn!(
                 "egui: Failed to deserialize {} from memory: {}, ron error: {:?}",
                 std::any::type_name::<T>(),
@@ -467,7 +466,7 @@ impl IdTypeMap {
 
     /// For tests
     #[cfg(feature = "persistence")]
-    #[allow(unused)]
+    #[allow(unused, clippy::allow_attributes)]
     fn get_generation<T: SerializableAny>(&self, id: Id) -> Option<usize> {
         let element = self.map.get(&hash(TypeId::of::<T>(), id))?;
         match element {
@@ -574,6 +573,8 @@ struct PersistedMap(Vec<(u64, SerializedElement)>);
 #[cfg(feature = "persistence")]
 impl PersistedMap {
     fn from_map(map: &IdTypeMap) -> Self {
+        #![expect(clippy::iter_over_hash_type)] // the serialized order doesn't matter
+
         profiling::function_scope!();
 
         use std::collections::BTreeMap;
diff --git a/crates/egui/src/viewport.rs b/crates/egui/src/viewport.rs
index d3f1c389d..3d757e477 100644
--- a/crates/egui/src/viewport.rs
+++ b/crates/egui/src/viewport.rs
@@ -42,7 +42,7 @@
 //! a [`ViewportCommand`] to it using [`Context::send_viewport_cmd`].
 //! You can interact with other viewports using [`Context::send_viewport_cmd_to`].
 //!
-//! There is an example in <https://github.com/emilk/egui/tree/master/examples/multiple_viewports/src/main.rs>.
+//! There is an example in <https://github.com/emilk/egui/tree/main/examples/multiple_viewports/src/main.rs>.
 //!
 //! You can find all available viewports in [`crate::RawInput::viewports`] and the active viewport in
 //! [`crate::InputState::viewport`]:
@@ -113,6 +113,20 @@ pub enum ViewportClass {
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct ViewportId(pub Id);
 
+// We implement `PartialOrd` and `Ord` so we can use `ViewportId` in a `BTreeMap`,
+// which allows predicatable iteration order, frame-to-frame.
+impl PartialOrd for ViewportId {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ViewportId {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.value().cmp(&other.0.value())
+    }
+}
+
 impl Default for ViewportId {
     #[inline]
     fn default() -> Self {
@@ -151,6 +165,9 @@ pub type ViewportIdSet = nohash_hasher::IntSet<ViewportId>;
 /// A fast hash map from [`ViewportId`] to `T`.
 pub type ViewportIdMap<T> = nohash_hasher::IntMap<ViewportId, T>;
 
+/// An order map from [`ViewportId`] to `T`.
+pub type OrderedViewportIdMap<T> = std::collections::BTreeMap<ViewportId, T>;
+
 // ----------------------------------------------------------------------------
 
 /// Image data for an application icon.
@@ -260,7 +277,6 @@ pub type ImmediateViewportRendererCallback = dyn for<'a> Fn(&Context, ImmediateV
 /// The default values are implementation defined, so you may want to explicitly
 /// configure the size of the window, and what buttons are shown.
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
-#[allow(clippy::option_option)]
 pub struct ViewportBuilder {
     /// The title of the viewport.
     /// `eframe` will use this as the title of the native window.
@@ -291,9 +307,11 @@ pub struct ViewportBuilder {
 
     // macOS:
     pub fullsize_content_view: Option<bool>,
+    pub movable_by_window_background: Option<bool>,
     pub title_shown: Option<bool>,
     pub titlebar_buttons_shown: Option<bool>,
     pub titlebar_shown: Option<bool>,
+    pub has_shadow: Option<bool>,
 
     // windows:
     pub drag_and_drop: Option<bool>,
@@ -380,6 +398,10 @@ impl ViewportBuilder {
     /// The default is `false`.
     /// If this is not working, it's because the graphic context doesn't support transparency,
     /// you will need to set the transparency in the eframe!
+    ///
+    /// ## Platform-specific
+    ///
+    /// **macOS:** When using this feature to create an overlay-like UI, you likely want to combine this with [`Self::with_has_shadow`] set to `false` in order to avoid ghosting artifacts.
     #[inline]
     pub fn with_transparent(mut self, transparent: bool) -> Self {
         self.transparent = Some(transparent);
@@ -432,6 +454,14 @@ impl ViewportBuilder {
         self
     }
 
+    /// macOS: Set to `true` to allow the window to be moved by dragging the background.
+    /// Enabling this feature can result in unexpected behavior with draggable UI widgets such as sliders.
+    #[inline]
+    pub fn with_movable_by_background(mut self, value: bool) -> Self {
+        self.movable_by_window_background = Some(value);
+        self
+    }
+
     /// macOS: Set to `false` to hide the window title.
     #[inline]
     pub fn with_title_shown(mut self, title_shown: bool) -> Self {
@@ -453,6 +483,19 @@ impl ViewportBuilder {
         self
     }
 
+    /// macOS: Set to `false` to make the window render without a drop shadow.
+    ///
+    /// The default is `true`.
+    ///
+    /// Disabling this feature can solve ghosting issues experienced if using [`Self::with_transparent`].
+    ///
+    /// Look at winit for more details
+    #[inline]
+    pub fn with_has_shadow(mut self, has_shadow: bool) -> Self {
+        self.has_shadow = Some(has_shadow);
+        self
+    }
+
     /// windows: Whether show or hide the window icon in the taskbar.
     #[inline]
     pub fn with_taskbar(mut self, show: bool) -> Self {
@@ -543,6 +586,15 @@ impl ViewportBuilder {
 
     /// The initial "outer" position of the window,
     /// i.e. where the top-left corner of the frame/chrome should be.
+    ///
+    /// **`eframe` notes**:
+    ///
+    /// - **iOS:** Sets the top left coordinates of the window in the screen space coordinate system.
+    /// - **Web:** Sets the top-left coordinates relative to the viewport. Doesn't account for CSS
+    ///   [`transform`].
+    /// - **Android / Wayland:** Unsupported.
+    ///
+    /// [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
     #[inline]
     pub fn with_position(mut self, pos: impl Into<Pos2>) -> Self {
         self.position = Some(pos.into());
@@ -578,6 +630,8 @@ impl ViewportBuilder {
     }
 
     /// Control if window is always-on-top, always-on-bottom, or neither.
+    ///
+    /// For platform compatibility see [`crate::viewport::WindowLevel`] documentation
     #[inline]
     pub fn with_window_level(mut self, level: WindowLevel) -> Self {
         self.window_level = Some(level);
@@ -585,6 +639,8 @@ impl ViewportBuilder {
     }
 
     /// This window is always on top
+    ///
+    /// For platform compatibility see [`crate::viewport::WindowLevel`] documentation
     #[inline]
     pub fn with_always_on_top(self) -> Self {
         self.with_window_level(WindowLevel::AlwaysOnTop)
@@ -613,6 +669,8 @@ impl ViewportBuilder {
     /// returning a list of commands and a bool indicating if the window needs to be recreated.
     #[must_use]
     pub fn patch(&mut self, new_vp_builder: Self) -> (Vec<ViewportCommand>, bool) {
+        #![expect(clippy::useless_let_if_seq)] // False positive
+
         let Self {
             title: new_title,
             app_id: new_app_id,
@@ -631,9 +689,11 @@ impl ViewportBuilder {
             visible: new_visible,
             drag_and_drop: new_drag_and_drop,
             fullsize_content_view: new_fullsize_content_view,
+            movable_by_window_background: new_movable_by_window_background,
             title_shown: new_title_shown,
             titlebar_buttons_shown: new_titlebar_buttons_shown,
             titlebar_shown: new_titlebar_shown,
+            has_shadow: new_has_shadow,
             close_button: new_close_button,
             minimize_button: new_minimize_button,
             maximize_button: new_maximize_button,
@@ -645,74 +705,74 @@ impl ViewportBuilder {
 
         let mut commands = Vec::new();
 
-        if let Some(new_title) = new_title {
-            if Some(&new_title) != self.title.as_ref() {
-                self.title = Some(new_title.clone());
-                commands.push(ViewportCommand::Title(new_title));
-            }
+        if let Some(new_title) = new_title
+            && Some(&new_title) != self.title.as_ref()
+        {
+            self.title = Some(new_title.clone());
+            commands.push(ViewportCommand::Title(new_title));
         }
 
-        if let Some(new_position) = new_position {
-            if Some(new_position) != self.position {
-                self.position = Some(new_position);
-                commands.push(ViewportCommand::OuterPosition(new_position));
-            }
+        if let Some(new_position) = new_position
+            && Some(new_position) != self.position
+        {
+            self.position = Some(new_position);
+            commands.push(ViewportCommand::OuterPosition(new_position));
         }
 
-        if let Some(new_inner_size) = new_inner_size {
-            if Some(new_inner_size) != self.inner_size {
-                self.inner_size = Some(new_inner_size);
-                commands.push(ViewportCommand::InnerSize(new_inner_size));
-            }
+        if let Some(new_inner_size) = new_inner_size
+            && Some(new_inner_size) != self.inner_size
+        {
+            self.inner_size = Some(new_inner_size);
+            commands.push(ViewportCommand::InnerSize(new_inner_size));
         }
 
-        if let Some(new_min_inner_size) = new_min_inner_size {
-            if Some(new_min_inner_size) != self.min_inner_size {
-                self.min_inner_size = Some(new_min_inner_size);
-                commands.push(ViewportCommand::MinInnerSize(new_min_inner_size));
-            }
+        if let Some(new_min_inner_size) = new_min_inner_size
+            && Some(new_min_inner_size) != self.min_inner_size
+        {
+            self.min_inner_size = Some(new_min_inner_size);
+            commands.push(ViewportCommand::MinInnerSize(new_min_inner_size));
         }
 
-        if let Some(new_max_inner_size) = new_max_inner_size {
-            if Some(new_max_inner_size) != self.max_inner_size {
-                self.max_inner_size = Some(new_max_inner_size);
-                commands.push(ViewportCommand::MaxInnerSize(new_max_inner_size));
-            }
+        if let Some(new_max_inner_size) = new_max_inner_size
+            && Some(new_max_inner_size) != self.max_inner_size
+        {
+            self.max_inner_size = Some(new_max_inner_size);
+            commands.push(ViewportCommand::MaxInnerSize(new_max_inner_size));
         }
 
-        if let Some(new_fullscreen) = new_fullscreen {
-            if Some(new_fullscreen) != self.fullscreen {
-                self.fullscreen = Some(new_fullscreen);
-                commands.push(ViewportCommand::Fullscreen(new_fullscreen));
-            }
+        if let Some(new_fullscreen) = new_fullscreen
+            && Some(new_fullscreen) != self.fullscreen
+        {
+            self.fullscreen = Some(new_fullscreen);
+            commands.push(ViewportCommand::Fullscreen(new_fullscreen));
         }
 
-        if let Some(new_maximized) = new_maximized {
-            if Some(new_maximized) != self.maximized {
-                self.maximized = Some(new_maximized);
-                commands.push(ViewportCommand::Maximized(new_maximized));
-            }
+        if let Some(new_maximized) = new_maximized
+            && Some(new_maximized) != self.maximized
+        {
+            self.maximized = Some(new_maximized);
+            commands.push(ViewportCommand::Maximized(new_maximized));
         }
 
-        if let Some(new_resizable) = new_resizable {
-            if Some(new_resizable) != self.resizable {
-                self.resizable = Some(new_resizable);
-                commands.push(ViewportCommand::Resizable(new_resizable));
-            }
+        if let Some(new_resizable) = new_resizable
+            && Some(new_resizable) != self.resizable
+        {
+            self.resizable = Some(new_resizable);
+            commands.push(ViewportCommand::Resizable(new_resizable));
         }
 
-        if let Some(new_transparent) = new_transparent {
-            if Some(new_transparent) != self.transparent {
-                self.transparent = Some(new_transparent);
-                commands.push(ViewportCommand::Transparent(new_transparent));
-            }
+        if let Some(new_transparent) = new_transparent
+            && Some(new_transparent) != self.transparent
+        {
+            self.transparent = Some(new_transparent);
+            commands.push(ViewportCommand::Transparent(new_transparent));
         }
 
-        if let Some(new_decorations) = new_decorations {
-            if Some(new_decorations) != self.decorations {
-                self.decorations = Some(new_decorations);
-                commands.push(ViewportCommand::Decorations(new_decorations));
-            }
+        if let Some(new_decorations) = new_decorations
+            && Some(new_decorations) != self.decorations
+        {
+            self.decorations = Some(new_decorations);
+            commands.push(ViewportCommand::Decorations(new_decorations));
         }
 
         if let Some(new_icon) = new_icon {
@@ -727,25 +787,25 @@ impl ViewportBuilder {
             }
         }
 
-        if let Some(new_visible) = new_visible {
-            if Some(new_visible) != self.visible {
-                self.visible = Some(new_visible);
-                commands.push(ViewportCommand::Visible(new_visible));
-            }
+        if let Some(new_visible) = new_visible
+            && Some(new_visible) != self.visible
+        {
+            self.visible = Some(new_visible);
+            commands.push(ViewportCommand::Visible(new_visible));
         }
 
-        if let Some(new_mouse_passthrough) = new_mouse_passthrough {
-            if Some(new_mouse_passthrough) != self.mouse_passthrough {
-                self.mouse_passthrough = Some(new_mouse_passthrough);
-                commands.push(ViewportCommand::MousePassthrough(new_mouse_passthrough));
-            }
+        if let Some(new_mouse_passthrough) = new_mouse_passthrough
+            && Some(new_mouse_passthrough) != self.mouse_passthrough
+        {
+            self.mouse_passthrough = Some(new_mouse_passthrough);
+            commands.push(ViewportCommand::MousePassthrough(new_mouse_passthrough));
         }
 
-        if let Some(new_window_level) = new_window_level {
-            if Some(new_window_level) != self.window_level {
-                self.window_level = Some(new_window_level);
-                commands.push(ViewportCommand::WindowLevel(new_window_level));
-            }
+        if let Some(new_window_level) = new_window_level
+            && Some(new_window_level) != self.window_level
+        {
+            self.window_level = Some(new_window_level);
+            commands.push(ViewportCommand::WindowLevel(new_window_level));
         }
 
         // --------------------------------------------------------------
@@ -804,6 +864,11 @@ impl ViewportBuilder {
             recreate_window = true;
         }
 
+        if new_has_shadow.is_some() && self.has_shadow != new_has_shadow {
+            self.has_shadow = new_has_shadow;
+            recreate_window = true;
+        }
+
         if new_taskbar.is_some() && self.taskbar != new_taskbar {
             self.taskbar = new_taskbar;
             recreate_window = true;
@@ -816,6 +881,13 @@ impl ViewportBuilder {
             recreate_window = true;
         }
 
+        if new_movable_by_window_background.is_some()
+            && self.movable_by_window_background != new_movable_by_window_background
+        {
+            self.movable_by_window_background = new_movable_by_window_background;
+            recreate_window = true;
+        }
+
         if new_drag_and_drop.is_some() && self.drag_and_drop != new_drag_and_drop {
             self.drag_and_drop = new_drag_and_drop;
             recreate_window = true;
@@ -830,6 +902,7 @@ impl ViewportBuilder {
     }
 }
 
+/// For winit platform compatibility, see [`winit::WindowLevel` documentation](https://docs.rs/winit/latest/winit/window/enum.WindowLevel.html#platform-specific)
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum WindowLevel {
@@ -1120,7 +1193,7 @@ pub struct ViewportOutput {
     /// since those don't result in real viewports.
     pub class: ViewportClass,
 
-    /// The window attrbiutes such as title, position, size, etc.
+    /// The window attributes such as title, position, size, etc.
     ///
     /// Use this when first constructing the native window.
     /// Also check for changes in it using [`ViewportBuilder::patch`],
diff --git a/crates/egui/src/widget_rect.rs b/crates/egui/src/widget_rect.rs
index 3725d62a7..fa99c95dc 100644
--- a/crates/egui/src/widget_rect.rs
+++ b/crates/egui/src/widget_rect.rs
@@ -129,6 +129,7 @@ impl WidgetRects {
             infos,
         } = self;
 
+        #[expect(clippy::iter_over_hash_type)]
         for rects in by_layer.values_mut() {
             rects.clear();
         }
diff --git a/crates/egui/src/widget_text.rs b/crates/egui/src/widget_text.rs
index 1132aa304..ef54d7969 100644
--- a/crates/egui/src/widget_text.rs
+++ b/crates/egui/src/widget_text.rs
@@ -1,10 +1,11 @@
+use emath::GuiRounding as _;
+use epaint::text::TextFormat;
+use std::fmt::Formatter;
 use std::{borrow::Cow, sync::Arc};
 
-use emath::GuiRounding as _;
-
 use crate::{
-    text::{LayoutJob, TextWrapping},
     Align, Color32, FontFamily, FontSelection, Galley, Style, TextStyle, TextWrapMode, Ui, Visuals,
+    text::{LayoutJob, TextWrapping},
 };
 
 /// Text and optional style choices for it.
@@ -22,7 +23,7 @@ use crate::{
 /// RichText::new("colored").color(Color32::RED);
 /// RichText::new("Large and underlined").size(20.0).underline();
 /// ```
-#[derive(Debug, Clone, Default, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct RichText {
     text: String,
     size: Option<f32>,
@@ -31,6 +32,7 @@ pub struct RichText {
     family: Option<FontFamily>,
     text_style: Option<TextStyle>,
     background_color: Color32,
+    expand_bg: f32,
     text_color: Option<Color32>,
     code: bool,
     strong: bool,
@@ -41,6 +43,29 @@ pub struct RichText {
     raised: bool,
 }
 
+impl Default for RichText {
+    fn default() -> Self {
+        Self {
+            text: Default::default(),
+            size: Default::default(),
+            extra_letter_spacing: Default::default(),
+            line_height: Default::default(),
+            family: Default::default(),
+            text_style: Default::default(),
+            background_color: Default::default(),
+            expand_bg: 1.0,
+            text_color: Default::default(),
+            code: Default::default(),
+            strong: Default::default(),
+            weak: Default::default(),
+            strikethrough: Default::default(),
+            underline: Default::default(),
+            italics: Default::default(),
+            raised: Default::default(),
+        }
+    }
+}
+
 impl From<&str> for RichText {
     #[inline]
     fn from(text: &str) -> Self {
@@ -282,7 +307,7 @@ impl RichText {
     /// Read the font height of the selected text style.
     ///
     /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    pub fn font_height(&self, fonts: &epaint::Fonts, style: &Style) -> f32 {
+    pub fn font_height(&self, fonts: &mut epaint::FontsView<'_>, 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),
@@ -364,6 +389,7 @@ impl RichText {
             family,
             text_style,
             background_color,
+            expand_bg,
             text_color: _, // already used by `get_text_color`
             code,
             strong: _, // already used by `get_text_color`
@@ -378,15 +404,11 @@ impl RichText {
         let text_color = text_color.unwrap_or(crate::Color32::PLACEHOLDER);
 
         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(fid) = style.override_font_id.clone() {
-                font_id = fid;
-            }
+            let mut font_id = style.override_font_id.clone().unwrap_or_else(|| {
+                (text_style.as_ref().or(style.override_text_style.as_ref()))
+                    .map(|text_style| text_style.resolve(style))
+                    .unwrap_or_else(|| fallback_font.resolve(style))
+            });
             if let Some(size) = size {
                 font_id.size = size;
             }
@@ -396,10 +418,12 @@ impl RichText {
             font_id
         };
 
-        let mut background_color = background_color;
-        if code {
-            background_color = style.visuals.code_bg_color;
-        }
+        let background_color = if code {
+            style.visuals.code_bg_color
+        } else {
+            background_color
+        };
+
         let underline = if underline {
             crate::Stroke::new(1.0, line_color)
         } else {
@@ -429,6 +453,7 @@ impl RichText {
                 underline,
                 strikethrough,
                 valign,
+                expand_bg,
             },
         )
     }
@@ -462,7 +487,16 @@ impl RichText {
 /// which will be replaced with a color chosen by the widget that paints the text.
 #[derive(Clone)]
 pub enum WidgetText {
-    RichText(RichText),
+    /// Plain unstyled text.
+    ///
+    /// We have this as a special case, as it is the common-case,
+    /// and it uses less memory than [`Self::RichText`].
+    Text(String),
+
+    /// Text and optional style choices for it.
+    ///
+    /// Prefer [`Self::Text`] if there is no styling, as it will be faster.
+    RichText(Arc<RichText>),
 
     /// Use this [`LayoutJob`] when laying out the text.
     ///
@@ -476,7 +510,7 @@ pub enum WidgetText {
     ///
     /// You can color the text however you want, or use [`Color32::PLACEHOLDER`]
     /// which will be replaced with a color chosen by the widget that paints the text.
-    LayoutJob(LayoutJob),
+    LayoutJob(Arc<LayoutJob>),
 
     /// Use exactly this galley when painting the text.
     ///
@@ -485,9 +519,21 @@ pub enum WidgetText {
     Galley(Arc<Galley>),
 }
 
+impl std::fmt::Debug for WidgetText {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let text = self.text();
+        match self {
+            Self::Text(_) => write!(f, "Text({text:?})"),
+            Self::RichText(_) => write!(f, "RichText({text:?})"),
+            Self::LayoutJob(_) => write!(f, "LayoutJob({text:?})"),
+            Self::Galley(_) => write!(f, "Galley({text:?})"),
+        }
+    }
+}
+
 impl Default for WidgetText {
     fn default() -> Self {
-        Self::RichText(RichText::default())
+        Self::Text(String::new())
     }
 }
 
@@ -495,6 +541,7 @@ impl WidgetText {
     #[inline]
     pub fn is_empty(&self) -> bool {
         match self {
+            Self::Text(text) => text.is_empty(),
             Self::RichText(text) => text.is_empty(),
             Self::LayoutJob(job) => job.is_empty(),
             Self::Galley(galley) => galley.is_empty(),
@@ -504,21 +551,36 @@ impl WidgetText {
     #[inline]
     pub fn text(&self) -> &str {
         match self {
+            Self::Text(text) => text,
             Self::RichText(text) => text.text(),
             Self::LayoutJob(job) => &job.text,
             Self::Galley(galley) => galley.text(),
         }
     }
 
+    /// Map the contents based on the provided closure.
+    ///
+    /// - [`Self::Text`] => convert to [`RichText`] and call f
+    /// - [`Self::RichText`] => call f
+    /// - else do nothing
+    #[must_use]
+    fn map_rich_text<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RichText) -> RichText,
+    {
+        match self {
+            Self::Text(text) => Self::RichText(Arc::new(f(RichText::new(text)))),
+            Self::RichText(text) => Self::RichText(Arc::new(f(Arc::unwrap_or_clone(text)))),
+            other => other,
+        }
+    }
+
     /// 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,
-        }
+        self.map_rich_text(|text| text.text_style(text_style))
     }
 
     /// Set the [`TextStyle`] unless it has already been set
@@ -526,10 +588,7 @@ impl WidgetText {
     /// 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,
-        }
+        self.map_rich_text(|text| text.fallback_text_style(text_style))
     }
 
     /// Override text color if, and only if, this is a [`RichText`].
@@ -537,116 +596,90 @@ impl WidgetText {
     /// 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,
-        }
+        self.map_rich_text(|text| text.color(color))
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn heading(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.heading()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.heading())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn monospace(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.monospace()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.monospace())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn code(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.code()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.code())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn strong(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.strong()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.strong())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn weak(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.weak()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.weak())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn underline(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.underline()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.underline())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn strikethrough(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.strikethrough()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.strikethrough())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn italics(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.italics()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.italics())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn small(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.small()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.small())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn small_raised(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.small_raised()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.small_raised())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     pub fn raised(self) -> Self {
-        match self {
-            Self::RichText(text) => Self::RichText(text.raised()),
-            Self::LayoutJob(_) | Self::Galley(_) => self,
-        }
+        self.map_rich_text(|text| text.raised())
     }
 
     /// Prefer using [`RichText`] directly!
+    #[inline]
     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,
-        }
+        self.map_rich_text(|text| text.background_color(background_color))
     }
 
     /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    pub(crate) fn font_height(&self, fonts: &epaint::Fonts, style: &Style) -> f32 {
+    pub(crate) fn font_height(&self, fonts: &mut epaint::FontsView<'_>, style: &Style) -> f32 {
         match self {
+            Self::Text(_) => fonts.row_height(&FontSelection::Default.resolve(style)),
             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().round_ui()
+                if let Some(placed_row) = galley.rows.first() {
+                    placed_row.height().round_ui()
                 } else {
                     galley.size().y.round_ui()
                 }
@@ -659,11 +692,24 @@ impl WidgetText {
         style: &Style,
         fallback_font: FontSelection,
         default_valign: Align,
-    ) -> LayoutJob {
+    ) -> Arc<LayoutJob> {
         match self {
-            Self::RichText(text) => text.into_layout_job(style, fallback_font, default_valign),
+            Self::Text(text) => Arc::new(LayoutJob::simple_format(
+                text,
+                TextFormat {
+                    font_id: FontSelection::Default.resolve(style),
+                    color: crate::Color32::PLACEHOLDER,
+                    valign: default_valign,
+                    ..Default::default()
+                },
+            )),
+            Self::RichText(text) => Arc::new(Arc::unwrap_or_clone(text).into_layout_job(
+                style,
+                fallback_font,
+                default_valign,
+            )),
             Self::LayoutJob(job) => job,
-            Self::Galley(galley) => (*galley.job).clone(),
+            Self::Galley(galley) => galley.job.clone(),
         }
     }
 
@@ -695,14 +741,38 @@ impl WidgetText {
         default_valign: Align,
     ) -> Arc<Galley> {
         match self {
-            Self::RichText(text) => {
-                let mut layout_job = text.into_layout_job(style, fallback_font, default_valign);
+            Self::Text(text) => {
+                let color = style
+                    .visuals
+                    .override_text_color
+                    .unwrap_or(crate::Color32::PLACEHOLDER);
+                let mut layout_job = LayoutJob::simple_format(
+                    text,
+                    TextFormat {
+                        // We want the style overrides to take precedence over the fallback font
+                        font_id: FontSelection::default()
+                            .resolve_with_fallback(style, fallback_font),
+                        color,
+                        valign: default_valign,
+                        ..Default::default()
+                    },
+                );
                 layout_job.wrap = text_wrapping;
-                ctx.fonts(|f| f.layout_job(layout_job))
+                ctx.fonts_mut(|f| f.layout_job(layout_job))
             }
-            Self::LayoutJob(mut job) => {
+            Self::RichText(text) => {
+                let mut layout_job = Arc::unwrap_or_clone(text).into_layout_job(
+                    style,
+                    fallback_font,
+                    default_valign,
+                );
+                layout_job.wrap = text_wrapping;
+                ctx.fonts_mut(|f| f.layout_job(layout_job))
+            }
+            Self::LayoutJob(job) => {
+                let mut job = Arc::unwrap_or_clone(job);
                 job.wrap = text_wrapping;
-                ctx.fonts(|f| f.layout_job(job))
+                ctx.fonts_mut(|f| f.layout_job(job))
             }
             Self::Galley(galley) => galley,
         }
@@ -712,48 +782,55 @@ impl WidgetText {
 impl From<&str> for WidgetText {
     #[inline]
     fn from(text: &str) -> Self {
-        Self::RichText(RichText::new(text))
+        Self::Text(text.to_owned())
     }
 }
 
 impl From<&String> for WidgetText {
     #[inline]
     fn from(text: &String) -> Self {
-        Self::RichText(RichText::new(text))
+        Self::Text(text.clone())
     }
 }
 
 impl From<String> for WidgetText {
     #[inline]
     fn from(text: String) -> Self {
-        Self::RichText(RichText::new(text))
+        Self::Text(text)
     }
 }
 
 impl From<&Box<str>> for WidgetText {
     #[inline]
     fn from(text: &Box<str>) -> Self {
-        Self::RichText(RichText::new(text.clone()))
+        Self::Text(text.to_string())
     }
 }
 
 impl From<Box<str>> for WidgetText {
     #[inline]
     fn from(text: Box<str>) -> Self {
-        Self::RichText(RichText::new(text))
+        Self::Text(text.into())
     }
 }
 
 impl From<Cow<'_, str>> for WidgetText {
     #[inline]
     fn from(text: Cow<'_, str>) -> Self {
-        Self::RichText(RichText::new(text))
+        Self::Text(text.into_owned())
     }
 }
 
 impl From<RichText> for WidgetText {
     #[inline]
     fn from(rich_text: RichText) -> Self {
+        Self::RichText(Arc::new(rich_text))
+    }
+}
+
+impl From<Arc<RichText>> for WidgetText {
+    #[inline]
+    fn from(rich_text: Arc<RichText>) -> Self {
         Self::RichText(rich_text)
     }
 }
@@ -761,6 +838,13 @@ impl From<RichText> for WidgetText {
 impl From<LayoutJob> for WidgetText {
     #[inline]
     fn from(layout_job: LayoutJob) -> Self {
+        Self::LayoutJob(Arc::new(layout_job))
+    }
+}
+
+impl From<Arc<LayoutJob>> for WidgetText {
+    #[inline]
+    fn from(layout_job: Arc<LayoutJob>) -> Self {
         Self::LayoutJob(layout_job)
     }
 }
@@ -771,3 +855,13 @@ impl From<Arc<Galley>> for WidgetText {
         Self::Galley(galley)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::WidgetText;
+
+    #[test]
+    fn ensure_small_widget_text() {
+        assert_eq!(size_of::<WidgetText>(), size_of::<String>());
+    }
+}
diff --git a/crates/egui/src/widgets/button.rs b/crates/egui/src/widgets/button.rs
index 578aedcd6..ccb1db69f 100644
--- a/crates/egui/src/widgets/button.rs
+++ b/crates/egui/src/widgets/button.rs
@@ -1,6 +1,7 @@
 use crate::{
-    widgets, Align, Color32, CornerRadius, Image, NumExt, Rect, Response, Sense, Stroke, TextStyle,
-    TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, WidgetType,
+    Atom, AtomExt as _, AtomKind, AtomLayout, AtomLayoutResponse, Color32, CornerRadius, Frame,
+    Image, IntoAtoms, NumExt as _, Response, Sense, Stroke, TextStyle, TextWrapMode, Ui, Vec2,
+    Widget, WidgetInfo, WidgetText, WidgetType,
 };
 
 /// Clickable button with text.
@@ -23,58 +24,91 @@ use crate::{
 /// ```
 #[must_use = "You should put this widget in a ui with `ui.add(widget);`"]
 pub struct Button<'a> {
-    image: Option<Image<'a>>,
-    text: Option<WidgetText>,
-    shortcut_text: WidgetText,
-    wrap_mode: Option<TextWrapMode>,
-
-    /// None means default for interact
+    layout: AtomLayout<'a>,
     fill: Option<Color32>,
     stroke: Option<Stroke>,
-    sense: Sense,
     small: bool,
     frame: Option<bool>,
+    frame_when_inactive: bool,
     min_size: Vec2,
     corner_radius: Option<CornerRadius>,
     selected: bool,
     image_tint_follows_text_color: bool,
+    limit_image_size: bool,
 }
 
 impl<'a> Button<'a> {
-    pub fn new(text: impl Into<WidgetText>) -> Self {
-        Self::opt_image_and_text(None, Some(text.into()))
-    }
-
-    /// Creates a button with an image. The size of the image as displayed is defined by the provided size.
-    #[allow(clippy::needless_pass_by_value)]
-    pub fn image(image: impl Into<Image<'a>>) -> Self {
-        Self::opt_image_and_text(Some(image.into()), 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(image: impl Into<Image<'a>>, text: impl Into<WidgetText>) -> Self {
-        Self::opt_image_and_text(Some(image.into()), Some(text.into()))
-    }
-
-    pub fn opt_image_and_text(image: Option<Image<'a>>, text: Option<WidgetText>) -> Self {
+    pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
         Self {
-            text,
-            image,
-            shortcut_text: Default::default(),
-            wrap_mode: None,
+            layout: AtomLayout::new(atoms.into_atoms())
+                .sense(Sense::click())
+                .fallback_font(TextStyle::Button),
             fill: None,
             stroke: None,
-            sense: Sense::click(),
             small: false,
             frame: None,
+            frame_when_inactive: true,
             min_size: Vec2::ZERO,
             corner_radius: None,
             selected: false,
             image_tint_follows_text_color: false,
+            limit_image_size: false,
         }
     }
 
+    /// Show a selectable button.
+    ///
+    /// Equivalent to:
+    /// ```rust
+    /// # use egui::{Button, IntoAtoms, __run_test_ui};
+    /// # __run_test_ui(|ui| {
+    /// let selected = true;
+    /// ui.add(Button::new("toggle me").selected(selected).frame_when_inactive(!selected).frame(true));
+    /// # });
+    /// ```
+    ///
+    /// See also:
+    ///   - [`Ui::selectable_value`]
+    ///   - [`Ui::selectable_label`]
+    pub fn selectable(selected: bool, atoms: impl IntoAtoms<'a>) -> Self {
+        Self::new(atoms)
+            .selected(selected)
+            .frame_when_inactive(selected)
+            .frame(true)
+    }
+
+    /// Creates a button with an image. The size of the image as displayed is defined by the provided size.
+    ///
+    /// Note: In contrast to [`Button::new`], this limits the image size to the default font height
+    /// (using [`crate::AtomExt::atom_max_height_font_size`]).
+    pub fn image(image: impl Into<Image<'a>>) -> Self {
+        Self::opt_image_and_text(Some(image.into()), None)
+    }
+
+    /// Creates a button with an image to the left of the text.
+    ///
+    /// Note: In contrast to [`Button::new`], this limits the image size to the default font height
+    /// (using [`crate::AtomExt::atom_max_height_font_size`]).
+    pub fn image_and_text(image: impl Into<Image<'a>>, text: impl Into<WidgetText>) -> Self {
+        Self::opt_image_and_text(Some(image.into()), Some(text.into()))
+    }
+
+    /// Create a button with an optional image and optional text.
+    ///
+    /// Note: In contrast to [`Button::new`], this limits the image size to the default font height
+    /// (using [`crate::AtomExt::atom_max_height_font_size`]).
+    pub fn opt_image_and_text(image: Option<Image<'a>>, text: Option<WidgetText>) -> Self {
+        let mut button = Self::new(());
+        if let Some(image) = image {
+            button.layout.push_right(image);
+        }
+        if let Some(text) = text {
+            button.layout.push_right(text);
+        }
+        button.limit_image_size = true;
+        button
+    }
+
     /// Set the wrap mode for the text.
     ///
     /// By default, [`crate::Ui::wrap_mode`] will be used, which can be overridden with [`crate::Style::wrap_mode`].
@@ -82,23 +116,20 @@ impl<'a> Button<'a> {
     /// Note that any `\n` in the text will always produce a new line.
     #[inline]
     pub fn wrap_mode(mut self, wrap_mode: TextWrapMode) -> Self {
-        self.wrap_mode = Some(wrap_mode);
+        self.layout = self.layout.wrap_mode(wrap_mode);
         self
     }
 
     /// Set [`Self::wrap_mode`] to [`TextWrapMode::Wrap`].
     #[inline]
-    pub fn wrap(mut self) -> Self {
-        self.wrap_mode = Some(TextWrapMode::Wrap);
-
-        self
+    pub fn wrap(self) -> Self {
+        self.wrap_mode(TextWrapMode::Wrap)
     }
 
     /// Set [`Self::wrap_mode`] to [`TextWrapMode::Truncate`].
     #[inline]
-    pub fn truncate(mut self) -> Self {
-        self.wrap_mode = Some(TextWrapMode::Truncate);
-        self
+    pub fn truncate(self) -> Self {
+        self.wrap_mode(TextWrapMode::Truncate)
     }
 
     /// Override background fill color. Note that this will override any on-hover effects.
@@ -106,7 +137,6 @@ impl<'a> Button<'a> {
     #[inline]
     pub fn fill(mut self, fill: impl Into<Color32>) -> Self {
         self.fill = Some(fill.into());
-        self.frame = Some(true);
         self
     }
 
@@ -122,9 +152,6 @@ impl<'a> Button<'a> {
     /// Make this a small button, suitable for embedding into text.
     #[inline]
     pub fn small(mut self) -> Self {
-        if let Some(text) = self.text {
-            self.text = Some(text.text_style(TextStyle::Body));
-        }
         self.small = true;
         self
     }
@@ -136,11 +163,23 @@ impl<'a> Button<'a> {
         self
     }
 
+    /// If `false`, the button will not have a frame when inactive.
+    ///
+    /// Default: `true`.
+    ///
+    /// Note: When [`Self::frame`] (or `ui.visuals().button_frame`) is `false`, this setting
+    /// has no effect.
+    #[inline]
+    pub fn frame_when_inactive(mut self, frame_when_inactive: bool) -> Self {
+        self.frame_when_inactive = frame_when_inactive;
+        self
+    }
+
     /// By default, buttons senses clicks.
     /// Change this to a drag-button with `Sense::drag()`.
     #[inline]
     pub fn sense(mut self, sense: Sense) -> Self {
-        self.sense = sense;
+        self.layout = self.layout.sense(sense);
         self
     }
 
@@ -181,9 +220,32 @@ impl<'a> Button<'a> {
     /// Designed for menu buttons, for setting a keyboard shortcut text (e.g. `Ctrl+S`).
     ///
     /// The text can be created with [`crate::Context::format_shortcut`].
+    ///
+    /// See also [`Self::right_text`].
     #[inline]
-    pub fn shortcut_text(mut self, shortcut_text: impl Into<WidgetText>) -> Self {
-        self.shortcut_text = shortcut_text.into();
+    pub fn shortcut_text(mut self, shortcut_text: impl IntoAtoms<'a>) -> Self {
+        self.layout.push_right(Atom::grow());
+
+        for mut atom in shortcut_text.into_atoms() {
+            atom.kind = match atom.kind {
+                AtomKind::Text(text) => AtomKind::Text(text.weak()),
+                other => other,
+            };
+            self.layout.push_right(atom);
+        }
+
+        self
+    }
+
+    /// Show some text on the right side of the button.
+    #[inline]
+    pub fn right_text(mut self, right_text: impl IntoAtoms<'a>) -> Self {
+        self.layout.push_right(Atom::grow());
+
+        for atom in right_text.into_atoms() {
+            self.layout.push_right(atom);
+        }
+
         self
     }
 
@@ -193,29 +255,42 @@ impl<'a> Button<'a> {
         self.selected = selected;
         self
     }
-}
 
-impl Widget for Button<'_> {
-    fn ui(self, ui: &mut Ui) -> Response {
+    /// Show the button and return a [`AtomLayoutResponse`] for painting custom contents.
+    pub fn atom_ui(self, ui: &mut Ui) -> AtomLayoutResponse {
         let Button {
-            text,
-            image,
-            shortcut_text,
-            wrap_mode,
+            mut layout,
             fill,
             stroke,
-            sense,
             small,
             frame,
-            min_size,
+            frame_when_inactive,
+            mut min_size,
             corner_radius,
             selected,
             image_tint_follows_text_color,
+            limit_image_size,
         } = self;
 
-        let frame = frame.unwrap_or_else(|| ui.visuals().button_frame);
+        if !small {
+            min_size.y = min_size.y.at_least(ui.spacing().interact_size.y);
+        }
 
-        let mut button_padding = if frame {
+        if limit_image_size {
+            layout.map_atoms(|atom| {
+                if matches!(&atom.kind, AtomKind::Image(_)) {
+                    atom.atom_max_height_font_size(ui)
+                } else {
+                    atom
+                }
+            });
+        }
+
+        let text = layout.text().map(String::from);
+
+        let has_frame_margin = frame.unwrap_or_else(|| ui.visuals().button_frame);
+
+        let mut button_padding = if has_frame_margin {
             ui.spacing().button_padding
         } else {
             Vec2::ZERO
@@ -224,181 +299,62 @@ impl Widget for Button<'_> {
             button_padding.y = 0.0;
         }
 
-        let space_available_for_image = if let Some(text) = &text {
-            let font_height = ui.fonts(|fonts| text.font_height(fonts, ui.style()));
-            Vec2::splat(font_height) // Reasonable?
+        let mut prepared = layout
+            .frame(Frame::new().inner_margin(button_padding))
+            .min_size(min_size)
+            .allocate(ui);
+
+        let response = if ui.is_rect_visible(prepared.response.rect) {
+            let visuals = ui.style().interact_selectable(&prepared.response, selected);
+
+            let visible_frame = if frame_when_inactive {
+                has_frame_margin
+            } else {
+                has_frame_margin
+                    && (prepared.response.hovered()
+                        || prepared.response.is_pointer_button_down_on()
+                        || prepared.response.has_focus())
+            };
+
+            if image_tint_follows_text_color {
+                prepared.map_images(|image| image.tint(visuals.text_color()));
+            }
+
+            prepared.fallback_text_color = visuals.text_color();
+
+            if visible_frame {
+                let stroke = stroke.unwrap_or(visuals.bg_stroke);
+                let fill = fill.unwrap_or(visuals.weak_bg_fill);
+                prepared.frame = prepared
+                    .frame
+                    .inner_margin(
+                        button_padding + Vec2::splat(visuals.expansion) - Vec2::splat(stroke.width),
+                    )
+                    .outer_margin(-Vec2::splat(visuals.expansion))
+                    .fill(fill)
+                    .stroke(stroke)
+                    .corner_radius(corner_radius.unwrap_or(visuals.corner_radius));
+            }
+
+            prepared.paint(ui)
         } else {
-            ui.available_size() - 2.0 * button_padding
+            AtomLayoutResponse::empty(prepared.response)
         };
 
-        let image_size = if let Some(image) = &image {
-            image
-                .load_and_calc_size(ui, space_available_for_image)
-                .unwrap_or(space_available_for_image)
-        } else {
-            Vec2::ZERO
-        };
-
-        let gap_before_shortcut_text = ui.spacing().item_spacing.x;
-
-        let mut text_wrap_width = ui.available_width() - 2.0 * button_padding.x;
-        if image.is_some() {
-            text_wrap_width -= image_size.x + ui.spacing().icon_spacing;
-        }
-
-        // Note: we don't wrap the shortcut text
-        let shortcut_galley = (!shortcut_text.is_empty()).then(|| {
-            shortcut_text.into_galley(
-                ui,
-                Some(TextWrapMode::Extend),
-                f32::INFINITY,
-                TextStyle::Button,
-            )
-        });
-
-        if let Some(shortcut_galley) = &shortcut_galley {
-            // Leave space for the shortcut text:
-            text_wrap_width -= gap_before_shortcut_text + shortcut_galley.size().x;
-        }
-
-        let galley =
-            text.map(|text| text.into_galley(ui, wrap_mode, text_wrap_width, TextStyle::Button));
-
-        let mut desired_size = Vec2::ZERO;
-        if image.is_some() {
-            desired_size.x += image_size.x;
-            desired_size.y = desired_size.y.max(image_size.y);
-        }
-        if image.is_some() && galley.is_some() {
-            desired_size.x += ui.spacing().icon_spacing;
-        }
-        if let Some(galley) = &galley {
-            desired_size.x += galley.size().x;
-            desired_size.y = desired_size.y.max(galley.size().y);
-        }
-        if let Some(shortcut_galley) = &shortcut_galley {
-            desired_size.x += gap_before_shortcut_text + shortcut_galley.size().x;
-            desired_size.y = desired_size.y.max(shortcut_galley.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, mut response) = ui.allocate_at_least(desired_size, sense);
-        response.widget_info(|| {
-            if let Some(galley) = &galley {
-                WidgetInfo::labeled(WidgetType::Button, ui.is_enabled(), galley.text())
+        response.response.widget_info(|| {
+            if let Some(text) = &text {
+                WidgetInfo::labeled(WidgetType::Button, ui.is_enabled(), text)
             } else {
                 WidgetInfo::new(WidgetType::Button)
             }
         });
 
-        if ui.is_rect_visible(rect) {
-            let visuals = ui.style().interact(&response);
-
-            let (frame_expansion, frame_cr, frame_fill, frame_stroke) = if selected {
-                let selection = ui.visuals().selection;
-                (
-                    Vec2::ZERO,
-                    CornerRadius::ZERO,
-                    selection.bg_fill,
-                    selection.stroke,
-                )
-            } else if frame {
-                let expansion = Vec2::splat(visuals.expansion);
-                (
-                    expansion,
-                    visuals.corner_radius,
-                    visuals.weak_bg_fill,
-                    visuals.bg_stroke,
-                )
-            } else {
-                Default::default()
-            };
-            let frame_cr = corner_radius.unwrap_or(frame_cr);
-            let frame_fill = fill.unwrap_or(frame_fill);
-            let frame_stroke = stroke.unwrap_or(frame_stroke);
-            ui.painter().rect(
-                rect.expand2(frame_expansion),
-                frame_cr,
-                frame_fill,
-                frame_stroke,
-                epaint::StrokeKind::Inside,
-            );
-
-            let mut cursor_x = rect.min.x + button_padding.x;
-
-            if let Some(image) = &image {
-                let mut image_pos = ui
-                    .layout()
-                    .align_size_within_rect(image_size, rect.shrink2(button_padding))
-                    .min;
-                if galley.is_some() || shortcut_galley.is_some() {
-                    image_pos.x = cursor_x;
-                }
-                let image_rect = Rect::from_min_size(image_pos, image_size);
-                cursor_x += image_size.x;
-                let tlr = image.load_for_size(ui.ctx(), image_size);
-                let mut image_options = image.image_options().clone();
-                if image_tint_follows_text_color {
-                    image_options.tint = image_options.tint * visuals.text_color();
-                }
-                widgets::image::paint_texture_load_result(
-                    ui,
-                    &tlr,
-                    image_rect,
-                    image.show_loading_spinner,
-                    &image_options,
-                    None,
-                );
-                response = widgets::image::texture_load_result_response(
-                    &image.source(ui.ctx()),
-                    &tlr,
-                    response,
-                );
-            }
-
-            if image.is_some() && galley.is_some() {
-                cursor_x += ui.spacing().icon_spacing;
-            }
-
-            if let Some(galley) = galley {
-                let mut text_pos = ui
-                    .layout()
-                    .align_size_within_rect(galley.size(), rect.shrink2(button_padding))
-                    .min;
-                if image.is_some() || shortcut_galley.is_some() {
-                    text_pos.x = cursor_x;
-                }
-                ui.painter().galley(text_pos, galley, visuals.text_color());
-            }
-
-            if let Some(shortcut_galley) = shortcut_galley {
-                // Always align to the right
-                let layout = if ui.layout().is_horizontal() {
-                    ui.layout().with_main_align(Align::Max)
-                } else {
-                    ui.layout().with_cross_align(Align::Max)
-                };
-                let shortcut_text_pos = layout
-                    .align_size_within_rect(shortcut_galley.size(), rect.shrink2(button_padding))
-                    .min;
-                ui.painter().galley(
-                    shortcut_text_pos,
-                    shortcut_galley,
-                    ui.visuals().weak_text_color(),
-                );
-            }
-        }
-
-        if let Some(cursor) = ui.visuals().interact_cursor {
-            if response.hovered() {
-                ui.ctx().set_cursor_icon(cursor);
-            }
-        }
-
         response
     }
 }
+
+impl Widget for Button<'_> {
+    fn ui(self, ui: &mut Ui) -> Response {
+        self.atom_ui(ui).response
+    }
+}
diff --git a/crates/egui/src/widgets/checkbox.rs b/crates/egui/src/widgets/checkbox.rs
index 7bdb6c86f..c90cca292 100644
--- a/crates/egui/src/widgets/checkbox.rs
+++ b/crates/egui/src/widgets/checkbox.rs
@@ -1,6 +1,6 @@
 use crate::{
-    epaint, pos2, vec2, NumExt, Response, Sense, Shape, TextStyle, Ui, Vec2, Widget, WidgetInfo,
-    WidgetText, WidgetType,
+    Atom, AtomLayout, Atoms, Id, IntoAtoms, NumExt as _, Response, Sense, Shape, Ui, Vec2, Widget,
+    WidgetInfo, WidgetType, epaint, pos2,
 };
 
 // TODO(emilk): allow checkbox without a text label
@@ -19,21 +19,21 @@ use crate::{
 #[must_use = "You should put this widget in a ui with `ui.add(widget);`"]
 pub struct Checkbox<'a> {
     checked: &'a mut bool,
-    text: WidgetText,
+    atoms: Atoms<'a>,
     indeterminate: bool,
 }
 
 impl<'a> Checkbox<'a> {
-    pub fn new(checked: &'a mut bool, text: impl Into<WidgetText>) -> Self {
+    pub fn new(checked: &'a mut bool, atoms: impl IntoAtoms<'a>) -> Self {
         Checkbox {
             checked,
-            text: text.into(),
+            atoms: atoms.into_atoms(),
             indeterminate: false,
         }
     }
 
     pub fn without_text(checked: &'a mut bool) -> Self {
-        Self::new(checked, WidgetText::default())
+        Self::new(checked, ())
     }
 
     /// Display an indeterminate state (neither checked nor unchecked)
@@ -51,92 +51,88 @@ impl Widget for Checkbox<'_> {
     fn ui(self, ui: &mut Ui) -> Response {
         let Checkbox {
             checked,
-            text,
+            mut atoms,
             indeterminate,
         } = self;
 
         let spacing = &ui.spacing();
         let icon_width = spacing.icon_width;
-        let icon_spacing = spacing.icon_spacing;
 
-        let (galley, 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 mut min_size = Vec2::splat(spacing.interact_size.y);
+        min_size.y = min_size.y.at_least(icon_width);
 
-            let wrap_width = ui.available_width() - total_extra.x;
-            let galley = text.into_galley(ui, None, wrap_width, TextStyle::Button);
+        // In order to center the checkbox based on min_size we set the icon height to at least min_size.y
+        let mut icon_size = Vec2::splat(icon_width);
+        icon_size.y = icon_size.y.at_least(min_size.y);
+        let rect_id = Id::new("egui::checkbox");
+        atoms.push_left(Atom::custom(rect_id, icon_size));
 
-            let mut desired_size = total_extra + galley.size();
-            desired_size = desired_size.at_least(spacing.interact_size);
+        let text = atoms.text().map(String::from);
 
-            (Some(galley), desired_size)
-        };
+        let mut prepared = AtomLayout::new(atoms)
+            .sense(Sense::click())
+            .min_size(min_size)
+            .allocate(ui);
 
-        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() {
+        if prepared.response.clicked() {
             *checked = !*checked;
-            response.mark_changed();
+            prepared.response.mark_changed();
         }
-        response.widget_info(|| {
+        prepared.response.widget_info(|| {
             if indeterminate {
                 WidgetInfo::labeled(
                     WidgetType::Checkbox,
                     ui.is_enabled(),
-                    galley.as_ref().map_or("", |x| x.text()),
+                    text.as_deref().unwrap_or(""),
                 )
             } else {
                 WidgetInfo::selected(
                     WidgetType::Checkbox,
                     ui.is_enabled(),
                     *checked,
-                    galley.as_ref().map_or("", |x| x.text()),
+                    text.as_deref().unwrap_or(""),
                 )
             }
         });
 
-        if ui.is_rect_visible(rect) {
+        if ui.is_rect_visible(prepared.response.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::new(
-                big_icon_rect.expand(visuals.expansion),
-                visuals.corner_radius,
-                visuals.bg_fill,
-                visuals.bg_stroke,
-                epaint::StrokeKind::Inside,
-            ));
+            let visuals = *ui.style().interact(&prepared.response);
+            prepared.fallback_text_color = visuals.text_color();
+            let response = prepared.paint(ui);
 
-            if indeterminate {
-                // Horizontal line:
-                ui.painter().add(Shape::hline(
-                    small_icon_rect.x_range(),
-                    small_icon_rect.center().y,
-                    visuals.fg_stroke,
-                ));
-            } else 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(rect) = response.rect(rect_id) {
+                let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
+                ui.painter().add(epaint::RectShape::new(
+                    big_icon_rect.expand(visuals.expansion),
+                    visuals.corner_radius,
+                    visuals.bg_fill,
+                    visuals.bg_stroke,
+                    epaint::StrokeKind::Inside,
                 ));
+
+                if indeterminate {
+                    // Horizontal line:
+                    ui.painter().add(Shape::hline(
+                        small_icon_rect.x_range(),
+                        small_icon_rect.center().y,
+                        visuals.fg_stroke,
+                    ));
+                } else 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(galley) = galley {
-                let text_pos = pos2(
-                    rect.min.x + icon_width + icon_spacing,
-                    rect.center().y - 0.5 * galley.size().y,
-                );
-                ui.painter().galley(text_pos, galley, visuals.text_color());
-            }
+            response.response
+        } else {
+            prepared.response
         }
-
-        response
     }
 }
diff --git a/crates/egui/src/widgets/color_picker.rs b/crates/egui/src/widgets/color_picker.rs
index a9906cef1..17d6b650b 100644
--- a/crates/egui/src/widgets/color_picker.rs
+++ b/crates/egui/src/widgets/color_picker.rs
@@ -2,12 +2,13 @@
 
 use crate::util::fixed_cache::FixedCache;
 use crate::{
-    epaint, lerp, remap_clamp, Area, Context, DragValue, Frame, Id, Key, Order, Painter, Response,
-    Sense, Ui, UiKind, Widget, WidgetInfo, WidgetType,
+    Context, DragValue, Id, Painter, Popup, PopupCloseBehavior, Response, Sense, Ui, Widget as _,
+    WidgetInfo, WidgetType, epaint, lerp, remap_clamp,
 };
 use epaint::{
+    Mesh, Rect, Shape, Stroke, StrokeKind, Vec2,
     ecolor::{Color32, Hsva, HsvaGamma, Rgba},
-    pos2, vec2, Mesh, Rect, Shape, Stroke, StrokeKind, Vec2,
+    pos2, vec2,
 };
 
 fn contrast_color(color: impl Into<Rgba>) -> Color32 {
@@ -490,40 +491,23 @@ pub fn color_picker_color32(ui: &mut Ui, srgba: &mut Color32, alpha: Alpha) -> b
 
 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 open = Popup::is_id_open(ui.ctx(), 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 = 275.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)
-            .kind(UiKind::Picker)
-            .order(Order::Foreground)
-            .fixed_pos(button_response.rect.max)
-            .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());
-        }
-    }
+    Popup::menu(&button_response)
+        .id(popup_id)
+        .close_behavior(PopupCloseBehavior::CloseOnClickOutside)
+        .show(|ui| {
+            ui.spacing_mut().slider_width = COLOR_SLIDER_WIDTH;
+            if color_picker_hsva_2d(ui, hsva, alpha) {
+                button_response.mark_changed();
+            }
+        });
 
     button_response
 }
diff --git a/crates/egui/src/widgets/drag_value.rs b/crates/egui/src/widgets/drag_value.rs
index 846ab72f0..29d596201 100644
--- a/crates/egui/src/widgets/drag_value.rs
+++ b/crates/egui/src/widgets/drag_value.rs
@@ -3,8 +3,8 @@
 use std::{cmp::Ordering, ops::RangeInclusive};
 
 use crate::{
-    emath, text, Button, CursorIcon, Key, Modifiers, NumExt, Response, RichText, Sense, TextEdit,
-    TextWrapMode, Ui, Widget, WidgetInfo, MINUS_CHAR_STR,
+    Button, CursorIcon, Id, Key, MINUS_CHAR_STR, Modifiers, NumExt as _, Response, RichText, Sense,
+    TextEdit, TextWrapMode, Ui, Widget, WidgetInfo, emath, text,
 };
 
 // ----------------------------------------------------------------------------
@@ -451,10 +451,11 @@ impl Widget for DragValue<'_> {
         // 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, ui.layer_id());
-            mem.has_focus(id)
-        });
+        let is_kb_editing = ui.is_enabled()
+            && ui.memory_mut(|mem| {
+                mem.interested_in_focus(id, ui.layer_id());
+                mem.has_focus(id)
+            });
 
         if ui.memory_mut(|mem| mem.gained_focus(id)) {
             ui.data_mut(|data| data.remove::<String>(id));
@@ -488,27 +489,21 @@ impl Widget for DragValue<'_> {
                     - 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;
-            }
+            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")]
-        {
+        ui.input(|input| {
             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;
-                    }
+            for request in input.accesskit_action_requests(id, Action::SetValue) {
+                if let Some(ActionData::NumericValue(new_value)) = request.data {
+                    value = new_value;
                 }
-            });
-        }
+            }
+        });
 
         if clamp_existing_to_range {
             value = clamp_value_to_range(value, range.clone());
@@ -549,7 +544,7 @@ impl Widget for DragValue<'_> {
         }
 
         // some clones below are redundant if AccessKit is disabled
-        #[allow(clippy::redundant_clone)]
+        #[expect(clippy::redundant_clone)]
         let mut response = if is_kb_editing {
             let mut value_text = ui
                 .data_mut(|data| data.remove_temp::<String>(id))
@@ -562,10 +557,17 @@ impl Widget for DragValue<'_> {
                     .margin(ui.spacing().button_padding)
                     .min_size(ui.spacing().interact_size)
                     .id(id)
-                    .desired_width(ui.spacing().interact_size.x)
+                    .desired_width(
+                        ui.spacing().interact_size.x - 2.0 * ui.spacing().button_padding.x,
+                    )
                     .font(text_style),
             );
 
+            // Select all text when the edit gains focus.
+            if ui.memory_mut(|mem| mem.gained_focus(id)) {
+                select_all_text(ui, id, response.id, &value_text);
+            }
+
             let update = if update_while_editing {
                 // Update when the edit content has changed.
                 response.changed()
@@ -620,12 +622,7 @@ impl Widget for DragValue<'_> {
             if response.clicked() {
                 ui.data_mut(|data| data.remove::<String>(id));
                 ui.memory_mut(|mem| mem.request_focus(id));
-                let mut state = TextEdit::load_state(ui.ctx(), id).unwrap_or_default();
-                state.cursor.set_char_range(Some(text::CCursorRange::two(
-                    text::CCursor::default(),
-                    text::CCursor::new(value_text.chars().count()),
-                )));
-                state.store(ui.ctx(), response.id);
+                select_all_text(ui, id, response.id, &value_text);
             } else if response.dragged() {
                 ui.ctx().set_cursor_icon(cursor_icon);
 
@@ -666,7 +663,6 @@ impl Widget for DragValue<'_> {
 
         response.widget_info(|| WidgetInfo::drag_value(ui.is_enabled(), 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
@@ -756,6 +752,16 @@ pub(crate) fn clamp_value_to_range(x: f64, range: RangeInclusive<f64>) -> f64 {
     }
 }
 
+/// Select all text in the `DragValue` text edit widget.
+fn select_all_text(ui: &Ui, widget_id: Id, response_id: Id, value_text: &str) {
+    let mut state = TextEdit::load_state(ui.ctx(), widget_id).unwrap_or_default();
+    state.cursor.set_char_range(Some(text::CCursorRange::two(
+        text::CCursor::default(),
+        text::CCursor::new(value_text.chars().count()),
+    )));
+    state.store(ui.ctx(), response_id);
+}
+
 #[cfg(test)]
 mod tests {
     use super::clamp_value_to_range;
diff --git a/crates/egui/src/widgets/hyperlink.rs b/crates/egui/src/widgets/hyperlink.rs
index 7d5129b14..989643304 100644
--- a/crates/egui/src/widgets/hyperlink.rs
+++ b/crates/egui/src/widgets/hyperlink.rs
@@ -1,6 +1,6 @@
 use crate::{
-    epaint, text_selection, CursorIcon, Label, Response, Sense, Stroke, Ui, Widget, WidgetInfo,
-    WidgetText, WidgetType,
+    CursorIcon, Label, Response, Sense, Stroke, Ui, Widget, WidgetInfo, WidgetText, WidgetType,
+    epaint, text_selection,
 };
 
 use self::text_selection::LabelSelectionState;
@@ -96,7 +96,7 @@ pub struct Hyperlink {
 }
 
 impl Hyperlink {
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn new(url: impl ToString) -> Self {
         let url = url.to_string();
         Self {
@@ -106,7 +106,7 @@ impl Hyperlink {
         }
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn from_label_and_url(text: impl Into<WidgetText>, url: impl ToString) -> Self {
         Self {
             url: url.to_string(),
@@ -129,18 +129,16 @@ impl Widget for Hyperlink {
 
         let response = ui.add(Link::new(text));
 
-        if response.clicked() {
-            let modifiers = ui.ctx().input(|i| i.modifiers);
-            ui.ctx().open_url(crate::OpenUrl {
-                url: url.clone(),
-                new_tab: new_tab || modifiers.any(),
-            });
-        }
-        if response.middle_clicked() {
+        if response.clicked_with_open_in_background() {
             ui.ctx().open_url(crate::OpenUrl {
                 url: url.clone(),
                 new_tab: true,
             });
+        } else if response.clicked() {
+            ui.ctx().open_url(crate::OpenUrl {
+                url: url.clone(),
+                new_tab,
+            });
         }
 
         if ui.style().url_in_tooltip {
diff --git a/crates/egui/src/widgets/image.rs b/crates/egui/src/widgets/image.rs
index 89974dcaf..167920adc 100644
--- a/crates/egui/src/widgets/image.rs
+++ b/crates/egui/src/widgets/image.rs
@@ -1,15 +1,16 @@
 use std::{borrow::Cow, slice::Iter, sync::Arc, time::Duration};
 
-use emath::{Align, Float as _, Rot2};
+use emath::{Align, Float as _, GuiRounding as _, NumExt as _, Rot2};
 use epaint::{
-    text::{LayoutJob, TextFormat, TextWrapping},
     RectShape,
+    text::{LayoutJob, TextFormat, TextWrapping},
 };
 
 use crate::{
-    load::{Bytes, SizeHint, SizedTexture, TextureLoadResult, TexturePoll},
-    pos2, Color32, Context, CornerRadius, Id, Mesh, Painter, Rect, Response, Sense, Shape, Spinner,
+    Color32, Context, CornerRadius, Id, Mesh, Painter, Rect, Response, Sense, Shape, Spinner,
     TextStyle, TextureOptions, Ui, Vec2, Widget, WidgetInfo, WidgetType,
+    load::{Bytes, SizeHint, SizedTexture, TextureLoadResult, TexturePoll},
+    pos2,
 };
 
 /// A widget which displays an image.
@@ -54,7 +55,7 @@ pub struct Image<'a> {
     sense: Sense,
     size: ImageSize,
     pub(crate) show_loading_spinner: Option<bool>,
-    alt_text: Option<String>,
+    pub(crate) alt_text: Option<String>,
 }
 
 impl<'a> Image<'a> {
@@ -156,6 +157,9 @@ impl<'a> Image<'a> {
 
     /// Fit the image to its original size with some scaling.
     ///
+    /// The texel size of the source image will be multiplied by the `scale` factor,
+    /// and then become the _ui_ size of the [`Image`].
+    ///
     /// This will cause the image to overflow if it is larger than the available space.
     ///
     /// If [`Image::max_size`] is set, this is guaranteed to never exceed that limit.
@@ -274,7 +278,8 @@ impl<'a> Image<'a> {
     }
 
     /// Set alt text for the image. This will be shown when the image fails to load.
-    /// It will also be read to screen readers.
+    ///
+    /// It will also be used for accessibility (e.g. read by screen readers).
     #[inline]
     pub fn alt_text(mut self, label: impl Into<String>) -> Self {
         self.alt_text = Some(label.into());
@@ -291,9 +296,9 @@ impl<'a, T: Into<ImageSource<'a>>> From<T> for Image<'a> {
 impl<'a> Image<'a> {
     /// Returns the size the image will occupy in the final UI.
     #[inline]
-    pub fn calc_size(&self, available_size: Vec2, original_image_size: Option<Vec2>) -> Vec2 {
-        let original_image_size = original_image_size.unwrap_or(Vec2::splat(24.0)); // Fallback for still-loading textures, or failure to load.
-        self.size.calc_size(available_size, original_image_size)
+    pub fn calc_size(&self, available_size: Vec2, image_source_size: Option<Vec2>) -> Vec2 {
+        let image_source_size = image_source_size.unwrap_or(Vec2::splat(24.0)); // Fallback for still-loading textures, or failure to load.
+        self.size.calc_size(available_size, image_source_size)
     }
 
     pub fn load_and_calc_size(&self, ui: &Ui, available_size: Vec2) -> Option<Vec2> {
@@ -373,9 +378,27 @@ impl<'a> Image<'a> {
     /// ```
     #[inline]
     pub fn paint_at(&self, ui: &Ui, rect: Rect) {
+        let pixels_per_point = ui.pixels_per_point();
+
+        let rect = rect.round_to_pixels(pixels_per_point);
+
+        // Load exactly the size of the rectangle we are painting to.
+        // This is important for getting crisp SVG:s.
+        let pixel_size = (pixels_per_point * rect.size()).round();
+
+        let texture = self.source(ui.ctx()).clone().load(
+            ui.ctx(),
+            self.texture_options,
+            SizeHint::Size {
+                width: pixel_size.x as _,
+                height: pixel_size.y as _,
+                maintain_aspect_ratio: false, // no - just get exactly what we asked for
+            },
+        );
+
         paint_texture_load_result(
             ui,
-            &self.load_for_size(ui.ctx(), rect.size()),
+            &texture,
             rect,
             self.show_loading_spinner,
             &self.image_options,
@@ -387,8 +410,8 @@ impl<'a> Image<'a> {
 impl Widget for Image<'_> {
     fn ui(self, ui: &mut Ui) -> Response {
         let tlr = self.load_for_size(ui.ctx(), ui.available_size());
-        let original_image_size = tlr.as_ref().ok().and_then(|t| t.size());
-        let ui_size = self.calc_size(ui.available_size(), original_image_size);
+        let image_source_size = tlr.as_ref().ok().and_then(|t| t.size());
+        let ui_size = self.calc_size(ui.available_size(), image_source_size);
 
         let (rect, response) = ui.allocate_exact_size(ui_size, self.sense);
         response.widget_info(|| {
@@ -440,7 +463,10 @@ pub struct ImageSize {
 #[derive(Debug, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum ImageFit {
-    /// Fit the image to its original size, scaled by some factor.
+    /// Fit the image to its original srce size, scaled by some factor.
+    ///
+    /// The original size of the image is usually its texel resolution,
+    /// but for an SVG it's the point size of the SVG.
     ///
     /// Ignores how much space is actually available in the ui.
     Original { scale: f32 },
@@ -467,25 +493,38 @@ impl ImageFit {
 impl ImageSize {
     /// Size hint for e.g. rasterizing an svg.
     pub fn hint(&self, available_size: Vec2, pixels_per_point: f32) -> SizeHint {
-        let size = match self.fit {
-            ImageFit::Original { scale } => return SizeHint::Scale(scale.ord()),
+        let Self {
+            maintain_aspect_ratio,
+            max_size,
+            fit,
+        } = *self;
+
+        let point_size = match fit {
+            ImageFit::Original { scale } => {
+                return SizeHint::Scale((pixels_per_point * scale).ord());
+            }
             ImageFit::Fraction(fract) => available_size * fract,
             ImageFit::Exact(size) => size,
         };
-        let size = size.min(self.max_size);
-        let size = size * pixels_per_point;
+        let point_size = point_size.at_most(max_size);
+
+        let pixel_size = pixels_per_point * point_size;
 
         // `inf` on an axis means "any value"
-        match (size.x.is_finite(), size.y.is_finite()) {
-            (true, true) => SizeHint::Size(size.x.round() as u32, size.y.round() as u32),
-            (true, false) => SizeHint::Width(size.x.round() as u32),
-            (false, true) => SizeHint::Height(size.y.round() as u32),
+        match (pixel_size.x.is_finite(), pixel_size.y.is_finite()) {
+            (true, true) => SizeHint::Size {
+                width: pixel_size.x.round() as u32,
+                height: pixel_size.y.round() as u32,
+                maintain_aspect_ratio,
+            },
+            (true, false) => SizeHint::Width(pixel_size.x.round() as u32),
+            (false, true) => SizeHint::Height(pixel_size.y.round() as u32),
             (false, false) => SizeHint::Scale(pixels_per_point.ord()),
         }
     }
 
     /// Calculate the final on-screen size in points.
-    pub fn calc_size(&self, available_size: Vec2, original_image_size: Vec2) -> Vec2 {
+    pub fn calc_size(&self, available_size: Vec2, image_source_size: Vec2) -> Vec2 {
         let Self {
             maintain_aspect_ratio,
             max_size,
@@ -493,7 +532,7 @@ impl ImageSize {
         } = *self;
         match fit {
             ImageFit::Original { scale } => {
-                let image_size = original_image_size * scale;
+                let image_size = scale * image_source_size;
                 if image_size.x <= max_size.x && image_size.y <= max_size.y {
                     image_size
                 } else {
@@ -502,11 +541,11 @@ impl ImageSize {
             }
             ImageFit::Fraction(fract) => {
                 let scale_to_size = (available_size * fract).min(max_size);
-                scale_to_fit(original_image_size, scale_to_size, maintain_aspect_ratio)
+                scale_to_fit(image_source_size, scale_to_size, maintain_aspect_ratio)
             }
             ImageFit::Exact(size) => {
                 let scale_to_size = size.min(max_size);
-                scale_to_fit(original_image_size, scale_to_size, maintain_aspect_ratio)
+                scale_to_fit(image_source_size, scale_to_size, maintain_aspect_ratio)
             }
         }
     }
@@ -634,7 +673,7 @@ pub fn paint_texture_load_result(
     rect: Rect,
     show_loading_spinner: Option<bool>,
     options: &ImageOptions,
-    alt: Option<&str>,
+    alt_text: Option<&str>,
 ) {
     match tlr {
         Ok(TexturePoll::Ready { texture }) => {
@@ -659,9 +698,9 @@ pub fn paint_texture_load_result(
                 0.0,
                 TextFormat::simple(font_id.clone(), ui.visuals().error_fg_color),
             );
-            if let Some(alt) = alt {
+            if let Some(alt_text) = alt_text {
                 job.append(
-                    alt,
+                    alt_text,
                     ui.spacing().item_spacing.x,
                     TextFormat::simple(font_id, ui.visuals().text_color()),
                 );
@@ -899,11 +938,9 @@ fn animated_image_frame_index(ctx: &Context, uri: &str) -> usize {
                 return index;
             }
         }
-
-        0
-    } else {
-        0
     }
+
+    0
 }
 
 /// Checks if uri is a gif file
diff --git a/crates/egui/src/widgets/image_button.rs b/crates/egui/src/widgets/image_button.rs
index b1dddbf7c..752980bb8 100644
--- a/crates/egui/src/widgets/image_button.rs
+++ b/crates/egui/src/widgets/image_button.rs
@@ -1,11 +1,12 @@
 use crate::{
-    widgets, Color32, CornerRadius, Image, Rect, Response, Sense, Ui, Vec2, Widget, WidgetInfo,
-    WidgetType,
+    Color32, CornerRadius, Image, Rect, Response, Sense, Ui, Vec2, Widget, WidgetInfo, WidgetType,
+    widgets,
 };
 
 /// A clickable image within a frame.
 #[must_use = "You should put this widget in a ui with `ui.add(widget);`"]
 #[derive(Clone, Debug)]
+#[deprecated(since = "0.33.0", note = "Use egui::Button::image instead")]
 pub struct ImageButton<'a> {
     pub(crate) image: Image<'a>,
     sense: Sense,
@@ -14,6 +15,7 @@ pub struct ImageButton<'a> {
     alt_text: Option<String>,
 }
 
+#[expect(deprecated, reason = "Deprecated in egui 0.33.0")]
 impl<'a> ImageButton<'a> {
     pub fn new(image: impl Into<Image<'a>>) -> Self {
         Self {
@@ -82,6 +84,7 @@ impl<'a> ImageButton<'a> {
     }
 }
 
+#[expect(deprecated, reason = "Deprecated in egui 0.33.0")]
 impl Widget for ImageButton<'_> {
     fn ui(self, ui: &mut Ui) -> Response {
         let padding = if self.frame {
@@ -93,15 +96,15 @@ impl Widget for ImageButton<'_> {
 
         let available_size_for_image = ui.available_size() - 2.0 * padding;
         let tlr = self.image.load_for_size(ui.ctx(), available_size_for_image);
-        let original_image_size = tlr.as_ref().ok().and_then(|t| t.size());
+        let image_source_size = tlr.as_ref().ok().and_then(|t| t.size());
         let image_size = self
             .image
-            .calc_size(available_size_for_image, original_image_size);
+            .calc_size(available_size_for_image, image_source_size);
 
         let padded_size = image_size + 2.0 * padding;
         let (rect, response) = ui.allocate_exact_size(padded_size, self.sense);
         response.widget_info(|| {
-            let mut info = WidgetInfo::new(WidgetType::ImageButton);
+            let mut info = WidgetInfo::new(WidgetType::Button);
             info.label = self.alt_text.clone();
             info
         });
diff --git a/crates/egui/src/widgets/label.rs b/crates/egui/src/widgets/label.rs
index 67dc196bc..86259ab2a 100644
--- a/crates/egui/src/widgets/label.rs
+++ b/crates/egui/src/widgets/label.rs
@@ -1,12 +1,10 @@
 use std::sync::Arc;
 
 use crate::{
-    epaint, pos2, text_selection, vec2, Align, Direction, FontSelection, Galley, Pos2, Response,
-    Sense, Stroke, TextWrapMode, Ui, Widget, WidgetInfo, WidgetText, WidgetType,
+    Align, Direction, FontSelection, Galley, Pos2, Response, Sense, Stroke, TextWrapMode, Ui,
+    Widget, WidgetInfo, WidgetText, WidgetType, epaint, pos2, text_selection::LabelSelectionState,
 };
 
-use self::text_selection::LabelSelectionState;
-
 /// Static text.
 ///
 /// Usually it is more convenient to use [`Ui::label`].
@@ -30,6 +28,7 @@ pub struct Label {
     sense: Option<Sense>,
     selectable: Option<bool>,
     halign: Option<Align>,
+    show_tooltip_when_elided: bool,
 }
 
 impl Label {
@@ -40,6 +39,7 @@ impl Label {
             sense: None,
             selectable: None,
             halign: None,
+            show_tooltip_when_elided: true,
         }
     }
 
@@ -116,6 +116,23 @@ impl Label {
         self.sense = Some(sense);
         self
     }
+
+    /// Show the full text when hovered, if the text was elided.
+    ///
+    /// By default, this is true.
+    ///
+    /// ```
+    /// # use egui::{Label, Sense};
+    /// # egui::__run_test_ui(|ui| {
+    /// ui.add(Label::new("some text").show_tooltip_when_elided(false))
+    ///     .on_hover_text("completely different text");
+    /// # });
+    /// ```
+    #[inline]
+    pub fn show_tooltip_when_elided(mut self, show: bool) -> Self {
+        self.show_tooltip_when_elided = show;
+        self
+    }
 }
 
 impl Label {
@@ -148,7 +165,7 @@ impl Label {
             };
             select_sense -= Sense::FOCUSABLE; // Don't move focus to labels with TAB key.
 
-            sense = sense.union(select_sense);
+            sense |= select_sense;
         }
 
         if let WidgetText::Galley(galley) = self.text {
@@ -163,9 +180,11 @@ impl Label {
         }
 
         let valign = ui.text_valign();
-        let mut layout_job = self
-            .text
-            .into_layout_job(ui.style(), FontSelection::Default, valign);
+        let mut layout_job = Arc::unwrap_or_clone(self.text.into_layout_job(
+            ui.style(),
+            FontSelection::Default,
+            valign,
+        ));
 
         let available_width = ui.available_width();
 
@@ -180,7 +199,10 @@ impl Label {
 
             let cursor = ui.cursor();
             let first_row_indentation = available_width - ui.available_size_before_wrap().x;
-            debug_assert!(first_row_indentation.is_finite());
+            debug_assert!(
+                first_row_indentation.is_finite(),
+                "first row indentation is not finite: {first_row_indentation}"
+            );
 
             layout_job.wrap.max_width = available_width;
             layout_job.first_row_min_height = cursor.height();
@@ -189,15 +211,18 @@ impl Label {
             if let Some(first_section) = layout_job.sections.first_mut() {
                 first_section.leading_space = first_row_indentation;
             }
-            let galley = ui.fonts(|fonts| fonts.layout_job(layout_job));
+            let galley = ui.fonts_mut(|fonts| fonts.layout_job(layout_job));
 
             let pos = pos2(ui.max_rect().left(), ui.cursor().top());
             assert!(!galley.rows.is_empty(), "Galleys are never empty");
             // collect a response from many rows:
-            let rect = galley.rows[0].rect.translate(vec2(pos.x, pos.y));
+            let rect = galley.rows[0]
+                .rect_without_leading_space()
+                .translate(pos.to_vec2());
             let mut response = ui.allocate_rect(rect, sense);
-            for row in galley.rows.iter().skip(1) {
-                let rect = row.rect.translate(vec2(pos.x, pos.y));
+            response.intrinsic_size = Some(galley.intrinsic_size());
+            for placed_row in galley.rows.iter().skip(1) {
+                let rect = placed_row.rect().translate(pos.to_vec2());
                 response |= ui.allocate_rect(rect, sense);
             }
             (pos, galley, response)
@@ -225,10 +250,11 @@ impl Label {
             } else {
                 layout_job.halign = self.halign.unwrap_or(ui.layout().horizontal_placement());
                 layout_job.justify = ui.layout().horizontal_justify();
-            };
+            }
 
-            let galley = ui.fonts(|fonts| fonts.layout_job(layout_job));
-            let (rect, response) = ui.allocate_exact_size(galley.size(), sense);
+            let galley = ui.fonts_mut(|fonts| fonts.layout_job(layout_job));
+            let (rect, mut response) = ui.allocate_exact_size(galley.size(), sense);
+            response.intrinsic_size = Some(galley.intrinsic_size());
             let galley_pos = match galley.job.halign {
                 Align::LEFT => rect.left_top(),
                 Align::Center => rect.center_top(),
@@ -247,15 +273,22 @@ impl Widget for Label {
         let interactive = self.sense.is_some_and(|sense| sense != Sense::hover());
 
         let selectable = self.selectable;
+        let show_tooltip_when_elided = self.show_tooltip_when_elided;
 
         let (galley_pos, galley, mut response) = self.layout_in_ui(ui);
         response
             .widget_info(|| WidgetInfo::labeled(WidgetType::Label, ui.is_enabled(), galley.text()));
 
         if ui.is_rect_visible(response.rect) {
-            if galley.elided {
+            if show_tooltip_when_elided && galley.elided {
+                // Keep the sections and text, but reset everything else (especially wrapping):
+                let job = crate::text::LayoutJob {
+                    sections: galley.job.sections.clone(),
+                    text: galley.job.text.clone(),
+                    ..crate::text::LayoutJob::default()
+                };
                 // Show the full (non-elided) text on hover:
-                response = response.on_hover_text(galley.text());
+                response = response.on_hover_text(job);
             }
 
             let response_color = if interactive {
diff --git a/crates/egui/src/widgets/mod.rs b/crates/egui/src/widgets/mod.rs
index a4a40ec66..9cdefb699 100644
--- a/crates/egui/src/widgets/mod.rs
+++ b/crates/egui/src/widgets/mod.rs
@@ -4,7 +4,7 @@
 //! * `ui.add(Label::new("Text").text_color(color::red));`
 //! * `if ui.add(Button::new("Click me")).clicked() { … }`
 
-use crate::{epaint, Response, Ui};
+use crate::{Response, Ui, epaint};
 
 mod button;
 mod checkbox;
@@ -22,20 +22,22 @@ mod slider;
 mod spinner;
 pub mod text_edit;
 
+#[expect(deprecated)]
+pub use self::selected_label::SelectableLabel;
+#[expect(deprecated, reason = "Deprecated in egui 0.33.0")]
 pub use self::{
     button::Button,
     checkbox::Checkbox,
     drag_value::DragValue,
     hyperlink::{Hyperlink, Link},
     image::{
-        decode_animated_image_uri, has_gif_magic_header, has_webp_header, paint_texture_at,
         FrameDurations, Image, ImageFit, ImageOptions, ImageSize, ImageSource,
+        decode_animated_image_uri, has_gif_magic_header, has_webp_header, paint_texture_at,
     },
     image_button::ImageButton,
     label::Label,
     progress_bar::ProgressBar,
     radio_button::RadioButton,
-    selected_label::SelectableLabel,
     separator::Separator,
     slider::{Slider, SliderClamping, SliderOrientation},
     spinner::Spinner,
diff --git a/crates/egui/src/widgets/progress_bar.rs b/crates/egui/src/widgets/progress_bar.rs
index 44c9b8971..bba6be8ef 100644
--- a/crates/egui/src/widgets/progress_bar.rs
+++ b/crates/egui/src/widgets/progress_bar.rs
@@ -1,6 +1,6 @@
 use crate::{
-    lerp, vec2, Color32, CornerRadius, NumExt, Pos2, Rect, Response, Rgba, Sense, Shape, Stroke,
-    TextStyle, TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, WidgetType,
+    Color32, CornerRadius, NumExt as _, Pos2, Rect, Response, Rgba, Sense, Shape, Stroke,
+    TextStyle, TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, WidgetType, lerp, vec2,
 };
 
 enum ProgressBarText {
diff --git a/crates/egui/src/widgets/radio_button.rs b/crates/egui/src/widgets/radio_button.rs
index fabf565b5..8b1f7cc4b 100644
--- a/crates/egui/src/widgets/radio_button.rs
+++ b/crates/egui/src/widgets/radio_button.rs
@@ -1,6 +1,6 @@
 use crate::{
-    epaint, pos2, vec2, NumExt, Response, Sense, TextStyle, Ui, Vec2, Widget, WidgetInfo,
-    WidgetText, WidgetType,
+    Atom, AtomLayout, Atoms, Id, IntoAtoms, NumExt as _, Response, Sense, Ui, Vec2, Widget,
+    WidgetInfo, WidgetType, epaint,
 };
 
 /// One out of several alternatives, either selected or not.
@@ -23,89 +23,84 @@ use crate::{
 /// # });
 /// ```
 #[must_use = "You should put this widget in a ui with `ui.add(widget);`"]
-pub struct RadioButton {
+pub struct RadioButton<'a> {
     checked: bool,
-    text: WidgetText,
+    atoms: Atoms<'a>,
 }
 
-impl RadioButton {
-    pub fn new(checked: bool, text: impl Into<WidgetText>) -> Self {
+impl<'a> RadioButton<'a> {
+    pub fn new(checked: bool, atoms: impl IntoAtoms<'a>) -> Self {
         Self {
             checked,
-            text: text.into(),
+            atoms: atoms.into_atoms(),
         }
     }
 }
 
-impl Widget for RadioButton {
+impl Widget for RadioButton<'_> {
     fn ui(self, ui: &mut Ui) -> Response {
-        let Self { checked, text } = self;
+        let Self { checked, mut atoms } = self;
 
         let spacing = &ui.spacing();
         let icon_width = spacing.icon_width;
-        let icon_spacing = spacing.icon_spacing;
 
-        let (galley, 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 mut min_size = Vec2::splat(spacing.interact_size.y);
+        min_size.y = min_size.y.at_least(icon_width);
 
-            let wrap_width = ui.available_width() - total_extra.x;
-            let text = text.into_galley(ui, None, wrap_width, TextStyle::Button);
+        // In order to center the checkbox based on min_size we set the icon height to at least min_size.y
+        let mut icon_size = Vec2::splat(icon_width);
+        icon_size.y = icon_size.y.at_least(min_size.y);
+        let rect_id = Id::new("egui::radio_button");
+        atoms.push_left(Atom::custom(rect_id, icon_size));
 
-            let mut desired_size = total_extra + text.size();
-            desired_size = desired_size.at_least(spacing.interact_size);
+        let text = atoms.text().map(String::from);
 
-            (Some(text), desired_size)
-        };
+        let mut prepared = AtomLayout::new(atoms)
+            .sense(Sense::click())
+            .min_size(min_size)
+            .allocate(ui);
 
-        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(|| {
+        prepared.response.widget_info(|| {
             WidgetInfo::selected(
                 WidgetType::RadioButton,
                 ui.is_enabled(),
                 checked,
-                galley.as_ref().map_or("", |x| x.text()),
+                text.as_deref().unwrap_or(""),
             )
         });
 
-        if ui.is_rect_visible(rect) {
+        if ui.is_rect_visible(prepared.response.rect) {
             // let visuals = ui.style().interact_selectable(&response, checked); // too colorful
-            let visuals = ui.style().interact(&response);
+            let visuals = *ui.style().interact(&prepared.response);
 
-            let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
+            prepared.fallback_text_color = visuals.text_color();
+            let response = prepared.paint(ui);
 
-            let painter = ui.painter();
+            if let Some(rect) = response.rect(rect_id) {
+                let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
 
-            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,
-            });
+                let painter = ui.painter();
 
-            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(),
+                    center: big_icon_rect.center(),
+                    radius: big_icon_rect.width() / 2.0 + visuals.expansion,
+                    fill: visuals.bg_fill,
+                    stroke: visuals.bg_stroke,
                 });
-            }
 
-            if let Some(galley) = galley {
-                let text_pos = pos2(
-                    rect.min.x + icon_width + icon_spacing,
-                    rect.center().y - 0.5 * galley.size().y,
-                );
-                ui.painter().galley(text_pos, galley, visuals.text_color());
+                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(),
+                    });
+                }
             }
+            response.response
+        } else {
+            prepared.response
         }
-
-        response
     }
 }
diff --git a/crates/egui/src/widgets/selected_label.rs b/crates/egui/src/widgets/selected_label.rs
index dfed4d2ba..536ef43da 100644
--- a/crates/egui/src/widgets/selected_label.rs
+++ b/crates/egui/src/widgets/selected_label.rs
@@ -1,86 +1,13 @@
-use crate::{NumExt, Response, Sense, TextStyle, Ui, Widget, WidgetInfo, WidgetText, WidgetType};
+#![expect(deprecated, clippy::new_ret_no_self)]
 
-/// One out of several alternatives, either selected or not.
-/// Will mark selected items with a different background color.
-/// An alternative to [`crate::RadioButton`] and [`crate::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 a ui with `ui.add(widget);`"]
-pub struct SelectableLabel {
-    selected: bool,
-    text: WidgetText,
-}
+use crate::WidgetText;
+
+#[deprecated = "Use `Button::selectable()` instead"]
+pub struct SelectableLabel {}
 
 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 galley = text.into_galley(ui, None, wrap_width, TextStyle::Button);
-
-        let mut desired_size = total_extra + galley.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,
-                ui.is_enabled(),
-                selected,
-                galley.text(),
-            )
-        });
-
-        if ui.is_rect_visible(response.rect) {
-            let text_pos = ui
-                .layout()
-                .align_size_within_rect(galley.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.corner_radius,
-                    visuals.weak_bg_fill,
-                    visuals.bg_stroke,
-                    epaint::StrokeKind::Inside,
-                );
-            }
-
-            ui.painter().galley(text_pos, galley, visuals.text_color());
-        }
-
-        response
+    #[deprecated = "Use `Button::selectable()` instead"]
+    pub fn new(selected: bool, text: impl Into<WidgetText>) -> super::Button<'static> {
+        crate::Button::selectable(selected, text)
     }
 }
diff --git a/crates/egui/src/widgets/separator.rs b/crates/egui/src/widgets/separator.rs
index d018cfa4d..6fdd03b96 100644
--- a/crates/egui/src/widgets/separator.rs
+++ b/crates/egui/src/widgets/separator.rs
@@ -1,4 +1,4 @@
-use crate::{vec2, Response, Sense, Ui, Vec2, Widget};
+use crate::{Response, Sense, Ui, Vec2, Widget, vec2};
 
 /// A visual separator. A horizontal or vertical line (depending on [`crate::Layout`]).
 ///
diff --git a/crates/egui/src/widgets/slider.rs b/crates/egui/src/widgets/slider.rs
index 590282074..129c41c3b 100644
--- a/crates/egui/src/widgets/slider.rs
+++ b/crates/egui/src/widgets/slider.rs
@@ -3,9 +3,9 @@
 use std::ops::RangeInclusive;
 
 use crate::{
-    emath, epaint, lerp, pos2, remap, remap_clamp, style, style::HandleShape, vec2, Color32,
-    DragValue, EventFilter, Key, Label, NumExt, Pos2, Rangef, Rect, Response, Sense, TextStyle,
-    TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, MINUS_CHAR_STR,
+    Color32, DragValue, EventFilter, Key, Label, MINUS_CHAR_STR, NumExt as _, Pos2, Rangef, Rect,
+    Response, Sense, TextStyle, TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, emath,
+    epaint, lerp, pos2, remap, remap_clamp, style, style::HandleShape, vec2,
 };
 
 use super::drag_value::clamp_value_to_range;
@@ -117,6 +117,7 @@ pub struct Slider<'a> {
     custom_parser: Option<NumParser<'a>>,
     trailing_fill: Option<bool>,
     handle_shape: Option<HandleShape>,
+    update_while_editing: bool,
 }
 
 impl<'a> Slider<'a> {
@@ -133,11 +134,7 @@ impl<'a> Slider<'a> {
             value.to_f64()
         });
 
-        if Num::INTEGRAL {
-            slf.integer()
-        } else {
-            slf
-        }
+        if Num::INTEGRAL { slf.integer() } else { slf }
     }
 
     pub fn from_get_set(
@@ -167,6 +164,7 @@ impl<'a> Slider<'a> {
             custom_parser: None,
             trailing_fill: None,
             handle_shape: None,
+            update_while_editing: true,
         }
     }
 
@@ -641,6 +639,16 @@ impl<'a> Slider<'a> {
         let normalized = normalized_from_value(value, self.range(), &self.spec);
         lerp(position_range, normalized as f32)
     }
+
+    /// Update the value on each key press when text-editing the value.
+    ///
+    /// Default: `true`.
+    /// If `false`, the value will only be updated when user presses enter or deselects the value.
+    #[inline]
+    pub fn update_while_editing(mut self, update: bool) -> Self {
+        self.update_while_editing = update;
+        self
+    }
 }
 
 impl Slider<'_> {
@@ -708,14 +716,11 @@ impl Slider<'_> {
             });
         }
 
-        #[cfg(feature = "accesskit")]
-        {
+        ui.input(|input| {
             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);
-            });
-        }
+            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;
 
@@ -724,7 +729,7 @@ impl Slider<'_> {
             let prev_value = self.get_value();
             let prev_position = self.position_from_value(prev_value, position_range);
             let new_position = prev_position + ui_point_per_step * kb_step;
-            let new_value = match self.step {
+            let mut new_value = match self.step {
                 Some(step) => prev_value + (kb_step as f64 * step),
                 None if self.smart_aim => {
                     let aim_radius = 0.49 * ui_point_per_step; // Chosen so we don't include `prev_value` in the search.
@@ -735,20 +740,30 @@ impl Slider<'_> {
                 }
                 _ => self.value_from_position(new_position, position_range),
             };
+            if let Some(max_decimals) = self.max_decimals {
+                // self.set_value rounds, so ensure we reach at the least the next breakpoint
+                // note: we give it a little bit of leeway due to floating point errors. (0.1 isn't representable in binary)
+                // 'set_value' will round it to the nearest value.
+                let min_increment = 1.0 / (10.0_f64.powi(max_decimals as i32));
+                new_value = if new_value > prev_value {
+                    f64::max(new_value, prev_value + min_increment * 1.001)
+                } else if new_value < prev_value {
+                    f64::min(new_value, prev_value - min_increment * 1.001)
+                } else {
+                    new_value
+                };
+            }
             self.set_value(new_value);
         }
 
-        #[cfg(feature = "accesskit")]
-        {
+        ui.input(|input| {
             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);
-                    }
+            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) {
@@ -785,7 +800,7 @@ impl Slider<'_> {
                     SliderOrientation::Vertical => {
                         trailing_rail_rect.min.y = center.y - corner_radius.se as f32;
                     }
-                };
+                }
 
                 ui.painter().rect_filled(
                     trailing_rail_rect,
@@ -900,7 +915,8 @@ impl Slider<'_> {
                 .min_decimals(self.min_decimals)
                 .max_decimals_opt(self.max_decimals)
                 .suffix(self.suffix.clone())
-                .prefix(self.prefix.clone());
+                .prefix(self.prefix.clone())
+                .update_while_editing(self.update_while_editing);
 
             match self.clamping {
                 SliderClamping::Never => {}
@@ -914,7 +930,7 @@ impl Slider<'_> {
 
             if let Some(fmt) = &self.custom_formatter {
                 dv = dv.custom_formatter(fmt);
-            };
+            }
             if let Some(parser) = &self.custom_parser {
                 dv = dv.custom_parser(parser);
             }
@@ -956,7 +972,6 @@ impl Slider<'_> {
         }
         response.widget_info(|| WidgetInfo::slider(ui.is_enabled(), 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());
@@ -1065,7 +1080,10 @@ fn value_from_normalized(normalized: f64, range: RangeInclusive<f64>, spec: &Sli
             let log = lerp(min_log..=max_log, normalized);
             10.0_f64.powf(log)
         } else {
-            assert!(min < 0.0 && 0.0 < max);
+            assert!(
+                min < 0.0 && 0.0 < max,
+                "min should be negative and max positive, but got min={min} and max={max}"
+            );
             let zero_cutoff = logarithmic_zero_cutoff(min, max);
             if normalized < zero_cutoff {
                 // negative
@@ -1114,7 +1132,10 @@ fn normalized_from_value(value: f64, range: RangeInclusive<f64>, spec: &SliderSp
             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);
+            assert!(
+                min < 0.0 && 0.0 < max,
+                "min should be negative and max positive, but got min={min} and max={max}"
+            );
             let zero_cutoff = logarithmic_zero_cutoff(min, max);
             if value < 0.0 {
                 // negative
@@ -1142,8 +1163,11 @@ fn normalized_from_value(value: f64, range: RangeInclusive<f64>, spec: &SliderSp
 }
 
 fn range_log10(min: f64, max: f64, spec: &SliderSpec) -> (f64, f64) {
-    assert!(spec.logarithmic);
-    assert!(min <= max);
+    assert!(spec.logarithmic, "spec must be logarithmic");
+    assert!(
+        min <= max,
+        "min must be less than or equal to max, but was min={min} and max={max}"
+    );
 
     if min == 0.0 && max == INFINITY {
         (spec.smallest_positive.log10(), INF_RANGE_MAGNITUDE)
@@ -1167,7 +1191,10 @@ fn range_log10(min: f64, max: f64, spec: &SliderSpec) -> (f64, f64) {
 /// 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);
+    assert!(
+        min < 0.0 && 0.0 < max,
+        "min must be negative and max positive, but got min={min} and max={max}"
+    );
 
     let min_magnitude = if min == -INFINITY {
         INF_RANGE_MAGNITUDE
diff --git a/crates/egui/src/widgets/spinner.rs b/crates/egui/src/widgets/spinner.rs
index 97cf24966..8b5ab5e28 100644
--- a/crates/egui/src/widgets/spinner.rs
+++ b/crates/egui/src/widgets/spinner.rs
@@ -1,4 +1,4 @@
-use epaint::{emath::lerp, vec2, Color32, Pos2, Rect, Shape, Stroke};
+use epaint::{Color32, Pos2, Rect, Shape, Stroke, emath::lerp, vec2};
 
 use crate::{Response, Sense, Ui, Widget, WidgetInfo, WidgetType};
 
@@ -42,8 +42,8 @@ impl Spinner {
             let color = self
                 .color
                 .unwrap_or_else(|| ui.visuals().strong_text_color());
-            let radius = (rect.height() / 2.0) - 2.0;
-            let n_points = 20;
+            let radius = (rect.height().min(rect.width()) / 2.0) - 2.0;
+            let n_points = (radius.round() as u32).clamp(8, 128);
             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();
diff --git a/crates/egui/src/widgets/text_edit/builder.rs b/crates/egui/src/widgets/text_edit/builder.rs
index 2f685bbc1..6f2da1baa 100644
--- a/crates/egui/src/widgets/text_edit/builder.rs
+++ b/crates/egui/src/widgets/text_edit/builder.rs
@@ -2,25 +2,25 @@ use std::sync::Arc;
 
 use emath::{Rect, TSTransform};
 use epaint::{
-    text::{cursor::CCursor, Galley, LayoutJob},
     StrokeKind,
+    text::{Galley, LayoutJob, cursor::CCursor},
 };
 
 use crate::{
-    epaint,
+    Align, Align2, Color32, Context, CursorIcon, Event, EventFilter, FontSelection, Id, ImeEvent,
+    Key, KeyboardShortcut, Margin, Modifiers, NumExt as _, Response, Sense, Shape, TextBuffer,
+    TextStyle, TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, WidgetWithState, epaint,
     os::OperatingSystem,
     output::OutputEvent,
     response, text_selection,
-    text_selection::{
-        text_cursor_state::cursor_rect, visuals::paint_text_selection, CCursorRange, CursorRange,
-    },
-    vec2, Align, Align2, Color32, Context, CursorIcon, Event, EventFilter, FontSelection, Id,
-    ImeEvent, Key, KeyboardShortcut, Margin, Modifiers, NumExt, Response, Sense, Shape, TextBuffer,
-    TextStyle, TextWrapMode, Ui, Vec2, Widget, WidgetInfo, WidgetText, WidgetWithState,
+    text_selection::{CCursorRange, text_cursor_state::cursor_rect, visuals::paint_text_selection},
+    vec2,
 };
 
 use super::{TextEditOutput, TextEditState};
 
+type LayouterFn<'t> = &'t mut dyn FnMut(&Ui, &dyn TextBuffer, f32) -> Arc<Galley>;
+
 /// A text region that the user can edit the contents of.
 ///
 /// See also [`Ui::text_edit_singleline`] and [`Ui::text_edit_multiline`].
@@ -63,7 +63,7 @@ use super::{TextEditOutput, TextEditState};
 /// See [`TextEdit::show`].
 ///
 /// ## Other
-/// The background color of a [`crate::TextEdit`] is [`crate::Visuals::extreme_bg_color`] or can be set with [`crate::TextEdit::background_color`].
+/// The background color of a [`crate::TextEdit`] is [`crate::Visuals::text_edit_bg_color`] or can be set with [`crate::TextEdit::background_color`].
 #[must_use = "You should put this widget in a ui with `ui.add(widget);`"]
 pub struct TextEdit<'t> {
     text: &'t mut dyn TextBuffer,
@@ -73,7 +73,7 @@ pub struct TextEdit<'t> {
     id_salt: Option<Id>,
     font_selection: FontSelection,
     text_color: Option<Color32>,
-    layouter: Option<&'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>>,
+    layouter: Option<LayouterFn<'t>>,
     password: bool,
     frame: bool,
     margin: Margin,
@@ -207,7 +207,7 @@ impl<'t> TextEdit<'t> {
         self
     }
 
-    /// Set the background color of the [`TextEdit`]. The default is [`crate::Visuals::extreme_bg_color`].
+    /// Set the background color of the [`TextEdit`]. The default is [`crate::Visuals::text_edit_bg_color`].
     // TODO(bircni): remove this once #3284 is implemented
     #[inline]
     pub fn background_color(mut self, color: Color32) -> Self {
@@ -263,16 +263,19 @@ impl<'t> TextEdit<'t> {
     /// # 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);
+    /// let mut layouter = |ui: &egui::Ui, buf: &dyn egui::TextBuffer, wrap_width: f32| {
+    ///     let mut layout_job: egui::text::LayoutJob = my_memoized_highlighter(buf.as_str());
     ///     layout_job.wrap.max_width = wrap_width;
-    ///     ui.fonts(|f| f.layout_job(layout_job))
+    ///     ui.fonts_mut(|f| f.layout_job(layout_job))
     /// };
     /// ui.add(egui::TextEdit::multiline(&mut my_code).layouter(&mut layouter));
     /// # });
     /// ```
     #[inline]
-    pub fn layouter(mut self, layouter: &'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>) -> Self {
+    pub fn layouter(
+        mut self,
+        layouter: &'t mut dyn FnMut(&Ui, &dyn TextBuffer, f32) -> Arc<Galley>,
+    ) -> Self {
         self.layouter = Some(layouter);
 
         self
@@ -425,19 +428,12 @@ impl TextEdit<'_> {
         let where_to_put_background = ui.painter().add(Shape::Noop);
         let background_color = self
             .background_color
-            .unwrap_or(ui.visuals().extreme_bg_color);
-        let margin = self.margin;
-        let mut output = self.show_content(ui);
-
-        // TODO(emilk): return full outer_rect in `TextEditOutput`.
-        // Can't do it now because this fix is ging into a patch release.
-        let outer_rect = output.response.rect;
-        let inner_rect = outer_rect - margin;
-        output.response.rect = inner_rect;
+            .unwrap_or_else(|| ui.visuals().text_edit_bg_color());
+        let output = self.show_content(ui);
 
         if frame {
             let visuals = ui.style().interact(&output.response);
-            let frame_rect = outer_rect.expand(visuals.expansion);
+            let frame_rect = output.response.rect.expand(visuals.expansion);
             let shape = if is_mutable {
                 if output.response.has_focus() {
                     epaint::RectShape::new(
@@ -505,9 +501,10 @@ impl TextEdit<'_> {
             .unwrap_or_else(|| ui.visuals().widgets.inactive.text_color());
 
         let prev_text = text.as_str().to_owned();
+        let hint_text_str = hint_text.text().to_owned();
 
         let font_id = font_selection.resolve(ui.style());
-        let row_height = ui.fonts(|f| f.row_height(&font_id));
+        let row_height = ui.fonts_mut(|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() - margin.sum().x).at_least(MIN_WIDTH);
         let desired_width = desired_width.unwrap_or_else(|| ui.spacing().text_edit_width);
@@ -518,19 +515,19 @@ impl TextEdit<'_> {
         };
 
         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 mut default_layouter = move |ui: &Ui, text: &dyn TextBuffer, wrap_width: f32| {
+            let text = mask_if_password(password, text.as_str());
             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))
+            ui.fonts_mut(|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 mut galley = layouter(ui, text, wrap_width);
 
         let desired_inner_width = if clip_text {
             wrap_width // visual clipping with scroll in singleline input.
@@ -576,42 +573,39 @@ impl TextEdit<'_> {
         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);
-                }
+        if interactive && let Some(pointer_pos) = response.interact_pointer_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)
+            // 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 - rect.min + singleline_offset);
+            let cursor_at_pointer =
+                galley.cursor_from_pos(pointer_pos - rect.min + state.text_offset);
 
-                if ui.visuals().text_cursor.preview
-                    && response.hovered()
-                    && ui.input(|i| i.pointer.is_moving())
-                {
-                    // text cursor preview:
-                    let cursor_rect = TSTransform::from_translation(rect.min.to_vec2())
-                        * cursor_rect(&galley, &cursor_at_pointer, row_height);
-                    text_selection::visuals::paint_cursor_end(&painter, ui.visuals(), cursor_rect);
-                }
+            if ui.visuals().text_cursor.preview
+                && response.hovered()
+                && ui.input(|i| i.pointer.is_moving())
+            {
+                // text cursor preview:
+                let cursor_rect = TSTransform::from_translation(rect.min.to_vec2())
+                    * cursor_rect(&galley, &cursor_at_pointer, row_height);
+                text_selection::visuals::paint_cursor_end(&painter, ui.visuals(), cursor_rect);
+            }
 
-                let is_being_dragged = ui.ctx().is_being_dragged(response.id);
-                let did_interact = state.cursor.pointer_interaction(
-                    ui,
-                    &response,
-                    cursor_at_pointer,
-                    &galley,
-                    is_being_dragged,
-                );
+            let is_being_dragged = ui.ctx().is_being_dragged(response.id);
+            let did_interact = state.cursor.pointer_interaction(
+                ui,
+                &response,
+                cursor_at_pointer,
+                &galley,
+                is_being_dragged,
+            );
 
-                if did_interact || response.clicked() {
-                    ui.memory_mut(|mem| mem.request_focus(response.id));
+            if did_interact || response.clicked() {
+                ui.memory_mut(|mem| mem.request_focus(response.id));
 
-                    state.last_interaction_time = ui.ctx().input(|i| i.time);
-                }
+                state.last_interaction_time = ui.ctx().input(|i| i.time);
             }
         }
 
@@ -625,9 +619,9 @@ impl TextEdit<'_> {
             ui.memory_mut(|mem| mem.set_focus_lock_filter(id, event_filter));
 
             let default_cursor_range = if cursor_at_end {
-                CursorRange::one(galley.end())
+                CCursorRange::one(galley.end())
             } else {
-                CursorRange::default()
+                CCursorRange::default()
             };
 
             let (changed, new_cursor_range) = events(
@@ -656,16 +650,16 @@ impl TextEdit<'_> {
             .align_size_within_rect(galley.size(), rect)
             .intersect(rect) // limit pos to the response rect area
             .min;
-        let align_offset = rect.left() - galley_pos.x;
+        let align_offset = rect.left_top() - galley_pos;
 
         // Visual clipping for singleline text editor with text larger than width
-        if clip_text && align_offset == 0.0 {
+        if clip_text && align_offset.x == 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,
+                (Some(cursor_range), true) => galley.pos_from_cursor(cursor_range.primary).min.x,
                 _ => 0.0,
             };
 
-            let mut offset_x = state.singleline_offset;
+            let mut offset_x = state.text_offset.x;
             let visible_range = offset_x..=offset_x + desired_inner_size.x;
 
             if !visible_range.contains(&cursor_pos) {
@@ -680,16 +674,16 @@ impl TextEdit<'_> {
                 .at_most(galley.size().x - desired_inner_size.x)
                 .at_least(0.0);
 
-            state.singleline_offset = offset_x;
+            state.text_offset = vec2(offset_x, align_offset.y);
             galley_pos -= vec2(offset_x, 0.0);
         } else {
-            state.singleline_offset = align_offset;
+            state.text_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()
+            prev_cursor_range != cursor_range
         } else {
             false
         };
@@ -722,69 +716,89 @@ impl TextEdit<'_> {
 
             let has_focus = ui.memory(|mem| mem.has_focus(id));
 
-            if has_focus {
-                if let Some(cursor_range) = state.cursor.range(&galley) {
-                    // Add text selection rectangles to the galley:
-                    paint_text_selection(&mut galley, ui.visuals(), &cursor_range, None);
-                }
+            if has_focus && let Some(cursor_range) = state.cursor.range(&galley) {
+                // Add text selection rectangles to the galley:
+                paint_text_selection(&mut galley, ui.visuals(), &cursor_range, None);
             }
 
-            // Allocate additional space if edits were made this frame that changed the size. This is important so that,
-            // if there's a ScrollArea, it can properly scroll to the cursor.
-            let extra_size = galley.size() - rect.size();
-            if extra_size.x > 0.0 || extra_size.y > 0.0 {
-                ui.allocate_rect(
-                    Rect::from_min_size(outer_rect.max, extra_size),
-                    Sense::hover(),
-                );
+            if !clip_text {
+                // Allocate additional space if edits were made this frame that changed the size. This is important so that,
+                // if there's a ScrollArea, it can properly scroll to the cursor.
+                // Condition `!clip_text` is important to avoid breaking layout for `TextEdit::singleline` (PR #5640)
+                let extra_size = galley.size() - rect.size();
+                if extra_size.x > 0.0 || extra_size.y > 0.0 {
+                    match ui.layout().main_dir() {
+                        crate::Direction::LeftToRight | crate::Direction::TopDown => {
+                            ui.allocate_rect(
+                                Rect::from_min_size(outer_rect.max, extra_size),
+                                Sense::hover(),
+                            );
+                        }
+                        crate::Direction::RightToLeft => {
+                            ui.allocate_rect(
+                                Rect::from_min_size(
+                                    emath::pos2(outer_rect.min.x - extra_size.x, outer_rect.max.y),
+                                    extra_size,
+                                ),
+                                Sense::hover(),
+                            );
+                        }
+                        crate::Direction::BottomUp => {
+                            ui.allocate_rect(
+                                Rect::from_min_size(
+                                    emath::pos2(outer_rect.min.x, outer_rect.max.y - extra_size.y),
+                                    extra_size,
+                                ),
+                                Sense::hover(),
+                            );
+                        }
+                    }
+                }
             }
 
             painter.galley(galley_pos, galley.clone(), text_color);
 
-            if has_focus {
-                if let Some(cursor_range) = state.cursor.range(&galley) {
-                    let primary_cursor_rect =
-                        cursor_rect(&galley, &cursor_range.primary, row_height)
-                            .translate(galley_pos.to_vec2());
+            if has_focus && let Some(cursor_range) = state.cursor.range(&galley) {
+                let primary_cursor_rect = cursor_rect(&galley, &cursor_range.primary, row_height)
+                    .translate(galley_pos.to_vec2());
 
+                if response.changed() || selection_changed {
+                    // Scroll to keep primary cursor in view:
+                    ui.scroll_to_rect(primary_cursor_rect + margin, None);
+                }
+
+                if text.is_mutable() && interactive {
+                    let now = ui.ctx().input(|i| i.time);
                     if response.changed() || selection_changed {
-                        // Scroll to keep primary cursor in view:
-                        ui.scroll_to_rect(primary_cursor_rect + margin, None);
+                        state.last_interaction_time = now;
                     }
 
-                    if text.is_mutable() && interactive {
-                        let now = ui.ctx().input(|i| i.time);
-                        if response.changed() || selection_changed {
-                            state.last_interaction_time = now;
-                        }
+                    // Only show (and blink) cursor if the egui viewport has focus.
+                    // This is for two reasons:
+                    // * Don't give the impression that the user can type into a window without focus
+                    // * Don't repaint the ui because of a blinking cursor in an app that is not in focus
+                    let viewport_has_focus = ui.ctx().input(|i| i.focused);
+                    if viewport_has_focus {
+                        text_selection::visuals::paint_text_cursor(
+                            ui,
+                            &painter,
+                            primary_cursor_rect,
+                            now - state.last_interaction_time,
+                        );
+                    }
 
-                        // Only show (and blink) cursor if the egui viewport has focus.
-                        // This is for two reasons:
-                        // * Don't give the impression that the user can type into a window without focus
-                        // * Don't repaint the ui because of a blinking cursor in an app that is not in focus
-                        let viewport_has_focus = ui.ctx().input(|i| i.focused);
-                        if viewport_has_focus {
-                            text_selection::visuals::paint_text_cursor(
-                                ui,
-                                &painter,
-                                primary_cursor_rect,
-                                now - state.last_interaction_time,
-                            );
-                        }
+                    // Set IME output (in screen coords) when text is editable and visible
+                    let to_global = ui
+                        .ctx()
+                        .layer_transform_to_global(ui.layer_id())
+                        .unwrap_or_default();
 
-                        // Set IME output (in screen coords) when text is editable and visible
-                        let to_global = ui
-                            .ctx()
-                            .layer_transform_to_global(ui.layer_id())
-                            .unwrap_or_default();
-
-                        ui.ctx().output_mut(|o| {
-                            o.ime = Some(crate::output::IMEOutput {
-                                rect: to_global * rect,
-                                cursor_rect: to_global * primary_cursor_rect,
-                            });
+                    ui.ctx().output_mut(|o| {
+                        o.ime = Some(crate::output::IMEOutput {
+                            rect: to_global * rect,
+                            cursor_rect: to_global * primary_cursor_rect,
                         });
-                    }
+                    });
                 }
             }
         }
@@ -807,12 +821,12 @@ impl TextEdit<'_> {
                     ui.is_enabled(),
                     mask_if_password(password, prev_text.as_str()),
                     mask_if_password(password, text.as_str()),
+                    hint_text_str.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 char_range = cursor_range.primary.index..=cursor_range.secondary.index;
             let info = WidgetInfo::text_selection_changed(
                 ui.is_enabled(),
                 char_range,
@@ -825,11 +839,11 @@ impl TextEdit<'_> {
                     ui.is_enabled(),
                     mask_if_password(password, prev_text.as_str()),
                     mask_if_password(password, text.as_str()),
+                    hint_text_str.as_str(),
                 )
             });
         }
 
-        #[cfg(feature = "accesskit")]
         {
             let role = if password {
                 accesskit::Role::PasswordInput
@@ -862,9 +876,11 @@ impl TextEdit<'_> {
 
 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>()
+        std::iter::repeat_n(
+            epaint::text::PASSWORD_REPLACEMENT_CHAR,
+            text.chars().count(),
+        )
+        .collect::<String>()
     }
 
     if is_password {
@@ -877,22 +893,22 @@ fn mask_if_password(is_password: bool, text: &str) -> String {
 // ----------------------------------------------------------------------------
 
 /// Check for (keyboard) events to edit the cursor and/or text.
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn events(
     ui: &crate::Ui,
     state: &mut TextEditState,
     text: &mut dyn TextBuffer,
     galley: &mut Arc<Galley>,
-    layouter: &mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>,
+    layouter: &mut dyn FnMut(&Ui, &dyn TextBuffer, f32) -> Arc<Galley>,
     id: Id,
     wrap_width: f32,
     multiline: bool,
     password: bool,
-    default_cursor_range: CursorRange,
+    default_cursor_range: CCursorRange,
     char_limit: usize,
     event_filter: EventFilter,
     return_key: Option<KeyboardShortcut>,
-) -> (bool, CursorRange) {
+) -> (bool, CCursorRange) {
     let os = ui.ctx().os();
 
     let mut cursor_range = state.cursor.range(galley).unwrap_or(default_cursor_range);
@@ -901,7 +917,7 @@ fn events(
     // 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()),
+        &(cursor_range, text.as_str().to_owned()),
     );
 
     let copy_if_not_password = |ui: &Ui, text: String| {
@@ -926,12 +942,10 @@ fn events(
             event if cursor_range.on_event(os, event, galley, id) => None,
 
             Event::Copy => {
-                if cursor_range.is_empty() {
-                    None
-                } else {
+                if !cursor_range.is_empty() {
                     copy_if_not_password(ui, cursor_range.slice_str(text.as_str()).to_owned());
-                    None
                 }
+                None
             }
             Event::Cut => {
                 if cursor_range.is_empty() {
@@ -944,8 +958,12 @@ fn events(
             Event::Paste(text_to_insert) => {
                 if !text_to_insert.is_empty() {
                     let mut ccursor = text.delete_selected(&cursor_range);
-
-                    text.insert_text_at(&mut ccursor, text_to_insert, char_limit);
+                    if multiline {
+                        text.insert_text_at(&mut ccursor, text_to_insert, char_limit);
+                    } else {
+                        let single_line = text_to_insert.replace(['\r', '\n'], " ");
+                        text.insert_text_at(&mut ccursor, &single_line, char_limit);
+                    }
 
                     Some(CCursorRange::one(ccursor))
                 } else {
@@ -1011,7 +1029,7 @@ fn events(
                 if let Some((redo_ccursor_range, redo_txt)) = state
                     .undoer
                     .lock()
-                    .redo(&(cursor_range.as_ccursor_range(), text.as_str().to_owned()))
+                    .redo(&(cursor_range, text.as_str().to_owned()))
                 {
                     text.replace_with(redo_txt);
                     Some(*redo_ccursor_range)
@@ -1029,7 +1047,7 @@ fn events(
                 if let Some((undo_ccursor_range, undo_txt)) = state
                     .undoer
                     .lock()
-                    .undo(&(cursor_range.as_ccursor_range(), text.as_str().to_owned()))
+                    .undo(&(cursor_range, text.as_str().to_owned()))
                 {
                     text.replace_with(undo_txt);
                     Some(*undo_ccursor_range)
@@ -1073,14 +1091,14 @@ fn events(
                         state.ime_enabled = false;
 
                         if !prediction.is_empty()
-                            && cursor_range.secondary.ccursor.index
-                                == state.ime_cursor_range.secondary.ccursor.index
+                            && cursor_range.secondary.index
+                                == state.ime_cursor_range.secondary.index
                         {
                             let mut ccursor = text.delete_selected(&cursor_range);
                             text.insert_text_at(&mut ccursor, prediction, char_limit);
                             Some(CCursorRange::one(ccursor))
                         } else {
-                            let ccursor = cursor_range.primary.ccursor;
+                            let ccursor = cursor_range.primary;
                             Some(CCursorRange::one(ccursor))
                         }
                     }
@@ -1098,21 +1116,18 @@ fn events(
             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);
+            *galley = layouter(ui, text, 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),
-            };
+            cursor_range = new_ccursor_range;
         }
     }
 
-    state.cursor.set_range(Some(cursor_range));
+    state.cursor.set_char_range(Some(cursor_range));
 
     state.undoer.lock().feed_state(
         ui.input(|i| i.time),
-        &(cursor_range.as_ccursor_range(), text.as_str().to_owned()),
+        &(cursor_range, text.as_str().to_owned()),
     );
 
     (any_change, cursor_range)
@@ -1144,7 +1159,7 @@ fn remove_ime_incompatible_events(events: &mut Vec<Event>) {
 /// Returns `Some(new_cursor)` if we did mutate `text`.
 fn check_for_mutating_key_press(
     os: OperatingSystem,
-    cursor_range: &CursorRange,
+    cursor_range: &CCursorRange,
     text: &mut dyn TextBuffer,
     galley: &Galley,
     modifiers: &Modifiers,
@@ -1157,9 +1172,9 @@ fn check_for_mutating_key_press(
             } else if let Some(cursor) = cursor_range.single() {
                 if modifiers.alt || modifiers.ctrl {
                     // alt on mac, ctrl on windows
-                    text.delete_previous_word(cursor.ccursor)
+                    text.delete_previous_word(cursor)
                 } else {
-                    text.delete_previous_char(cursor.ccursor)
+                    text.delete_previous_char(cursor)
                 }
             } else {
                 text.delete_selected(cursor_range)
@@ -1173,9 +1188,9 @@ fn check_for_mutating_key_press(
             } else if let Some(cursor) = cursor_range.single() {
                 if modifiers.alt || modifiers.ctrl {
                     // alt on mac, ctrl on windows
-                    text.delete_next_word(cursor.ccursor)
+                    text.delete_next_word(cursor)
                 } else {
-                    text.delete_next_char(cursor.ccursor)
+                    text.delete_next_char(cursor)
                 }
             } else {
                 text.delete_selected(cursor_range)
@@ -1188,7 +1203,7 @@ fn check_for_mutating_key_press(
         }
 
         Key::H if modifiers.ctrl => {
-            let ccursor = text.delete_previous_char(cursor_range.primary.ccursor);
+            let ccursor = text.delete_previous_char(cursor_range.primary);
             Some(CCursorRange::one(ccursor))
         }
 
@@ -1204,7 +1219,7 @@ fn check_for_mutating_key_press(
 
         Key::W if modifiers.ctrl => {
             let ccursor = if let Some(cursor) = cursor_range.single() {
-                text.delete_previous_word(cursor.ccursor)
+                text.delete_previous_word(cursor)
             } else {
                 text.delete_selected(cursor_range)
             };
diff --git a/crates/egui/src/widgets/text_edit/output.rs b/crates/egui/src/widgets/text_edit/output.rs
index d02c1d1c5..8149bbe58 100644
--- a/crates/egui/src/widgets/text_edit/output.rs
+++ b/crates/egui/src/widgets/text_edit/output.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::text::CursorRange;
+use crate::text::CCursorRange;
 
 /// The output from a [`TextEdit`](crate::TextEdit).
 pub struct TextEditOutput {
@@ -20,14 +20,7 @@ pub struct TextEditOutput {
     pub state: super::TextEditState,
 
     /// Where the text cursor is.
-    pub cursor_range: Option<CursorRange>,
-}
-
-impl TextEditOutput {
-    #[deprecated = "Renamed `self.galley_pos`"]
-    pub fn text_draw_pos(&self) -> crate::Pos2 {
-        self.galley_pos
-    }
+    pub cursor_range: Option<CCursorRange>,
 }
 
 // TODO(emilk): add `output.paint` and `output.store` and split out that code from `TextEdit::show`.
diff --git a/crates/egui/src/widgets/text_edit/state.rs b/crates/egui/src/widgets/text_edit/state.rs
index c10a88274..5827aac4b 100644
--- a/crates/egui/src/widgets/text_edit/state.rs
+++ b/crates/egui/src/widgets/text_edit/state.rs
@@ -3,8 +3,8 @@ use std::sync::Arc;
 use crate::mutex::Mutex;
 
 use crate::{
-    text_selection::{CCursorRange, CursorRange, TextCursorState},
-    Context, Galley, Id,
+    Context, Id, Vec2,
+    text_selection::{CCursorRange, TextCursorState},
 };
 
 pub type TextEditUndoer = crate::util::undoer::Undoer<(CCursorRange, String)>;
@@ -47,11 +47,12 @@ pub struct TextEditState {
 
     // cursor range for IME candidate.
     #[cfg_attr(feature = "serde", serde(skip))]
-    pub(crate) ime_cursor_range: CursorRange,
+    pub(crate) ime_cursor_range: CCursorRange,
 
-    // Visual offset when editing singleline text bigger than the width.
+    // Text offset within the widget area.
+    // Used for sensing and singleline text clipping.
     #[cfg_attr(feature = "serde", serde(skip))]
-    pub(crate) singleline_offset: f32,
+    pub(crate) text_offset: Vec2,
 
     /// When did the user last press a key or click on the `TextEdit`.
     /// Used to pause the cursor animation when typing.
@@ -68,28 +69,11 @@ impl TextEditState {
         ctx.data_mut(|d| d.insert_persisted(id, self));
     }
 
-    /// The currently selected range of characters.
-    #[deprecated = "Use `self.cursor.char_range` instead"]
-    pub fn ccursor_range(&self) -> Option<CCursorRange> {
-        self.cursor.char_range()
-    }
-
-    /// Sets the currently selected range of characters.
-    #[deprecated = "Use `self.cursor.set_char_range` instead"]
-    pub fn set_ccursor_range(&mut self, ccursor_range: Option<CCursorRange>) {
-        self.cursor.set_char_range(ccursor_range);
-    }
-
-    #[deprecated = "Use `self.cursor.set_range` instead"]
-    pub fn set_cursor_range(&mut self, cursor_range: Option<CursorRange>) {
-        self.cursor.set_range(cursor_range);
-    }
-
     pub fn undoer(&self) -> TextEditUndoer {
         self.undoer.lock().clone()
     }
 
-    #[allow(clippy::needless_pass_by_ref_mut)] // Intentionally hide interiority of mutability
+    #[expect(clippy::needless_pass_by_ref_mut)] // Intentionally hide interiority of mutability
     pub fn set_undoer(&mut self, undoer: TextEditUndoer) {
         *self.undoer.lock() = undoer;
     }
@@ -97,9 +81,4 @@ impl TextEditState {
     pub fn clear_undoer(&mut self) {
         self.set_undoer(TextEditUndoer::default());
     }
-
-    #[deprecated = "Use `self.cursor.range` instead"]
-    pub fn cursor_range(&self, galley: &Galley) -> Option<CursorRange> {
-        self.cursor.range(galley)
-    }
 }
diff --git a/crates/egui/src/widgets/text_edit/text_buffer.rs b/crates/egui/src/widgets/text_edit/text_buffer.rs
index 31b746324..a67dc1b38 100644
--- a/crates/egui/src/widgets/text_edit/text_buffer.rs
+++ b/crates/egui/src/widgets/text_edit/text_buffer.rs
@@ -1,19 +1,16 @@
 use std::{borrow::Cow, ops::Range};
 
 use epaint::{
-    text::{
-        cursor::{CCursor, PCursor},
-        TAB_SIZE,
-    },
     Galley,
+    text::{TAB_SIZE, cursor::CCursor},
 };
 
-use crate::text_selection::{
-    text_cursor_state::{
-        byte_index_from_char_index, ccursor_next_word, ccursor_previous_word, find_line_start,
-        slice_char_range,
+use crate::{
+    text::CCursorRange,
+    text_selection::text_cursor_state::{
+        byte_index_from_char_index, ccursor_next_word, ccursor_previous_word,
+        char_index_from_byte_index, find_line_start, slice_char_range,
     },
-    CursorRange,
 };
 
 /// Trait constraining what types [`crate::TextEdit`] may use as
@@ -51,6 +48,10 @@ pub trait TextBuffer {
         byte_index_from_char_index(self.as_str(), char_index)
     }
 
+    fn char_index_from_byte_index(&self, char_index: usize) -> usize {
+        char_index_from_byte_index(self.as_str(), char_index)
+    }
+
     /// Clears all characters in this buffer
     fn clear(&mut self) {
         self.delete_char_range(0..self.as_str().len());
@@ -111,9 +112,9 @@ pub trait TextBuffer {
         }
     }
 
-    fn delete_selected(&mut self, cursor_range: &CursorRange) -> CCursor {
+    fn delete_selected(&mut self, cursor_range: &CCursorRange) -> CCursor {
         let [min, max] = cursor_range.sorted_cursors();
-        self.delete_selected_ccursor_range([min.ccursor, max.ccursor])
+        self.delete_selected_ccursor_range([min, max])
     }
 
     fn delete_selected_ccursor_range(&mut self, [min, max]: [CCursor; 2]) -> CCursor {
@@ -151,38 +152,63 @@ pub trait TextBuffer {
     fn delete_paragraph_before_cursor(
         &mut self,
         galley: &Galley,
-        cursor_range: &CursorRange,
+        cursor_range: &CCursorRange,
     ) -> 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 {
-            self.delete_previous_char(min.ccursor)
+        let min = galley.cursor_begin_of_paragraph(&min);
+        if min == max {
+            self.delete_previous_char(min)
         } else {
-            self.delete_selected(&CursorRange::two(min, max))
+            self.delete_selected(&CCursorRange::two(min, max))
         }
     }
 
     fn delete_paragraph_after_cursor(
         &mut self,
         galley: &Galley,
-        cursor_range: &CursorRange,
+        cursor_range: &CCursorRange,
     ) -> 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 {
-            self.delete_next_char(min.ccursor)
+        let max = galley.cursor_end_of_paragraph(&max);
+        if min == max {
+            self.delete_next_char(min)
         } else {
-            self.delete_selected(&CursorRange::two(min, max))
+            self.delete_selected(&CCursorRange::two(min, max))
         }
     }
+
+    /// Returns a unique identifier for the implementing type.
+    ///
+    /// This is useful for downcasting from this trait to the implementing type.
+    /// Here is an example usage:
+    /// ```
+    /// use egui::TextBuffer;
+    /// use std::any::TypeId;
+    ///
+    /// struct ExampleBuffer {}
+    ///
+    /// impl TextBuffer for ExampleBuffer {
+    ///     fn is_mutable(&self) -> bool { unimplemented!() }
+    ///     fn as_str(&self) -> &str { unimplemented!() }
+    ///     fn insert_text(&mut self, text: &str, char_index: usize) -> usize { unimplemented!() }
+    ///     fn delete_char_range(&mut self, char_range: std::ops::Range<usize>) { unimplemented!() }
+    ///
+    ///     // Implement it like the following:
+    ///     fn type_id(&self) -> TypeId {
+    ///         TypeId::of::<Self>()
+    ///     }
+    /// }
+    ///
+    /// // Example downcast:
+    /// pub fn downcast_example(buffer: &dyn TextBuffer) -> Option<&ExampleBuffer> {
+    ///     if buffer.type_id() == TypeId::of::<ExampleBuffer>() {
+    ///         unsafe { Some(&*(buffer as *const dyn TextBuffer as *const ExampleBuffer)) }
+    ///     } else {
+    ///         None
+    ///     }
+    /// }
+    /// ```
+    fn type_id(&self) -> std::any::TypeId;
 }
 
 impl TextBuffer for String {
@@ -205,7 +231,10 @@ impl TextBuffer for String {
     }
 
     fn delete_char_range(&mut self, char_range: Range<usize>) {
-        assert!(char_range.start <= char_range.end);
+        assert!(
+            char_range.start <= char_range.end,
+            "start must be <= end, but got {char_range:?}"
+        );
 
         // Get both byte indices
         let byte_start = byte_index_from_char_index(self.as_str(), char_range.start);
@@ -226,6 +255,10 @@ impl TextBuffer for String {
     fn take(&mut self) -> String {
         std::mem::take(self)
     }
+
+    fn type_id(&self) -> std::any::TypeId {
+        std::any::TypeId::of::<Self>()
+    }
 }
 
 impl TextBuffer for Cow<'_, str> {
@@ -256,6 +289,10 @@ impl TextBuffer for Cow<'_, str> {
     fn take(&mut self) -> String {
         std::mem::take(self).into_owned()
     }
+
+    fn type_id(&self) -> std::any::TypeId {
+        std::any::TypeId::of::<Cow<'_, str>>()
+    }
 }
 
 /// Immutable view of a `&str`!
@@ -273,4 +310,8 @@ impl TextBuffer for &str {
     }
 
     fn delete_char_range(&mut self, _ch_range: Range<usize>) {}
+
+    fn type_id(&self) -> std::any::TypeId {
+        std::any::TypeId::of::<&str>()
+    }
 }
diff --git a/crates/egui_demo_app/Cargo.toml b/crates/egui_demo_app/Cargo.toml
index 6ed74efab..7cde46383 100644
--- a/crates/egui_demo_app/Cargo.toml
+++ b/crates/egui_demo_app/Cargo.toml
@@ -23,19 +23,15 @@ crate-type = ["cdylib", "rlib"]
 
 
 [features]
-default = ["glow", "persistence"]
+default = ["wgpu", "persistence"]
 
 # image_viewer adds about 0.9 MB of WASM
 web_app = ["http", "persistence"]
 
+accessibility_inspector = ["dep:accesskit", "dep:accesskit_consumer", "eframe/accesskit"]
 http = ["ehttp", "image/jpeg", "poll-promise", "egui_extras/image"]
 image_viewer = ["image/jpeg", "egui_extras/all_loaders", "rfd"]
-persistence = [
-  "eframe/persistence",
-  "egui_extras/serde",
-  "egui/persistence",
-  "serde",
-]
+persistence = ["eframe/persistence", "egui_extras/serde", "egui/persistence", "serde"]
 puffin = ["dep:puffin", "dep:puffin_http", "profiling/profile-with-puffin"]
 serde = ["dep:serde", "egui_demo_lib/serde", "egui/serde"]
 syntect = ["egui_demo_lib/syntect"]
@@ -46,14 +42,9 @@ wayland = ["eframe/wayland"]
 x11 = ["eframe/x11"]
 
 [dependencies]
-chrono = { version = "0.4", default-features = false, features = [
-  "js-sys",
-  "wasmbind",
-] }
-eframe = { workspace = true, default-features = false, features = [
-  "web_screen_reader",
-] }
-egui = { workspace = true, features = ["callstack", "default", "log"] }
+chrono = { workspace = true, features = ["js-sys", "wasmbind"] }
+eframe = { workspace = true, default-features = false, features = ["web_screen_reader"] }
+egui = { workspace = true, features = ["callstack", "default"] }
 egui_demo_lib = { workspace = true, features = ["default", "chrono"] }
 egui_extras = { workspace = true, features = ["default", "image"] }
 image = { workspace = true, default-features = false, features = [
@@ -64,17 +55,19 @@ log.workspace = true
 profiling.workspace = true
 
 # Optional dependencies:
-
+accesskit = { workspace = true, optional = true }
+accesskit_consumer = { workspace = true, optional = true }
 bytemuck = { workspace = true, optional = true }
 puffin = { workspace = true, optional = true }
 puffin_http = { workspace = true, optional = true }
 # Enable both WebGL & WebGPU when targeting the web (these features have no effect when not targeting wasm32)
-wgpu = { workspace = true, features = ["webgpu", "webgl"], optional = true }
+# Also enable the default features so we have a supported backend for every platform.
+wgpu = { workspace = true, features = ["default", "webgpu", "webgl"], optional = true }
 
 
 # feature "http":
-ehttp = { version = "0.5", optional = true }
-poll-promise = { version = "0.3", optional = true, default-features = false }
+ehttp = { workspace = true, optional = true }
+poll-promise = { workspace = true, optional = true }
 
 # feature "persistence":
 serde = { workspace = true, optional = true }
@@ -82,17 +75,15 @@ serde = { workspace = true, optional = true }
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-env_logger = { version = "0.10", default-features = false, features = [
-  "auto-color",
-  "humantime",
-] }
-rfd = { version = "0.15", optional = true }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
+mimalloc.workspace = true
+rfd = { workspace = true, optional = true }
 
 # web:
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-wasm-bindgen = "=0.2.97"
+wasm-bindgen.workspace = true
 wasm-bindgen-futures.workspace = true
 web-sys.workspace = true
 
 [dev-dependencies]
-egui_kittest = { workspace = true, features = ["eframe", "snapshot", "wgpu"] }
\ No newline at end of file
+egui_kittest = { workspace = true, features = ["eframe", "snapshot", "wgpu"] }
diff --git a/crates/egui_demo_app/README.md b/crates/egui_demo_app/README.md
index 8182b4811..de273206f 100644
--- a/crates/egui_demo_app/README.md
+++ b/crates/egui_demo_app/README.md
@@ -1,5 +1,5 @@
 # egui demo app
-This app demonstrates [`egui`](https://github.com/emilk/egui/) and [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
+This app demonstrates [`egui`](https://github.com/emilk/egui/) and [`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe).
 
 View the demo app online at <https://egui.rs>.
 
@@ -12,7 +12,7 @@ Run it locally with `cargo run --release -p egui_demo_app`.
 ./scripts/build_demo_web.sh --open
 ```
 
-`egui_demo_app` uses [`egui_demo_lib`](https://github.com/emilk/egui/tree/master/crates/egui_demo_lib).
+`egui_demo_app` uses [`egui_demo_lib`](https://github.com/emilk/egui/tree/main/crates/egui_demo_lib).
 
 
 ## Running with `wgpu` backend
diff --git a/crates/egui_demo_app/src/accessibility_inspector.rs b/crates/egui_demo_app/src/accessibility_inspector.rs
new file mode 100644
index 000000000..f721b710c
--- /dev/null
+++ b/crates/egui_demo_app/src/accessibility_inspector.rs
@@ -0,0 +1,253 @@
+use accesskit::{Action, ActionRequest, NodeId};
+use accesskit_consumer::{FilterResult, Node, Tree, TreeChangeHandler};
+use eframe::epaint::text::TextWrapMode;
+use egui::collapsing_header::CollapsingState;
+use egui::{
+    Button, Color32, Context, Event, Frame, FullOutput, Id, Key, KeyboardShortcut, Label,
+    Modifiers, RawInput, RichText, ScrollArea, SidePanel, TopBottomPanel, Ui,
+};
+use std::mem;
+
+/// This [`egui::Plugin`] adds an inspector Panel.
+///
+/// It can be opened with the `(Cmd/Ctrl)+Alt+I`. It shows the current AccessKit tree and details
+/// for the selected node.
+/// Useful when debugging accessibility issues or trying to understand the structure of the Ui.
+///
+/// Add via
+/// ```
+/// # use egui_demo_app::accessibility_inspector::AccessibilityInspectorPlugin;
+/// # let ctx = egui::Context::default();
+/// ctx.add_plugin(AccessibilityInspectorPlugin::default());
+/// ```
+#[derive(Default, Debug)]
+pub struct AccessibilityInspectorPlugin {
+    pub open: bool,
+    tree: Option<accesskit_consumer::Tree>,
+    selected_node: Option<Id>,
+    queued_action: Option<ActionRequest>,
+}
+
+struct ChangeHandler;
+
+impl TreeChangeHandler for ChangeHandler {
+    fn node_added(&mut self, _node: &Node<'_>) {}
+
+    fn node_updated(&mut self, _old_node: &Node<'_>, _new_node: &Node<'_>) {}
+
+    fn focus_moved(&mut self, _old_node: Option<&Node<'_>>, _new_node: Option<&Node<'_>>) {}
+
+    fn node_removed(&mut self, _node: &Node<'_>) {}
+}
+
+impl egui::Plugin for AccessibilityInspectorPlugin {
+    fn debug_name(&self) -> &'static str {
+        "Accessibility Inspector"
+    }
+
+    fn input_hook(&mut self, input: &mut RawInput) {
+        if let Some(queued_action) = self.queued_action.take() {
+            input
+                .events
+                .push(Event::AccessKitActionRequest(queued_action));
+        }
+    }
+
+    fn output_hook(&mut self, output: &mut FullOutput) {
+        if let Some(update) = output.platform_output.accesskit_update.clone() {
+            self.tree = match mem::take(&mut self.tree) {
+                None => {
+                    // Create a new tree if it doesn't exist
+                    Some(Tree::new(update, true))
+                }
+                Some(mut tree) => {
+                    // Update the tree with the latest accesskit data
+                    tree.update_and_process_changes(update, &mut ChangeHandler);
+
+                    Some(tree)
+                }
+            }
+        }
+    }
+
+    fn on_begin_pass(&mut self, ctx: &Context) {
+        if ctx.input_mut(|i| {
+            i.consume_shortcut(&KeyboardShortcut::new(
+                Modifiers::COMMAND | Modifiers::ALT,
+                Key::I,
+            ))
+        }) {
+            self.open = !self.open;
+        }
+
+        if !self.open {
+            return;
+        }
+
+        ctx.enable_accesskit();
+
+        SidePanel::right(Self::id()).show(ctx, |ui| {
+            ui.heading("🔎 AccessKit Inspector");
+            if let Some(selected_node) = self.selected_node {
+                TopBottomPanel::bottom(Self::id().with("details_panel"))
+                    .frame(Frame::new())
+                    .show_separator_line(false)
+                    .show_inside(ui, |ui| {
+                        self.selection_ui(ui, selected_node);
+                    });
+            }
+
+            ui.style_mut().wrap_mode = Some(TextWrapMode::Truncate);
+            ScrollArea::vertical().show(ui, |ui| {
+                if let Some(tree) = &self.tree {
+                    Self::node_ui(ui, &tree.state().root(), &mut self.selected_node);
+                }
+            });
+        });
+    }
+}
+
+impl AccessibilityInspectorPlugin {
+    fn id() -> Id {
+        Id::new("Accessibility Inspector")
+    }
+
+    fn selection_ui(&mut self, ui: &mut Ui, selected_node: Id) {
+        ui.separator();
+
+        if let Some(tree) = &self.tree
+            && let Some(node) = tree.state().node_by_id(NodeId::from(selected_node.value()))
+        {
+            let node_response = ui.ctx().read_response(selected_node);
+
+            if let Some(widget_response) = node_response {
+                ui.ctx().debug_painter().debug_rect(
+                    widget_response.rect,
+                    ui.style_mut().visuals.selection.bg_fill,
+                    "",
+                );
+            }
+
+            egui::Grid::new("node_details_grid")
+                .num_columns(2)
+                .show(ui, |ui| {
+                    ui.label("Node ID");
+                    ui.strong(format!("{selected_node:?}"));
+                    ui.end_row();
+
+                    ui.label("Role");
+                    ui.strong(format!("{:?}", node.role()));
+                    ui.end_row();
+
+                    ui.label("Label");
+                    ui.add(
+                        Label::new(RichText::new(node.label().unwrap_or_default()).strong())
+                            .truncate(),
+                    );
+                    ui.end_row();
+
+                    ui.label("Value");
+                    ui.add(
+                        Label::new(RichText::new(node.value().unwrap_or_default()).strong())
+                            .truncate(),
+                    );
+                    ui.end_row();
+
+                    ui.label("Children");
+                    ui.label(RichText::new(node.children().len().to_string()).strong());
+
+                    ui.end_row();
+                });
+
+            ui.label("Actions");
+            ui.horizontal_wrapped(|ui| {
+                // Iterate through all possible actions via the `Action::n` helper.
+                let mut current_action = 0;
+                let all_actions = std::iter::from_fn(|| {
+                    let action = Action::n(current_action);
+                    current_action += 1;
+                    action
+                });
+
+                for action in all_actions {
+                    if node.supports_action(action, &|_node| FilterResult::Include)
+                        && ui.button(format!("{action:?}")).clicked()
+                    {
+                        let action_request = ActionRequest {
+                            target: node.id(),
+                            action,
+                            data: None,
+                        };
+                        self.queued_action = Some(action_request);
+                    }
+                }
+            });
+        } else {
+            ui.label("Node not found");
+        }
+    }
+
+    fn node_ui(ui: &mut Ui, node: &Node<'_>, selected_node: &mut Option<Id>) {
+        if node.id() == Self::id().value().into()
+            || node
+                .value()
+                .as_deref()
+                .is_some_and(|l| l.contains("AccessKit Inspector"))
+        {
+            return;
+        }
+        let label = node
+            .label()
+            .or(node.value())
+            .unwrap_or(node.id().0.to_string());
+        let label = format!("({:?}) {}", node.role(), label);
+
+        // Safety: This is safe since the `accesskit::NodeId` was created from an `egui::Id`.
+        #[expect(unsafe_code)]
+        let egui_node_id = unsafe { Id::from_high_entropy_bits(node.id().0) };
+
+        ui.push_id(node.id(), |ui| {
+            let child_count = node.children().len();
+            let has_children = child_count > 0;
+            let default_open = child_count == 1 && node.role() != accesskit::Role::Label;
+
+            let mut collapsing = CollapsingState::load_with_default_open(
+                ui.ctx(),
+                egui_node_id.with("ak_collapse"),
+                default_open,
+            );
+
+            let header_response = ui.horizontal(|ui| {
+                let text = if collapsing.is_open() { "⏷" } else { "⏵" };
+
+                if ui
+                    .add_visible(has_children, Button::new(text).frame_when_inactive(false))
+                    .clicked()
+                {
+                    collapsing.set_open(!collapsing.is_open());
+                }
+                let label_response =
+                    ui.selectable_value(selected_node, Some(egui_node_id), label.clone());
+                if label_response.hovered() {
+                    let widget_response = ui.ctx().read_response(egui_node_id);
+
+                    if let Some(widget_response) = widget_response {
+                        ui.ctx()
+                            .debug_painter()
+                            .debug_rect(widget_response.rect, Color32::RED, "");
+                    }
+                }
+            });
+
+            if has_children {
+                collapsing.show_body_indented(&header_response.response, ui, |ui| {
+                    node.children().for_each(|c| {
+                        Self::node_ui(ui, &c, selected_node);
+                    });
+                });
+            }
+
+            collapsing.store(ui.ctx());
+        });
+    }
+}
diff --git a/crates/egui_demo_app/src/apps/custom3d_glow.rs b/crates/egui_demo_app/src/apps/custom3d_glow.rs
index ad6bfc3bc..803f6156f 100644
--- a/crates/egui_demo_app/src/apps/custom3d_glow.rs
+++ b/crates/egui_demo_app/src/apps/custom3d_glow.rs
@@ -80,7 +80,7 @@ struct RotatingTriangle {
     vertex_array: glow::VertexArray,
 }
 
-#[allow(unsafe_code)] // we need unsafe code to use glow
+#[expect(unsafe_code)] // we need unsafe code to use glow
 impl RotatingTriangle {
     fn new(gl: &glow::Context) -> Option<Self> {
         use glow::HasContext as _;
@@ -91,10 +91,7 @@ impl RotatingTriangle {
             let program = gl.create_program().expect("Cannot create program");
 
             if !shader_version.is_new_shader_interface() {
-                log::warn!(
-                    "Custom 3D painting hasn't been ported to {:?}",
-                    shader_version
-                );
+                log::warn!("Custom 3D painting hasn't been ported to {shader_version:?}");
                 return None;
             }
 
diff --git a/crates/egui_demo_app/src/apps/custom3d_wgpu.rs b/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
index 2e3a34f7d..d3b10d480 100644
--- a/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
+++ b/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
@@ -1,7 +1,7 @@
 use std::num::NonZeroU64;
 
 use eframe::{
-    egui_wgpu::wgpu::util::DeviceExt,
+    egui_wgpu::wgpu::util::DeviceExt as _,
     egui_wgpu::{self, wgpu},
 };
 
diff --git a/crates/egui_demo_app/src/apps/fractal_clock.rs b/crates/egui_demo_app/src/apps/fractal_clock.rs
index 3eeddd7be..52a7f25b2 100644
--- a/crates/egui_demo_app/src/apps/fractal_clock.rs
+++ b/crates/egui_demo_app/src/apps/fractal_clock.rs
@@ -1,8 +1,8 @@
 use egui::{
+    Color32, Painter, Pos2, Rect, Shape, Stroke, Ui, Vec2,
     containers::{CollapsingHeader, Frame},
     emath, pos2,
     widgets::Slider,
-    Color32, Painter, Pos2, Rect, Shape, Stroke, Ui, Vec2,
 };
 use std::f32::consts::TAU;
 
@@ -73,7 +73,7 @@ impl FractalClock {
             ));
         } 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");
diff --git a/crates/egui_demo_app/src/apps/http_app.rs b/crates/egui_demo_app/src/apps/http_app.rs
index 2ea560268..2630fa862 100644
--- a/crates/egui_demo_app/src/apps/http_app.rs
+++ b/crates/egui_demo_app/src/apps/http_app.rs
@@ -53,7 +53,7 @@ pub struct HttpApp {
 impl Default for HttpApp {
     fn default() -> Self {
         Self {
-            url: "https://raw.githubusercontent.com/emilk/egui/master/README.md".to_owned(),
+            url: "https://raw.githubusercontent.com/emilk/egui/main/README.md".to_owned(),
             promise: Default::default(),
         }
     }
@@ -133,7 +133,7 @@ fn ui_url(ui: &mut egui::Ui, frame: &eframe::Frame, url: &mut String) -> bool {
     ui.horizontal(|ui| {
         if ui.button("Source code for this example").clicked() {
             *url = format!(
-                "https://raw.githubusercontent.com/emilk/egui/master/{}",
+                "https://raw.githubusercontent.com/emilk/egui/main/{}",
                 file!()
             );
             trigger_fetch = true;
@@ -238,7 +238,7 @@ impl ColoredText {
     pub fn ui(&self, ui: &mut egui::Ui) {
         let mut job = self.0.clone();
         job.wrap.max_width = ui.available_width();
-        let galley = ui.fonts(|f| f.layout_job(job));
+        let galley = ui.fonts_mut(|f| f.layout_job(job));
         ui.add(egui::Label::new(galley).selectable(true));
     }
 }
diff --git a/crates/egui_demo_app/src/apps/image_viewer.rs b/crates/egui_demo_app/src/apps/image_viewer.rs
index c75e8c686..c341d2385 100644
--- a/crates/egui_demo_app/src/apps/image_viewer.rs
+++ b/crates/egui_demo_app/src/apps/image_viewer.rs
@@ -1,10 +1,9 @@
-use egui::emath::Rot2;
-use egui::panel::HorizontalSide;
-use egui::panel::PanelSide;
-use egui::panel::VerticalSide;
 use egui::ImageFit;
 use egui::Slider;
 use egui::Vec2;
+use egui::emath::Rot2;
+use egui::panel::Side;
+use egui::panel::TopBottomSide;
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct ImageViewer {
@@ -53,31 +52,28 @@ impl Default for ImageViewer {
 
 impl eframe::App for ImageViewer {
     fn update(&mut self, ctx: &egui::Context, _: &mut eframe::Frame) {
-        egui::Panel::new(PanelSide::Horizontal(HorizontalSide::Top), "url bar").show(
-            ctx,
-            |ui| {
-                ui.horizontal_centered(|ui| {
-                    let label = ui.label("URI:");
-                    ui.text_edit_singleline(&mut self.uri_edit_text)
-                        .labelled_by(label.id);
-                    if ui.small_button("✔").clicked() {
-                        ctx.forget_image(&self.current_uri);
-                        self.uri_edit_text = self.uri_edit_text.trim().to_owned();
-                        self.current_uri = self.uri_edit_text.clone();
-                    };
+        egui::TopBottomPanel::new(TopBottomSide::Top, "url bar").show(ctx, |ui| {
+            ui.horizontal_centered(|ui| {
+                let label = ui.label("URI:");
+                ui.text_edit_singleline(&mut self.uri_edit_text)
+                    .labelled_by(label.id);
+                if ui.small_button("✔").clicked() {
+                    ctx.forget_image(&self.current_uri);
+                    self.uri_edit_text = self.uri_edit_text.trim().to_owned();
+                    self.current_uri = self.uri_edit_text.clone();
+                }
 
-                    #[cfg(not(target_arch = "wasm32"))]
-                    if ui.button("file…").clicked() {
-                        if let Some(path) = rfd::FileDialog::new().pick_file() {
-                            self.uri_edit_text = format!("file://{}", path.display());
-                            self.current_uri = self.uri_edit_text.clone();
-                        }
-                    }
-                });
-            },
-        );
+                #[cfg(not(target_arch = "wasm32"))]
+                if ui.button("file…").clicked()
+                    && let Some(path) = rfd::FileDialog::new().pick_file()
+                {
+                    self.uri_edit_text = format!("file://{}", path.display());
+                    self.current_uri = self.uri_edit_text.clone();
+                }
+            });
+        });
 
-        egui::Panel::new(PanelSide::Vertical(VerticalSide::Left), "controls").show(ctx, |ui| {
+        egui::SidePanel::new(Side::Left, "controls").show(ctx, |ui| {
             // uv
             ui.label("UV");
             ui.add(Slider::new(&mut self.image_options.uv.min.x, 0.0..=1.0).text("min x"));
diff --git a/crates/egui_demo_app/src/backend_panel.rs b/crates/egui_demo_app/src/backend_panel.rs
index 21c35cd92..e98d5179d 100644
--- a/crates/egui_demo_app/src/backend_panel.rs
+++ b/crates/egui_demo_app/src/backend_panel.rs
@@ -110,7 +110,7 @@ impl BackendPanel {
         if cfg!(debug_assertions) && cfg!(target_arch = "wasm32") {
             ui.separator();
             // For testing panic handling on web:
-            #[allow(clippy::manual_assert)]
+            #[expect(clippy::manual_assert)]
             if ui.button("panic!()").clicked() {
                 panic!("intentional panic!");
             }
@@ -146,6 +146,10 @@ impl BackendPanel {
             // builds to keep the noise down in the official demo.
             if cfg!(debug_assertions) {
                 ui.collapsing("More…", |ui| {
+                    ui.horizontal(|ui| {
+                        ui.label("Total ui frames:");
+                        ui.monospace(ui.ctx().cumulative_frame_nr().to_string());
+                    });
                     ui.horizontal(|ui| {
                         ui.label("Total ui passes:");
                         ui.monospace(ui.ctx().cumulative_pass_nr().to_string());
@@ -183,7 +187,7 @@ fn integration_ui(ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
         ui.label("egui running inside ");
         ui.hyperlink_to(
             "eframe",
-            "https://github.com/emilk/egui/tree/master/crates/eframe",
+            "https://github.com/emilk/egui/tree/main/crates/eframe",
         );
         ui.label(".");
     });
@@ -333,7 +337,7 @@ fn integration_ui(ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
                     .send_viewport_cmd(egui::ViewportCommand::InnerSize(size));
                 ui.ctx()
                     .send_viewport_cmd(egui::ViewportCommand::Fullscreen(false));
-                ui.close_menu();
+                ui.close();
             }
         });
     }
diff --git a/crates/egui_demo_app/src/frame_history.rs b/crates/egui_demo_app/src/frame_history.rs
index 231ba4a4f..52ff8342e 100644
--- a/crates/egui_demo_app/src/frame_history.rs
+++ b/crates/egui_demo_app/src/frame_history.rs
@@ -53,7 +53,7 @@ impl FrameHistory {
     }
 
     fn graph(&self, ui: &mut egui::Ui) -> egui::Response {
-        use egui::{emath, epaint, pos2, vec2, Pos2, Rect, Sense, Shape, Stroke, TextStyle};
+        use egui::{Pos2, Rect, Sense, Shape, Stroke, TextStyle, emath, epaint, pos2, vec2};
 
         ui.label("egui CPU usage history");
 
@@ -90,7 +90,7 @@ impl FrameHistory {
             ));
             let cpu_usage = to_screen.inverse().transform_pos(pointer_pos).y;
             let text = format!("{:.1} ms", 1e3 * cpu_usage);
-            shapes.push(ui.fonts(|f| {
+            shapes.push(ui.fonts_mut(|f| {
                 Shape::text(
                     f,
                     pos2(rect.left(), y),
diff --git a/crates/egui_demo_app/src/lib.rs b/crates/egui_demo_app/src/lib.rs
index 0eb34486d..05b3c4bd6 100644
--- a/crates/egui_demo_app/src/lib.rs
+++ b/crates/egui_demo_app/src/lib.rs
@@ -10,13 +10,14 @@ pub use wrap_app::{Anchor, WrapApp};
 
 /// Time of day as seconds since midnight. Used for clock in demo app.
 pub(crate) fn seconds_since_midnight() -> f64 {
-    use chrono::Timelike;
+    use chrono::Timelike as _;
     let time = chrono::Local::now().time();
     time.num_seconds_from_midnight() as f64 + 1e-9 * (time.nanosecond() as f64)
 }
 
 // ----------------------------------------------------------------------------
-
+#[cfg(feature = "accessibility_inspector")]
+pub mod accessibility_inspector;
 #[cfg(target_arch = "wasm32")]
 mod web;
 
diff --git a/crates/egui_demo_app/src/main.rs b/crates/egui_demo_app/src/main.rs
index 6a2bb2da7..37a235e89 100644
--- a/crates/egui_demo_app/src/main.rs
+++ b/crates/egui_demo_app/src/main.rs
@@ -4,8 +4,11 @@
 #![allow(rustdoc::missing_crate_level_docs)] // it's an example
 #![allow(clippy::never_loop)] // False positive
 
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; // Much faster allocator, can give 20% speedups: https://github.com/emilk/egui/pull/7029
+
 // When compiling natively:
-fn main() -> eframe::Result {
+fn main() {
     for arg in std::env::args().skip(1) {
         match arg.as_str() {
             "--profile" => {
@@ -13,7 +16,9 @@ fn main() -> eframe::Result {
                 start_puffin_server();
 
                 #[cfg(not(feature = "puffin"))]
-                panic!("Unknown argument: {arg} - you need to enable the 'puffin' feature to use this.");
+                panic!(
+                    "Unknown argument: {arg} - you need to enable the 'puffin' feature to use this."
+                );
             }
 
             _ => {
@@ -36,7 +41,12 @@ fn main() -> eframe::Result {
                 rust_log += &format!(",{loud_crate}=warn");
             }
         }
-        std::env::set_var("RUST_LOG", rust_log);
+
+        // SAFETY: we call this from the main thread without any other threads running.
+        #[expect(unsafe_code)]
+        unsafe {
+            std::env::set_var("RUST_LOG", rust_log);
+        }
     }
 
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -52,11 +62,27 @@ fn main() -> eframe::Result {
         ..Default::default()
     };
 
-    eframe::run_native(
+    let result = eframe::run_native(
         "egui demo app",
         options,
         Box::new(|cc| Ok(Box::new(egui_demo_app::WrapApp::new(cc)))),
-    )
+    );
+
+    match result {
+        Ok(()) => {}
+        Err(err) => {
+            // This produces a nicer error message than returning the `Result`:
+            print_error_and_exit(&err);
+        }
+    }
+}
+
+fn print_error_and_exit(err: &eframe::Error) -> ! {
+    #![expect(clippy::print_stderr)]
+    #![expect(clippy::exit)]
+
+    eprintln!("Error: {err}");
+    std::process::exit(1)
 }
 
 #[cfg(feature = "puffin")]
@@ -75,11 +101,11 @@ fn start_puffin_server() {
 
             // 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)]
+            #[expect(clippy::mem_forget)]
             std::mem::forget(puffin_server);
         }
         Err(err) => {
             log::error!("Failed to start puffin server: {err}");
         }
-    };
+    }
 }
diff --git a/crates/egui_demo_app/src/web.rs b/crates/egui_demo_app/src/web.rs
index 8c9cdd1d4..104ef1dce 100644
--- a/crates/egui_demo_app/src/web.rs
+++ b/crates/egui_demo_app/src/web.rs
@@ -14,7 +14,7 @@ pub struct WebHandle {
 #[wasm_bindgen]
 impl WebHandle {
     /// Installs a panic hook, then returns.
-    #[allow(clippy::new_without_default)]
+    #[allow(clippy::new_without_default, clippy::allow_attributes)]
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
         // Redirect [`log`] message to `console.log` and friends:
diff --git a/crates/egui_demo_app/src/wrap_app.rs b/crates/egui_demo_app/src/wrap_app.rs
index dc8b7f653..c118f280c 100644
--- a/crates/egui_demo_app/src/wrap_app.rs
+++ b/crates/egui_demo_app/src/wrap_app.rs
@@ -80,9 +80,10 @@ impl eframe::App for ColorTestApp {
     }
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum Anchor {
+    #[default]
     Demo,
 
     EasyMarkEditor,
@@ -134,13 +135,7 @@ impl std::fmt::Display for Anchor {
 
 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
+        Self::from(value.to_string())
     }
 }
 
@@ -188,7 +183,11 @@ impl WrapApp {
         // This gives us image support:
         egui_extras::install_image_loaders(&cc.egui_ctx);
 
-        #[allow(unused_mut)]
+        #[cfg(feature = "accessibility_inspector")]
+        cc.egui_ctx
+            .add_plugin(crate::accessibility_inspector::AccessibilityInspectorPlugin::default());
+
+        #[allow(unused_mut, clippy::allow_attributes)]
         let mut slf = Self {
             state: State::default(),
 
@@ -199,10 +198,10 @@ impl WrapApp {
         };
 
         #[cfg(feature = "persistence")]
-        if let Some(storage) = cc.storage {
-            if let Some(state) = eframe::get_value(storage, eframe::APP_KEY) {
-                slf.state = state;
-            }
+        if let Some(storage) = cc.storage
+            && let Some(state) = eframe::get_value(storage, eframe::APP_KEY)
+        {
+            slf.state = state;
         }
 
         slf
@@ -384,12 +383,12 @@ impl WrapApp {
                 .clicked()
             {
                 ui.ctx().memory_mut(|mem| *mem = Default::default());
-                ui.close_menu();
+                ui.close();
             }
 
             if ui.button("Reset everything").clicked() {
                 *cmd = Command::ResetEverything;
-                ui.close_menu();
+                ui.close();
             }
         });
     }
@@ -472,10 +471,10 @@ impl WrapApp {
             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));
+            let content_rect = ctx.content_rect();
+            painter.rect_filled(content_rect, 0.0, Color32::from_black_alpha(192));
             painter.text(
-                screen_rect.center(),
+                content_rect.center(),
                 Align2::CENTER_CENTER,
                 text,
                 TextStyle::Heading.resolve(&ctx.style()),
diff --git a/crates/egui_demo_app/tests/snapshots/clock.png b/crates/egui_demo_app/tests/snapshots/clock.png
index 80fef31cc..39d9bb5ce 100644
--- a/crates/egui_demo_app/tests/snapshots/clock.png
+++ b/crates/egui_demo_app/tests/snapshots/clock.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2c15a74a1b1ed3b52a53966a3df2901ca520b92fbfbd10503e32ddb8431e1467
-size 335399
+oid sha256:44a68dc4d3aeebeb2d296c5c8e03aac330e1e4552364084347b710326c88f70c
+size 335794
diff --git a/crates/egui_demo_app/tests/snapshots/custom3d.png b/crates/egui_demo_app/tests/snapshots/custom3d.png
index b138e53b9..deed497b1 100644
--- a/crates/egui_demo_app/tests/snapshots/custom3d.png
+++ b/crates/egui_demo_app/tests/snapshots/custom3d.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0e4a90792a9876da549f3d1da9b057a078400ad15db2cc6e35f4324851137d4e
-size 93115
+oid sha256:e9a760fe4a695e6321f00e40bfa76fd0195bee7157a1217572765e3f146ea2cc
+size 93640
diff --git a/crates/egui_demo_app/tests/snapshots/easymarkeditor.png b/crates/egui_demo_app/tests/snapshots/easymarkeditor.png
index 014264330..a039b8c24 100644
--- a/crates/egui_demo_app/tests/snapshots/easymarkeditor.png
+++ b/crates/egui_demo_app/tests/snapshots/easymarkeditor.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d8f1046ee5d50d73a17009fd1f11f056b5828fedc62908d00730a6aa77125473
-size 182900
+oid sha256:a1670bbfc1f0a71e20cbbeb73625c148b680963bc503d9b48e9cc43e704d7c54
+size 181671
diff --git a/crates/egui_demo_app/tests/snapshots/imageviewer.png b/crates/egui_demo_app/tests/snapshots/imageviewer.png
index 62624506d..b0d60672b 100644
--- a/crates/egui_demo_app/tests/snapshots/imageviewer.png
+++ b/crates/egui_demo_app/tests/snapshots/imageviewer.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:57274cec5ee7e5522073249b931ea65ead22752aea1de40666543e765c1b6b85
-size 102929
+oid sha256:128ca4e741995ffcdc07b027407d63911ded6c94fe3fe1dd0efecbf9408fb3af
+size 99871
diff --git a/crates/egui_demo_app/tests/test_demo_app.rs b/crates/egui_demo_app/tests/test_demo_app.rs
index 0247b9fc2..e083c8455 100644
--- a/crates/egui_demo_app/tests/test_demo_app.rs
+++ b/crates/egui_demo_app/tests/test_demo_app.rs
@@ -1,8 +1,8 @@
-use egui::accesskit::Role;
 use egui::Vec2;
+use egui::accesskit::Role;
 use egui_demo_app::{Anchor, WrapApp};
-use egui_kittest::kittest::Queryable;
 use egui_kittest::SnapshotResults;
+use egui_kittest::kittest::Queryable as _;
 
 #[test]
 fn test_demo_app() {
@@ -55,20 +55,23 @@ fn test_demo_app() {
                 harness
                     .get_by_role_and_label(Role::TextInput, "URI:")
                     .focus();
-                harness.press_key_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
+                harness.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
 
                 harness
                     .get_by_role_and_label(Role::TextInput, "URI:")
                     .type_text("file://../eframe/data/icon.png");
 
                 harness.get_by_role_and_label(Role::Button, "✔").click();
+
+                // Wait for the image to load
+                harness.try_run_realtime().ok();
             }
             _ => {}
         }
 
         // Can't use Harness::run because fractal clock keeps requesting repaints
-        harness.run_steps(2);
+        harness.run_steps(4);
 
-        results.add(harness.try_snapshot(&anchor.to_string()));
+        results.add(harness.try_snapshot(anchor.to_string()));
     }
 }
diff --git a/crates/egui_demo_lib/Cargo.toml b/crates/egui_demo_lib/Cargo.toml
index 0e0299f11..3e61187d5 100644
--- a/crates/egui_demo_lib/Cargo.toml
+++ b/crates/egui_demo_lib/Cargo.toml
@@ -5,19 +5,13 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Example library for egui"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/egui_demo_lib"
+homepage = "https://github.com/emilk/egui/tree/main/crates/egui_demo_lib"
 license.workspace = true
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/egui_demo_lib"
+repository = "https://github.com/emilk/egui/tree/main/crates/egui_demo_lib"
 categories = ["gui", "graphics"]
 keywords = ["glow", "egui", "gui", "gamedev"]
-include = [
-    "../LICENSE-APACHE",
-    "../LICENSE-MIT",
-    "**/*.rs",
-    "Cargo.toml",
-    "data/icon.png",
-]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml", "data/*"]
 
 [lints]
 workspace = true
@@ -43,12 +37,12 @@ syntect = ["egui_extras/syntect"]
 
 [dependencies]
 egui = { workspace = true, default-features = false, features = ["color-hex"] }
-egui_extras = { workspace = true, features = ["default"] }
+egui_extras = { workspace = true, features = ["image", "svg"] }
 
-unicode_names2 = { version = "0.6.0", default-features = false } # this old version has fewer dependencies
+unicode_names2.workspace = true # this old version has fewer dependencies
 
 #! ### Optional dependencies
-chrono = { version = "0.4", optional = true, features = ["js-sys", "wasmbind"] }
+chrono = { workspace = true, optional = true, features = ["js-sys", "wasmbind"] }
 ## Enable this when generating docs.
 document-features = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
@@ -56,8 +50,12 @@ serde = { workspace = true, optional = true }
 
 [dev-dependencies]
 criterion.workspace = true
-egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }
 egui = { workspace = true, features = ["default_fonts"] }
+egui_extras = { workspace = true, features = ["image", "svg"] }
+egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }
+image = { workspace = true, features = ["png"] }
+mimalloc.workspace = true # for benchmarks
+rand.workspace = true
 
 [[bench]]
 name = "benchmark"
diff --git a/crates/egui_demo_lib/README.md b/crates/egui_demo_lib/README.md
index 43ca0a0f3..58a5d6305 100644
--- a/crates/egui_demo_lib/README.md
+++ b/crates/egui_demo_lib/README.md
@@ -14,3 +14,19 @@ The demo library is a separate crate for three reasons:
 * 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
+
+This crate also contains benchmarks for egui. 
+Run them with 
+```bash
+# Run all benchmarks
+cargo bench -p egui_demo_lib 
+
+# Run a single benchmark
+cargo bench -p egui_demo_lib "benchmark name"
+
+# Profile benchmarks with cargo-flamegraph (--root flag is necessary for MacOS)
+CARGO_PROFILE_BENCH_DEBUG=true cargo flamegraph --bench benchmark --root -p egui_demo_lib  -- --bench "benchmark name"
+
+# Profile with cargo-instruments
+CARGO_PROFILE_BENCH_DEBUG=true cargo instruments --profile bench --bench benchmark -p egui_demo_lib -t time -- --bench "benchmark name" 
+```
diff --git a/crates/egui_demo_lib/benches/benchmark.rs b/crates/egui_demo_lib/benches/benchmark.rs
index cbcc4d88f..48e7d5207 100644
--- a/crates/egui_demo_lib/benches/benchmark.rs
+++ b/crates/egui_demo_lib/benches/benchmark.rs
@@ -1,7 +1,22 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use std::fmt::Write as _;
+
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 
 use egui::epaint::TextShape;
+use egui::load::SizedTexture;
+use egui::{Button, Id, RichText, TextureId, Ui, UiBuilder, Vec2};
 use egui_demo_lib::LOREM_IPSUM_LONG;
+use rand::Rng as _;
+
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; // Much faster allocator
+
+/// Each iteration should be called in their own `Ui` with an intentional id clash,
+/// to prevent the Context from building a massive map of `WidgetRects` (which would slow the test,
+/// causing unreliable results).
+fn create_benchmark_ui(ctx: &egui::Context) -> Ui {
+    Ui::new(ctx.clone(), Id::new("clashing_id"), UiBuilder::new())
+}
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     use egui::RawInput;
@@ -52,17 +67,71 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     {
         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(|| {
+            c.bench_function("label &str", |b| {
+                b.iter_batched_ref(
+                    || create_benchmark_ui(ctx),
+                    |ui| {
                         ui.label("the quick brown fox jumps over the lazy dog");
-                    });
-                });
-                c.bench_function("label format!", |b| {
-                    b.iter(|| {
+                    },
+                    BatchSize::LargeInput,
+                );
+            });
+            c.bench_function("label format!", |b| {
+                b.iter_batched_ref(
+                    || create_benchmark_ui(ctx),
+                    |ui| {
                         ui.label("the quick brown fox jumps over the lazy dog".to_owned());
-                    });
-                });
+                    },
+                    BatchSize::LargeInput,
+                );
+            });
+        });
+    }
+
+    {
+        let ctx = egui::Context::default();
+        let _ = ctx.run(RawInput::default(), |ctx| {
+            let mut group = c.benchmark_group("button");
+
+            // To ensure we have a valid image, let's use the font texture. The size
+            // shouldn't be important for this benchmark.
+            let image = SizedTexture::new(TextureId::default(), Vec2::splat(16.0));
+
+            group.bench_function("1_button_text", |b| {
+                b.iter_batched_ref(
+                    || create_benchmark_ui(ctx),
+                    |ui| {
+                        ui.add(Button::new("Hello World"));
+                    },
+                    BatchSize::LargeInput,
+                );
+            });
+            group.bench_function("2_button_text_image", |b| {
+                b.iter_batched_ref(
+                    || create_benchmark_ui(ctx),
+                    |ui| {
+                        ui.add(Button::image_and_text(image, "Hello World"));
+                    },
+                    BatchSize::LargeInput,
+                );
+            });
+            group.bench_function("3_button_text_image_right_text", |b| {
+                b.iter_batched_ref(
+                    || create_benchmark_ui(ctx),
+                    |ui| {
+                        ui.add(Button::image_and_text(image, "Hello World").right_text("⏵"));
+                    },
+                    BatchSize::LargeInput,
+                );
+            });
+            group.bench_function("4_button_italic", |b| {
+                b.iter_batched_ref(
+                    || create_benchmark_ui(ctx),
+                    |ui| {
+                        ui.add(Button::new(RichText::new("Hello World").italics()));
+                    },
+                    BatchSize::LargeInput,
+                );
             });
         });
     }
@@ -96,16 +165,15 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         let wrap_width = 512.0;
         let font_id = egui::FontId::default();
         let text_color = egui::Color32::WHITE;
-        let fonts = egui::epaint::text::Fonts::new(
-            pixels_per_point,
+        let mut fonts = egui::epaint::text::Fonts::new(
             max_texture_side,
+            egui::epaint::AlphaFromCoverage::default(),
             egui::FontDefinitions::default(),
         );
         {
-            let mut locked_fonts = fonts.lock();
             c.bench_function("text_layout_uncached", |b| {
                 b.iter(|| {
-                    use egui::epaint::text::{layout, LayoutJob};
+                    use egui::epaint::text::{LayoutJob, layout};
 
                     let job = LayoutJob::simple(
                         LOREM_IPSUM_LONG.to_owned(),
@@ -113,13 +181,13 @@ pub fn criterion_benchmark(c: &mut Criterion) {
                         text_color,
                         wrap_width,
                     );
-                    layout(&mut locked_fonts.fonts, job.into())
+                    layout(&mut fonts.fonts, pixels_per_point, job.into())
                 });
             });
         }
         c.bench_function("text_layout_cached", |b| {
             b.iter(|| {
-                fonts.layout(
+                fonts.with_pixels_per_point(pixels_per_point).layout(
                     LOREM_IPSUM_LONG.to_owned(),
                     font_id.clone(),
                     text_color,
@@ -128,9 +196,43 @@ pub fn criterion_benchmark(c: &mut Criterion) {
             });
         });
 
-        let galley = fonts.layout(LOREM_IPSUM_LONG.to_owned(), font_id, text_color, wrap_width);
+        c.bench_function("text_layout_cached_many_lines_modified", |b| {
+            const NUM_LINES: usize = 2_000;
+
+            let mut string = String::new();
+            for _ in 0..NUM_LINES {
+                for i in 0..30_u8 {
+                    write!(string, "{i:02X} ").unwrap();
+                }
+                string.push('\n');
+            }
+
+            let mut rng = rand::rng();
+            b.iter(|| {
+                fonts.begin_pass(max_texture_side, egui::epaint::AlphaFromCoverage::default());
+
+                // Delete a random character, simulating a user making an edit in a long file:
+                let mut new_string = string.clone();
+                let idx = rng.random_range(0..string.len());
+                new_string.remove(idx);
+
+                fonts.with_pixels_per_point(pixels_per_point).layout(
+                    new_string,
+                    font_id.clone(),
+                    text_color,
+                    wrap_width,
+                );
+            });
+        });
+
+        let galley = fonts.with_pixels_per_point(pixels_per_point).layout(
+            LOREM_IPSUM_LONG.to_owned(),
+            font_id,
+            text_color,
+            wrap_width,
+        );
         let font_image_size = fonts.font_image_size();
-        let prepared_discs = fonts.texture_atlas().lock().prepared_discs();
+        let prepared_discs = fonts.texture_atlas().prepared_discs();
         let mut tessellator = egui::epaint::Tessellator::new(
             1.0,
             Default::default(),
diff --git a/crates/egui_demo_lib/data/peace.svg b/crates/egui_demo_lib/data/peace.svg
new file mode 100644
index 000000000..4bf3e33a9
--- /dev/null
+++ b/crates/egui_demo_lib/data/peace.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg"
+     xmlns:svg="http://www.w3.org/2000/svg"
+     viewBox="0 0 44 44" width="32" height="32">
+  <g fill="none" stroke="white" stroke-width="3">
+    <circle cx="22" cy="22" r="19"/>
+    <path d="M 22,2 V 41"/>
+    <path d="M 22,2 V 22" transform="rotate(135, 22, 22)"/>
+    <path d="M 22,2 V 22" transform="rotate(225, 22, 22)"/>
+  </g>
+</svg>
diff --git a/crates/egui_demo_lib/data/ring.png b/crates/egui_demo_lib/data/ring.png
new file mode 100644
index 000000000..f82db9196
Binary files /dev/null and b/crates/egui_demo_lib/data/ring.png differ
diff --git a/crates/egui_demo_lib/src/demo/code_editor.rs b/crates/egui_demo_lib/src/demo/code_editor.rs
index fe39e1be8..6a4720311 100644
--- a/crates/egui_demo_lib/src/demo/code_editor.rs
+++ b/crates/egui_demo_lib/src/demo/code_editor.rs
@@ -76,16 +76,16 @@ impl crate::View for CodeEditor {
             });
         });
 
-        let mut layouter = |ui: &egui::Ui, string: &str, wrap_width: f32| {
+        let mut layouter = |ui: &egui::Ui, buf: &dyn egui::TextBuffer, wrap_width: f32| {
             let mut layout_job = egui_extras::syntax_highlighting::highlight(
                 ui.ctx(),
                 ui.style(),
                 &theme,
-                string,
+                buf.as_str(),
                 language,
             );
             layout_job.wrap.max_width = wrap_width;
-            ui.fonts(|f| f.layout_job(layout_job))
+            ui.fonts_mut(|f| f.layout_job(layout_job))
         };
 
         egui::ScrollArea::vertical().show(ui, |ui| {
diff --git a/crates/egui_demo_lib/src/demo/code_example.rs b/crates/egui_demo_lib/src/demo/code_example.rs
index 9094c19a7..23f561506 100644
--- a/crates/egui_demo_lib/src/demo/code_example.rs
+++ b/crates/egui_demo_lib/src/demo/code_example.rs
@@ -62,6 +62,7 @@ impl CodeExample {
         }
         ui.end_row();
 
+        #[expect(clippy::literal_string_with_formatting_args)]
         show_code(ui, r#"ui.label(format!("{name} is {age}"));"#);
         ui.label(format!("{name} is {age}"));
         ui.end_row();
@@ -84,7 +85,7 @@ impl CodeExample {
 
         ui.horizontal(|ui| {
             let font_id = egui::TextStyle::Monospace.resolve(ui.style());
-            let indentation = 2.0 * 4.0 * ui.fonts(|f| f.glyph_width(&font_id, ' '));
+            let indentation = 2.0 * 4.0 * ui.fonts_mut(|f| f.glyph_width(&font_id, ' '));
             ui.add_space(indentation);
 
             egui::Grid::new("code_samples")
@@ -105,7 +106,7 @@ impl crate::Demo for CodeExample {
     }
 
     fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
-        use crate::View;
+        use crate::View as _;
         egui::Window::new(self.name())
             .open(open)
             .min_width(375.0)
diff --git a/crates/egui_demo_lib/src/demo/context_menu.rs b/crates/egui_demo_lib/src/demo/context_menu.rs
deleted file mode 100644
index 2dce3e763..000000000
--- a/crates/egui_demo_lib/src/demo/context_menu.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-#[derive(Clone, Default, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct ContextMenus {}
-
-impl crate::Demo for ContextMenus {
-    fn name(&self) -> &'static str {
-        "☰ Context Menus"
-    }
-
-    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
-        use crate::View;
-        egui::Window::new(self.name())
-            .vscroll(false)
-            .resizable(false)
-            .open(open)
-            .show(ctx, |ui| self.ui(ui));
-    }
-}
-
-impl crate::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);
-
-            if ui.ctx().is_context_menu_open() {
-                ui.label("Context menu is open");
-            } else {
-                ui.label("Context menu is closed");
-            }
-        });
-
-        ui.vertical_centered(|ui| {
-            ui.add(crate::egui_github_link_file!());
-        });
-    }
-}
-
-impl ContextMenus {
-    fn nested_menus(ui: &mut egui::Ui) {
-        ui.set_max_width(200.0); // To make sure we wrap long text
-
-        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 that should be wrapped");
-    }
-}
diff --git a/crates/egui_demo_lib/src/demo/dancing_strings.rs b/crates/egui_demo_lib/src/demo/dancing_strings.rs
index dd480181d..cc4b578c0 100644
--- a/crates/egui_demo_lib/src/demo/dancing_strings.rs
+++ b/crates/egui_demo_lib/src/demo/dancing_strings.rs
@@ -1,8 +1,9 @@
 use egui::{
+    Color32, Context, Pos2, Rect, Ui,
     containers::{Frame, Window},
     emath, epaint,
     epaint::PathStroke,
-    hex_color, lerp, pos2, remap, vec2, Color32, Context, Pos2, Rect, Ui,
+    hex_color, lerp, pos2, remap, vec2,
 };
 
 #[derive(Default)]
diff --git a/crates/egui_demo_lib/src/demo/demo_app_windows.rs b/crates/egui_demo_lib/src/demo/demo_app_windows.rs
index e3aa314b5..8033539dd 100644
--- a/crates/egui_demo_lib/src/demo/demo_app_windows.rs
+++ b/crates/egui_demo_lib/src/demo/demo_app_windows.rs
@@ -1,18 +1,28 @@
 use std::collections::BTreeSet;
 
-use egui::{Context, Modifiers, ScrollArea, Ui};
-
 use super::About;
-use crate::is_mobile;
 use crate::Demo;
-use crate::View;
-
+use crate::View as _;
+use crate::is_mobile;
+use egui::containers::menu;
+use egui::style::StyleModifier;
+use egui::{Context, Modifiers, ScrollArea, Ui};
 // ----------------------------------------------------------------------------
 
 struct DemoGroup {
     demos: Vec<Box<dyn Demo>>,
 }
 
+impl std::ops::Add for DemoGroup {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        let mut demos = self.demos;
+        demos.extend(other.demos);
+        Self { demos }
+    }
+}
+
 impl DemoGroup {
     pub fn new(demos: Vec<Box<dyn Demo>>) -> Self {
         Self { demos }
@@ -65,7 +75,6 @@ impl Default for DemoGroups {
                 Box::<super::paint_bezier::PaintBezier>::default(),
                 Box::<super::code_editor::CodeEditor>::default(),
                 Box::<super::code_example::CodeExample>::default(),
-                Box::<super::context_menu::ContextMenus>::default(),
                 Box::<super::dancing_strings::DancingStrings>::default(),
                 Box::<super::drag_and_drop::DragAndDropDemo>::default(),
                 Box::<super::extra_viewport::ExtraViewport>::default(),
@@ -78,6 +87,7 @@ impl Default for DemoGroups {
                 Box::<super::multi_touch::MultiTouch>::default(),
                 Box::<super::painting::Painting>::default(),
                 Box::<super::panels::Panels>::default(),
+                Box::<super::popups::PopupsDemo>::default(),
                 Box::<super::scene::SceneDemo>::default(),
                 Box::<super::screenshot::Screenshot>::default(),
                 Box::<super::scrolling::Scrolling>::default(),
@@ -100,6 +110,7 @@ impl Default for DemoGroups {
                 Box::<super::tests::InputTest>::default(),
                 Box::<super::tests::LayoutTest>::default(),
                 Box::<super::tests::ManualLayoutTest>::default(),
+                Box::<super::tests::SvgTest>::default(),
                 Box::<super::tests::TessellationTest>::default(),
                 Box::<super::tests::WindowResizeTest>::default(),
             ]),
@@ -225,38 +236,36 @@ impl DemoWindows {
     }
 
     fn mobile_top_bar(&mut self, ctx: &Context) {
-        egui::Panel::top("menu_bar").show(ctx, |ui| {
-            egui::menu::bar(ui, |ui| {
-                let font_size = 16.5;
+        egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
+            menu::MenuBar::new()
+                .config(menu::MenuConfig::new().style(StyleModifier::default()))
+                .ui(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.menu_button(egui::RichText::new("⏷ demos").size(font_size), |ui| {
+                        self.demo_list_ui(ui);
+                    });
 
-                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                    use egui::special_emojis::GITHUB;
-                    ui.hyperlink_to(
-                        egui::RichText::new("🦋").size(font_size),
-                        "https://bsky.app/profile/ernerfeldt.bsky.social",
-                    );
-                    ui.hyperlink_to(
-                        egui::RichText::new(GITHUB).size(font_size),
-                        "https://github.com/emilk/egui",
-                    );
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                        use egui::special_emojis::GITHUB;
+                        ui.hyperlink_to(
+                            egui::RichText::new("🦋").size(font_size),
+                            "https://bsky.app/profile/ernerfeldt.bsky.social",
+                        );
+                        ui.hyperlink_to(
+                            egui::RichText::new(GITHUB).size(font_size),
+                            "https://github.com/emilk/egui",
+                        );
+                    });
                 });
-            });
         });
     }
 
     fn desktop_ui(&mut self, ctx: &Context) {
-        egui::Panel::right("egui_demo_panel")
+        egui::SidePanel::right("egui_demo_panel")
             .resizable(false)
-            .default_size(160.0)
-            .min_size(160.0)
+            .default_width(160.0)
+            .min_width(160.0)
             .show(ctx, |ui| {
                 ui.add_space(4.0);
                 ui.vertical_centered(|ui| {
@@ -280,8 +289,8 @@ impl DemoWindows {
                 self.demo_list_ui(ui);
             });
 
-        egui::Panel::top("menu_bar").show(ctx, |ui| {
-            egui::menu::bar(ui, |ui| {
+        egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
+            menu::MenuBar::new().ui(ui, |ui| {
                 file_menu_button(ui);
             });
         });
@@ -344,7 +353,6 @@ fn file_menu_button(ui: &mut Ui) {
             .clicked()
         {
             ui.ctx().memory_mut(|mem| mem.reset_areas());
-            ui.close_menu();
         }
 
         if ui
@@ -356,21 +364,25 @@ fn file_menu_button(ui: &mut Ui) {
             .clicked()
         {
             ui.ctx().memory_mut(|mem| *mem = Default::default());
-            ui.close_menu();
         }
     });
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{demo::demo_app_windows::DemoGroups, Demo};
-    use egui::Vec2;
-    use egui_kittest::kittest::Queryable;
-    use egui_kittest::{Harness, SnapshotOptions, SnapshotResults};
+    use crate::{Demo as _, demo::demo_app_windows::DemoGroups};
+
+    use egui_kittest::kittest::{NodeT as _, Queryable as _};
+    use egui_kittest::{Harness, OsThreshold, SnapshotOptions, SnapshotResults};
 
     #[test]
     fn demos_should_match_snapshot() {
-        let demos = DemoGroups::default().demos;
+        let DemoGroups {
+            demos,
+            tests,
+            about: _,
+        } = DemoGroups::default();
+        let demos = demos + tests;
 
         let mut results = SnapshotResults::new();
 
@@ -380,33 +392,41 @@ mod tests {
                 continue;
             }
 
-            // Remove the emoji from the demo name
-            let name = demo
-                .name()
-                .split_once(' ')
-                .map_or(demo.name(), |(_, name)| name);
+            let name = remove_leading_emoji(demo.name());
 
             let mut harness = Harness::new(|ctx| {
+                egui_extras::install_image_loaders(ctx);
                 demo.show(ctx, &mut true);
             });
 
-            let window = harness.node().children().next().unwrap();
+            let window = harness.queryable_node().children().next().unwrap();
             // TODO(lucasmerlin): Windows should probably have a label?
             //let window = harness.get_by_label(name);
 
-            let size = window.raw_bounds().expect("window bounds").size();
-            harness.set_size(Vec2::new(size.width as f32, size.height as f32));
+            let size = window.rect().size();
+            harness.set_size(size);
 
             // Run the app for some more frames...
             harness.run_ok();
 
             let mut options = SnapshotOptions::default();
-            // The Bézier Curve demo needs a threshold of 2.1 to pass on linux
+
             if name == "Bézier Curve" {
-                options.threshold = 2.1;
+                // The Bézier Curve demo needs a threshold of 2.1 to pass on linux:
+                options = options.threshold(OsThreshold::new(0.0).linux(2.1));
             }
 
-            results.add(harness.try_snapshot_options(&format!("demos/{name}"), &options));
+            results.add(harness.try_snapshot_options(format!("demos/{name}"), &options));
         }
     }
+
+    fn remove_leading_emoji(full_name: &str) -> &str {
+        if let Some((start, name)) = full_name.split_once(' ')
+            && start.len() <= 4
+            && start.bytes().next().is_some_and(|byte| byte >= 128)
+        {
+            return name;
+        }
+        full_name
+    }
 }
diff --git a/crates/egui_demo_lib/src/demo/drag_and_drop.rs b/crates/egui_demo_lib/src/demo/drag_and_drop.rs
index 7fa3f01bb..d483ced3f 100644
--- a/crates/egui_demo_lib/src/demo/drag_and_drop.rs
+++ b/crates/egui_demo_lib/src/demo/drag_and_drop.rs
@@ -1,4 +1,4 @@
-use egui::{vec2, Color32, Context, Frame, Id, Ui, Window};
+use egui::{Color32, Context, Frame, Id, Ui, Window, vec2};
 
 #[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
diff --git a/crates/egui_demo_lib/src/demo/extra_viewport.rs b/crates/egui_demo_lib/src/demo/extra_viewport.rs
index 1ab7787f9..d7c875f5f 100644
--- a/crates/egui_demo_lib/src/demo/extra_viewport.rs
+++ b/crates/egui_demo_lib/src/demo/extra_viewport.rs
@@ -54,7 +54,11 @@ fn viewport_content(ui: &mut egui::Ui, ctx: &egui::Context, open: &mut bool) {
 
     egui::ScrollArea::vertical().show(ui, |ui| {
         let viewports = ui.input(|i| i.raw.viewports.clone());
-        for (id, viewport) in viewports {
+        let ordered_viewports = viewports
+            .iter()
+            .map(|(id, viewport)| (*id, viewport.clone()))
+            .collect::<egui::OrderedViewportIdMap<_>>();
+        for (id, viewport) in ordered_viewports {
             ui.group(|ui| {
                 ui.label(format!("viewport {id:?}"));
                 ui.push_id(id, |ui| {
diff --git a/crates/egui_demo_lib/src/demo/font_book.rs b/crates/egui_demo_lib/src/demo/font_book.rs
index 605b7ed7f..39acf844a 100644
--- a/crates/egui_demo_lib/src/demo/font_book.rs
+++ b/crates/egui_demo_lib/src/demo/font_book.rs
@@ -77,7 +77,7 @@ impl crate::View for FontBook {
         let available_glyphs = self
             .available_glyphs
             .entry(self.font_id.family.clone())
-            .or_insert_with(|| available_characters(ui, self.font_id.family.clone()));
+            .or_insert_with(|| available_characters(ui, &self.font_id.family));
 
         ui.separator();
 
@@ -140,11 +140,10 @@ fn char_info_ui(ui: &mut egui::Ui, chr: char, glyph_info: &GlyphInfo, font_id: e
         });
 }
 
-fn available_characters(ui: &egui::Ui, family: egui::FontFamily) -> BTreeMap<char, GlyphInfo> {
-    ui.fonts(|f| {
-        f.lock()
-            .fonts
-            .font(&egui::FontId::new(10.0, family)) // size is arbitrary for getting the characters
+fn available_characters(ui: &egui::Ui, family: &egui::FontFamily) -> BTreeMap<char, GlyphInfo> {
+    ui.fonts_mut(|f| {
+        f.fonts
+            .font(family)
             .characters()
             .iter()
             .filter(|(chr, _fonts)| !chr.is_whitespace() && !chr.is_ascii_control())
@@ -169,7 +168,7 @@ fn char_name(chr: char) -> String {
 }
 
 fn special_char_name(chr: char) -> Option<&'static str> {
-    #[allow(clippy::match_same_arms)] // many "flag"
+    #[expect(clippy::match_same_arms)] // many "flag"
     match chr {
         // Special private-use-area extensions found in `emoji-icon-font.ttf`:
         // Private use area extensions:
diff --git a/crates/egui_demo_lib/src/demo/interactive_container.rs b/crates/egui_demo_lib/src/demo/interactive_container.rs
index 11d8afa48..5faeb8458 100644
--- a/crates/egui_demo_lib/src/demo/interactive_container.rs
+++ b/crates/egui_demo_lib/src/demo/interactive_container.rs
@@ -1,4 +1,4 @@
-use egui::{Frame, Label, RichText, Sense, UiBuilder, Widget};
+use egui::{Frame, Label, RichText, Sense, UiBuilder, Widget as _};
 
 /// Showcase [`egui::Ui::response`].
 #[derive(PartialEq, Eq, Default)]
diff --git a/crates/egui_demo_lib/src/demo/misc_demo_window.rs b/crates/egui_demo_lib/src/demo/misc_demo_window.rs
index edb19c3ea..bb62f1822 100644
--- a/crates/egui_demo_lib/src/demo/misc_demo_window.rs
+++ b/crates/egui_demo_lib/src/demo/misc_demo_window.rs
@@ -1,8 +1,8 @@
 use super::{Demo, View};
 
 use egui::{
-    vec2, Align, Checkbox, CollapsingHeader, Color32, Context, FontId, Resize, RichText, Sense,
-    Slider, Stroke, TextFormat, TextStyle, Ui, Vec2, Window,
+    Align, Align2, Checkbox, CollapsingHeader, Color32, ComboBox, Context, FontId, Resize,
+    RichText, Sense, Slider, Stroke, TextFormat, TextStyle, Ui, Vec2, Window, vec2,
 };
 
 /// Showcase some ui code
@@ -16,6 +16,7 @@ pub struct MiscDemoWindow {
     custom_collapsing_header: CustomCollapsingHeader,
     tree: Tree,
     box_painting: BoxPainting,
+    text_rotation: TextRotation,
 
     dummy_bool: bool,
     dummy_usize: usize,
@@ -32,6 +33,7 @@ impl Default for MiscDemoWindow {
             custom_collapsing_header: Default::default(),
             tree: Tree::demo(),
             box_painting: Default::default(),
+            text_rotation: Default::default(),
 
             dummy_bool: false,
             dummy_usize: 0,
@@ -79,6 +81,10 @@ impl View for MiscDemoWindow {
                 });
             });
 
+        CollapsingHeader::new("Text rotation")
+            .default_open(false)
+            .show(ui, |ui| self.text_rotation.ui(ui));
+
         CollapsingHeader::new("Colors")
             .default_open(false)
             .show(ui, |ui| {
@@ -207,7 +213,7 @@ fn label_ui(ui: &mut egui::Ui) {
 
     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()), ' '));
+            let width = ui.fonts_mut(|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)));
@@ -729,3 +735,95 @@ fn text_layout_demo(ui: &mut Ui) {
 
     ui.label(job);
 }
+
+// ----------------------------------------------------------------------------
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+struct TextRotation {
+    size: Vec2,
+    angle: f32,
+    align: egui::Align2,
+}
+
+impl Default for TextRotation {
+    fn default() -> Self {
+        Self {
+            size: vec2(200.0, 200.0),
+            angle: 0.0,
+            align: egui::Align2::LEFT_TOP,
+        }
+    }
+}
+
+impl TextRotation {
+    pub fn ui(&mut self, ui: &mut Ui) {
+        ui.add(Slider::new(&mut self.angle, 0.0..=2.0 * std::f32::consts::PI).text("angle"));
+
+        let default_color = if ui.visuals().dark_mode {
+            Color32::LIGHT_GRAY
+        } else {
+            Color32::DARK_GRAY
+        };
+
+        let aligns = [
+            (Align2::LEFT_TOP, "LEFT_TOP"),
+            (Align2::LEFT_CENTER, "LEFT_CENTER"),
+            (Align2::LEFT_BOTTOM, "LEFT_BOTTOM"),
+            (Align2::CENTER_TOP, "CENTER_TOP"),
+            (Align2::CENTER_CENTER, "CENTER_CENTER"),
+            (Align2::CENTER_BOTTOM, "CENTER_BOTTOM"),
+            (Align2::RIGHT_TOP, "RIGHT_TOP"),
+            (Align2::RIGHT_CENTER, "RIGHT_CENTER"),
+            (Align2::RIGHT_BOTTOM, "RIGHT_BOTTOM"),
+        ];
+
+        ComboBox::new("anchor", "Anchor")
+            .selected_text(aligns.iter().find(|(a, _)| *a == self.align).unwrap().1)
+            .show_ui(ui, |ui| {
+                for (align2, name) in &aligns {
+                    ui.selectable_value(&mut self.align, *align2, *name);
+                }
+            });
+
+        ui.horizontal_wrapped(|ui| {
+            let (response, painter) = ui.allocate_painter(self.size, Sense::empty());
+            let rect = response.rect;
+
+            let start_pos = self.size / 2.0;
+
+            let s = ui.ctx().fonts_mut(|f| {
+                let mut t = egui::Shape::text(
+                    f,
+                    rect.min + start_pos,
+                    egui::Align2::LEFT_TOP,
+                    "sample_text",
+                    egui::FontId::new(12.0, egui::FontFamily::Proportional),
+                    default_color,
+                );
+
+                if let egui::epaint::Shape::Text(ts) = &mut t {
+                    let new = ts.clone().with_angle_and_anchor(self.angle, self.align);
+                    *ts = new;
+                }
+
+                t
+            });
+
+            if let egui::epaint::Shape::Text(ts) = &s {
+                let align_pt =
+                    rect.min + start_pos + self.align.pos_in_rect(&ts.galley.rect).to_vec2();
+                painter.circle(align_pt, 2.0, Color32::RED, (0.0, Color32::RED));
+            }
+
+            painter.rect(
+                rect,
+                0.0,
+                default_color.gamma_multiply(0.3),
+                (0.0, Color32::BLACK),
+                egui::StrokeKind::Middle,
+            );
+            painter.add(s);
+        });
+    }
+}
diff --git a/crates/egui_demo_lib/src/demo/mod.rs b/crates/egui_demo_lib/src/demo/mod.rs
index cb68a46fb..553221a1f 100644
--- a/crates/egui_demo_lib/src/demo/mod.rs
+++ b/crates/egui_demo_lib/src/demo/mod.rs
@@ -7,7 +7,6 @@
 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;
@@ -23,6 +22,7 @@ pub mod paint_bezier;
 pub mod painting;
 pub mod panels;
 pub mod password;
+mod popups;
 pub mod scene;
 pub mod screenshot;
 pub mod scrolling;
diff --git a/crates/egui_demo_lib/src/demo/modals.rs b/crates/egui_demo_lib/src/demo/modals.rs
index d344d99c0..a916c8bdf 100644
--- a/crates/egui_demo_lib/src/demo/modals.rs
+++ b/crates/egui_demo_lib/src/demo/modals.rs
@@ -1,4 +1,4 @@
-use egui::{ComboBox, Context, Id, Modal, ProgressBar, Ui, Widget, Window};
+use egui::{ComboBox, Context, Id, Modal, ProgressBar, Ui, Widget as _, Window};
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
@@ -96,7 +96,9 @@ impl crate::View for Modals {
                             *save_modal_open = true;
                         }
                         if ui.button("Cancel").clicked() {
-                            *user_modal_open = false;
+                            // You can call `ui.close()` to close the modal.
+                            // (This causes the current modals `should_close` to return true)
+                            ui.close();
                         }
                     },
                 );
@@ -123,7 +125,7 @@ impl crate::View for Modals {
                         }
 
                         if ui.button("No Thanks").clicked() {
-                            *save_modal_open = false;
+                            ui.close();
                         }
                     },
                 );
@@ -160,11 +162,11 @@ impl crate::View for Modals {
 
 #[cfg(test)]
 mod tests {
+    use crate::Demo as _;
     use crate::demo::modals::Modals;
-    use crate::Demo;
     use egui::accesskit::Role;
-    use egui::Key;
-    use egui_kittest::kittest::Queryable;
+    use egui::{Key, Popup};
+    use egui_kittest::kittest::Queryable as _;
     use egui_kittest::{Harness, SnapshotResults};
 
     #[test]
@@ -185,12 +187,12 @@ mod tests {
 
         // Harness::run would fail because we keep requesting repaints to simulate progress.
         harness.run_ok();
-        assert!(harness.ctx.memory(|mem| mem.any_popup_open()));
+        assert!(Popup::is_any_open(&harness.ctx));
         assert!(harness.state().user_modal_open);
 
-        harness.press_key(Key::Escape);
+        harness.key_press(Key::Escape);
         harness.run_ok();
-        assert!(!harness.ctx.memory(|mem| mem.any_popup_open()));
+        assert!(!Popup::is_any_open(&harness.ctx));
         assert!(harness.state().user_modal_open);
     }
 
@@ -212,7 +214,7 @@ mod tests {
         assert!(harness.state().user_modal_open);
         assert!(harness.state().save_modal_open);
 
-        harness.press_key(Key::Escape);
+        harness.key_press(Key::Escape);
         harness.run();
 
         assert!(harness.state().user_modal_open);
@@ -265,7 +267,7 @@ mod tests {
 
         harness.run_ok();
 
-        harness.get_by_label("Yes Please").simulate_click();
+        harness.get_by_label("Yes Please").click();
 
         harness.run_ok();
 
diff --git a/crates/egui_demo_lib/src/demo/multi_touch.rs b/crates/egui_demo_lib/src/demo/multi_touch.rs
index b6580c5f8..d83e548bd 100644
--- a/crates/egui_demo_lib/src/demo/multi_touch.rs
+++ b/crates/egui_demo_lib/src/demo/multi_touch.rs
@@ -1,6 +1,7 @@
 use egui::{
+    Color32, Event, Frame, Pos2, Rect, Sense, Stroke, Vec2,
     emath::{RectTransform, Rot2},
-    vec2, Color32, Frame, Pos2, Rect, Sense, Stroke, Vec2,
+    vec2,
 };
 
 pub struct MultiTouch {
@@ -29,7 +30,7 @@ impl crate::Demo for MultiTouch {
     fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
-            .default_size(vec2(512.0, 512.0))
+            .default_size(vec2(544.0, 512.0))
             .resizable(true)
             .show(ctx, |ui| {
                 use crate::View as _;
@@ -44,13 +45,31 @@ impl crate::View for MultiTouch {
             ui.add(crate::egui_github_link_file!());
         });
         ui.strong(
-            "This demo only works on devices with multitouch support (e.g. mobiles and tablets).",
+            "This demo only works on devices with multitouch support (e.g. mobiles, tablets, and trackpads).",
         );
         ui.separator();
         ui.label("Try touch gestures Pinch/Stretch, Rotation, and Pressure with 2+ fingers.");
 
+        let relative_pointer_gesture = ui.input(|i| {
+            i.events.iter().any(|event| {
+                matches!(
+                    event,
+                    Event::MouseWheel { .. } | Event::Zoom { .. } | Event::Rotate { .. }
+                )
+            })
+        });
         let num_touches = ui.input(|i| i.multi_touch().map_or(0, |mt| mt.num_touches));
-        ui.label(format!("Current touches: {num_touches}"));
+        let num_touches_str = format!("{num_touches}-finger touch");
+        ui.label(format!(
+            "Input source: {}",
+            if ui.input(|i| i.multi_touch().is_some()) {
+                num_touches_str.as_str()
+            } else if relative_pointer_gesture {
+                "cursor"
+            } else {
+                "none"
+            }
+        ));
 
         let color = if ui.visuals().dark_mode {
             Color32::WHITE
@@ -82,18 +101,18 @@ impl crate::View for MultiTouch {
             // 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;
+            if ui.input(|i| i.multi_touch().is_some()) || relative_pointer_gesture {
+                ui.input(|input| {
+                    // This adjusts the current zoom factor, rotation angle, and translation according
+                    // to the dynamic change (for the current frame) of the touch gesture:
+                    self.zoom *= input.zoom_delta();
+                    self.rotation += input.rotation_delta();
+                    self.translation += to_screen.inverse().scale() * input.translation_delta();
+                    // touch pressure will make the arrow thicker (not all touch devices support this):
+                    stroke_width += 10. * input.multi_touch().map_or(0.0, |touch| touch.force);
 
-                self.last_touch_time = ui.input(|i| i.time);
+                    self.last_touch_time = input.time;
+                });
             } else {
                 self.slowly_reset(ui);
             }
diff --git a/crates/egui_demo_lib/src/demo/paint_bezier.rs b/crates/egui_demo_lib/src/demo/paint_bezier.rs
index 08e29a9ff..57def359f 100644
--- a/crates/egui_demo_lib/src/demo/paint_bezier.rs
+++ b/crates/egui_demo_lib/src/demo/paint_bezier.rs
@@ -1,8 +1,8 @@
 use egui::{
-    emath,
+    Color32, Context, Frame, Grid, Pos2, Rect, Sense, Shape, Stroke, StrokeKind, Ui, Vec2,
+    Widget as _, Window, emath,
     epaint::{self, CubicBezierShape, PathShape, QuadraticBezierShape},
-    pos2, Color32, Context, Frame, Grid, Pos2, Rect, Sense, Shape, Stroke, StrokeKind, Ui, Vec2,
-    Widget, Window,
+    pos2,
 };
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -152,7 +152,7 @@ impl PaintBezier {
             _ => {
                 unreachable!();
             }
-        };
+        }
 
         painter.add(PathShape::line(points_in_screen, self.aux_stroke));
         painter.extend(control_point_shapes);
diff --git a/crates/egui_demo_lib/src/demo/painting.rs b/crates/egui_demo_lib/src/demo/painting.rs
index 8e1df7ae7..5a4942f68 100644
--- a/crates/egui_demo_lib/src/demo/painting.rs
+++ b/crates/egui_demo_lib/src/demo/painting.rs
@@ -1,4 +1,4 @@
-use egui::{emath, vec2, Color32, Context, Frame, Pos2, Rect, Sense, Stroke, Ui, Window};
+use egui::{Color32, Context, Frame, Pos2, Rect, Sense, Stroke, Ui, Window, emath, vec2};
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
diff --git a/crates/egui_demo_lib/src/demo/password.rs b/crates/egui_demo_lib/src/demo/password.rs
index 528f5a515..04b3c6f37 100644
--- a/crates/egui_demo_lib/src/demo/password.rs
+++ b/crates/egui_demo_lib/src/demo/password.rs
@@ -8,7 +8,6 @@
 /// ``` 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.
@@ -28,7 +27,7 @@ pub fn password_ui(ui: &mut egui::Ui, password: &mut String) -> egui::Response {
     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, "👁"))
+            .selectable_label(show_plaintext, "👁")
             .on_hover_text("Show/hide password");
 
         if response.clicked() {
@@ -62,5 +61,5 @@ pub fn password(password: &mut String) -> impl egui::Widget + '_ {
 }
 
 pub fn url_to_file_source_code() -> String {
-    format!("https://github.com/emilk/egui/blob/master/{}", file!())
+    format!("https://github.com/emilk/egui/blob/main/{}", file!())
 }
diff --git a/crates/egui_demo_lib/src/demo/popups.rs b/crates/egui_demo_lib/src/demo/popups.rs
new file mode 100644
index 000000000..cb14f0cc7
--- /dev/null
+++ b/crates/egui_demo_lib/src/demo/popups.rs
@@ -0,0 +1,319 @@
+use crate::rust_view_ui;
+use egui::color_picker::{Alpha, color_picker_color32};
+use egui::containers::menu::{MenuConfig, SubMenuButton};
+use egui::{
+    Align, Align2, Atom, Button, ComboBox, Frame, Id, Layout, Popup, PopupCloseBehavior, RectAlign,
+    RichText, Tooltip, Ui, UiBuilder, include_image,
+};
+
+/// Showcase [`Popup`].
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct PopupsDemo {
+    align4: RectAlign,
+    gap: f32,
+    #[cfg_attr(feature = "serde", serde(skip))]
+    close_behavior: PopupCloseBehavior,
+    popup_open: bool,
+    checked: bool,
+    color: egui::Color32,
+}
+
+impl Default for PopupsDemo {
+    fn default() -> Self {
+        Self {
+            align4: RectAlign::default(),
+            gap: 4.0,
+            close_behavior: PopupCloseBehavior::CloseOnClick,
+            popup_open: false,
+            checked: true,
+            color: egui::Color32::RED,
+        }
+    }
+}
+
+impl PopupsDemo {
+    fn apply_options<'a>(&self, popup: Popup<'a>) -> Popup<'a> {
+        popup
+            .align(self.align4)
+            .gap(self.gap)
+            .close_behavior(self.close_behavior)
+    }
+
+    fn nested_menus(&mut self, ui: &mut Ui) {
+        ui.set_max_width(200.0); // To make sure we wrap long text
+
+        if ui.button("Open…").clicked() {
+            ui.close();
+        }
+        ui.menu_button("Popups can have submenus", |ui| {
+            ui.menu_button("SubMenu", |ui| {
+                if ui.button("Open…").clicked() {
+                    ui.close();
+                }
+                let _ = ui.button("Item");
+                ui.menu_button("Recursive", |ui| self.nested_menus(ui));
+            });
+            ui.menu_button("SubMenu", |ui| {
+                if ui.button("Open…").clicked() {
+                    ui.close();
+                }
+                let _ = ui.button("Item");
+            });
+            let _ = ui.button("Item");
+            if ui.button("Open…").clicked() {
+                ui.close();
+            }
+        });
+        ui.add_enabled_ui(false, |ui| {
+            ui.menu_button("SubMenus can be disabled", |_| {});
+        });
+        ui.menu_image_text_button(
+            include_image!("../../data/icon.png"),
+            "I have an icon!",
+            |ui| {
+                let _ = ui.button("Item1");
+                let _ = ui.button("Item2");
+                let _ = ui.button("Item3");
+                let _ = ui.button("Item4");
+                if ui.button("Open…").clicked() {
+                    ui.close();
+                }
+            },
+        );
+        let _ = ui.button("Very long text for this item that should be wrapped");
+        SubMenuButton::new("Always CloseOnClickOutside")
+            .config(MenuConfig::new().close_behavior(PopupCloseBehavior::CloseOnClickOutside))
+            .ui(ui, |ui| {
+                ui.checkbox(&mut self.checked, "Checkbox");
+
+                // Customized color SubMenuButton
+                let is_bright = self.color.intensity() > 0.5;
+                let text_color = if is_bright {
+                    egui::Color32::BLACK
+                } else {
+                    egui::Color32::WHITE
+                };
+
+                let button = Button::new((
+                    RichText::new("Background").color(text_color),
+                    Atom::grow(),
+                    RichText::new(SubMenuButton::RIGHT_ARROW).color(text_color),
+                ))
+                .fill(self.color);
+
+                SubMenuButton::from_button(button).ui(ui, |ui| {
+                    ui.spacing_mut().slider_width = 200.0;
+                    color_picker_color32(ui, &mut self.color, Alpha::Opaque);
+                });
+
+                if self.checked {
+                    ui.menu_button("Only visible when checked", |ui| {
+                        if ui.button("Remove myself").clicked() {
+                            self.checked = false;
+                        }
+                    });
+                }
+
+                if ui.button("Open…").clicked() {
+                    ui.close();
+                }
+            });
+    }
+}
+
+impl crate::Demo for PopupsDemo {
+    fn name(&self) -> &'static str {
+        "\u{2755} Popups"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .open(open)
+            .resizable(false)
+            .default_width(250.0)
+            .constrain(false)
+            .show(ctx, |ui| {
+                use crate::View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+impl crate::View for PopupsDemo {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        let response = Frame::group(ui.style())
+            .show(ui, |ui| {
+                ui.set_width(ui.available_width());
+                ui.vertical_centered(|ui| ui.button("Click, right-click and hover me!"))
+                    .inner
+            })
+            .inner;
+
+        self.apply_options(Popup::menu(&response).id(Id::new("menu")))
+            .show(|ui| self.nested_menus(ui));
+
+        self.apply_options(Popup::context_menu(&response).id(Id::new("context_menu")))
+            .show(|ui| self.nested_menus(ui));
+
+        if self.popup_open {
+            self.apply_options(Popup::from_response(&response).id(Id::new("popup")))
+                .show(|ui| {
+                    ui.label("Popup contents");
+                });
+        }
+
+        let mut tooltip = Tooltip::for_enabled(&response);
+        tooltip.popup = self.apply_options(tooltip.popup);
+        tooltip.show(|ui| {
+            ui.label("Tooltips are popups, too!");
+        });
+
+        Frame::canvas(ui.style()).show(ui, |ui| {
+            let mut reset_btn_ui = ui.new_child(
+                UiBuilder::new()
+                    .max_rect(ui.max_rect())
+                    .layout(Layout::right_to_left(Align::Min)),
+            );
+            if reset_btn_ui
+                .button("⟲")
+                .on_hover_text("Reset to defaults")
+                .clicked()
+            {
+                *self = Self::default();
+            }
+
+            ui.set_width(ui.available_width());
+            ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+            ui.spacing_mut().item_spacing.x = 0.0;
+            let align_combobox = |ui: &mut Ui, label: &str, align: &mut Align2| {
+                let aligns = [
+                    (Align2::LEFT_TOP, "LEFT_TOP"),
+                    (Align2::LEFT_CENTER, "LEFT_CENTER"),
+                    (Align2::LEFT_BOTTOM, "LEFT_BOTTOM"),
+                    (Align2::CENTER_TOP, "CENTER_TOP"),
+                    (Align2::CENTER_CENTER, "CENTER_CENTER"),
+                    (Align2::CENTER_BOTTOM, "CENTER_BOTTOM"),
+                    (Align2::RIGHT_TOP, "RIGHT_TOP"),
+                    (Align2::RIGHT_CENTER, "RIGHT_CENTER"),
+                    (Align2::RIGHT_BOTTOM, "RIGHT_BOTTOM"),
+                ];
+
+                ComboBox::new(label, "")
+                    .selected_text(aligns.iter().find(|(a, _)| a == align).unwrap().1)
+                    .show_ui(ui, |ui| {
+                        for (align2, name) in &aligns {
+                            ui.selectable_value(align, *align2, *name);
+                        }
+                    });
+            };
+
+            rust_view_ui(ui, "let align = RectAlign {");
+            ui.horizontal(|ui| {
+                rust_view_ui(ui, "    parent: Align2::");
+                align_combobox(ui, "parent", &mut self.align4.parent);
+                rust_view_ui(ui, ",");
+            });
+            ui.horizontal(|ui| {
+                rust_view_ui(ui, "    child: Align2::");
+                align_combobox(ui, "child", &mut self.align4.child);
+                rust_view_ui(ui, ",");
+            });
+            rust_view_ui(ui, "};");
+
+            ui.horizontal(|ui| {
+                rust_view_ui(ui, "let align = RectAlign::");
+
+                let presets = [
+                    (RectAlign::TOP_START, "TOP_START"),
+                    (RectAlign::TOP, "TOP"),
+                    (RectAlign::TOP_END, "TOP_END"),
+                    (RectAlign::RIGHT_START, "RIGHT_START"),
+                    (RectAlign::RIGHT, "RIGHT"),
+                    (RectAlign::RIGHT_END, "RIGHT_END"),
+                    (RectAlign::BOTTOM_START, "BOTTOM_START"),
+                    (RectAlign::BOTTOM, "BOTTOM"),
+                    (RectAlign::BOTTOM_END, "BOTTOM_END"),
+                    (RectAlign::LEFT_START, "LEFT_START"),
+                    (RectAlign::LEFT, "LEFT"),
+                    (RectAlign::LEFT_END, "LEFT_END"),
+                ];
+
+                ComboBox::new("Preset", "")
+                    .selected_text(
+                        presets
+                            .iter()
+                            .find(|(a, _)| a == &self.align4)
+                            .map_or("<Select Preset>", |(_, name)| *name),
+                    )
+                    .show_ui(ui, |ui| {
+                        for (align4, name) in &presets {
+                            ui.selectable_value(&mut self.align4, *align4, *name);
+                        }
+                    });
+                rust_view_ui(ui, ";");
+            });
+
+            ui.horizontal(|ui| {
+                rust_view_ui(ui, "let gap = ");
+                ui.add(egui::DragValue::new(&mut self.gap));
+                rust_view_ui(ui, ";");
+            });
+
+            rust_view_ui(ui, "let close_behavior");
+            ui.horizontal(|ui| {
+                rust_view_ui(ui, "    = PopupCloseBehavior::");
+                let close_behaviors = [
+                    (
+                        PopupCloseBehavior::CloseOnClick,
+                        "CloseOnClick",
+                        "Closes when the user clicks anywhere (inside or outside)",
+                    ),
+                    (
+                        PopupCloseBehavior::CloseOnClickOutside,
+                        "CloseOnClickOutside",
+                        "Closes when the user clicks outside the popup",
+                    ),
+                    (
+                        PopupCloseBehavior::IgnoreClicks,
+                        "IgnoreClicks",
+                        "Close only when the button is clicked again",
+                    ),
+                ];
+                ComboBox::new("Close behavior", "")
+                    .selected_text(
+                        close_behaviors
+                            .iter()
+                            .find_map(|(behavior, text, _)| {
+                                (behavior == &self.close_behavior).then_some(*text)
+                            })
+                            .unwrap(),
+                    )
+                    .show_ui(ui, |ui| {
+                        for (close_behavior, name, tooltip) in &close_behaviors {
+                            ui.selectable_value(&mut self.close_behavior, *close_behavior, *name)
+                                .on_hover_text(*tooltip);
+                        }
+                    });
+                rust_view_ui(ui, ";");
+            });
+
+            ui.horizontal(|ui| {
+                rust_view_ui(ui, "let popup_open = ");
+                ui.checkbox(&mut self.popup_open, "");
+                rust_view_ui(ui, ";");
+            });
+            ui.monospace("");
+            rust_view_ui(ui, "let response = ui.button(\"Click me!\");");
+            rust_view_ui(ui, "Popup::menu(&response)");
+            rust_view_ui(ui, "    .gap(gap).align(align)");
+            rust_view_ui(ui, "    .close_behavior(close_behavior)");
+            rust_view_ui(ui, "    .show(|ui| { /* menu contents */ });");
+        });
+
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}
diff --git a/crates/egui_demo_lib/src/demo/screenshot.rs b/crates/egui_demo_lib/src/demo/screenshot.rs
index eb62611c8..64370ec07 100644
--- a/crates/egui_demo_lib/src/demo/screenshot.rs
+++ b/crates/egui_demo_lib/src/demo/screenshot.rs
@@ -1,4 +1,4 @@
-use egui::{Image, UserData, ViewportCommand, Widget};
+use egui::{Image, UserData, ViewportCommand, Widget as _};
 use std::sync::Arc;
 
 /// Showcase [`ViewportCommand::Screenshot`].
@@ -58,7 +58,7 @@ impl crate::View for Screenshot {
                         None
                     }
                 })
-                .last()
+                .next_back()
         });
 
         if let Some(image) = image {
diff --git a/crates/egui_demo_lib/src/demo/scrolling.rs b/crates/egui_demo_lib/src/demo/scrolling.rs
index 7a2ca4d7c..8c1250a9c 100644
--- a/crates/egui_demo_lib/src/demo/scrolling.rs
+++ b/crates/egui_demo_lib/src/demo/scrolling.rs
@@ -1,11 +1,12 @@
 use egui::{
-    pos2, scroll_area::ScrollBarVisibility, Align, Align2, Color32, DragValue, NumExt, Rect,
-    ScrollArea, Sense, Slider, TextStyle, TextWrapMode, Ui, Vec2, Widget,
+    Align, Align2, Color32, DragValue, NumExt as _, Rect, ScrollArea, Sense, Slider, TextStyle,
+    TextWrapMode, Ui, Vec2, Widget as _, pos2, scroll_area::ScrollBarVisibility,
 };
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
 enum ScrollDemo {
+    #[default]
     ScrollAppearance,
     ScrollTo,
     ManyLines,
@@ -14,12 +15,6 @@ enum ScrollDemo {
     Bidirectional,
 }
 
-impl Default for ScrollDemo {
-    fn default() -> Self {
-        Self::ScrollAppearance
-    }
-}
-
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 #[derive(Default, PartialEq)]
@@ -191,7 +186,7 @@ fn huge_content_painter(ui: &mut egui::Ui) {
     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 row_height = ui.fonts_mut(|f| f.row_height(&font_id)) + ui.spacing().item_spacing.y;
     let num_rows = 10_000;
 
     ScrollArea::vertical()
@@ -222,7 +217,7 @@ fn huge_content_painter(ui: &mut egui::Ui) {
                     font_id.clone(),
                     ui.visuals().text_color(),
                 );
-                used_rect = used_rect.union(text_rect);
+                used_rect |= text_rect;
             }
 
             ui.allocate_rect(used_rect, Sense::hover()); // make sure it is visible!
diff --git a/crates/egui_demo_lib/src/demo/sliders.rs b/crates/egui_demo_lib/src/demo/sliders.rs
index ef8bdb0cd..6b512e1ea 100644
--- a/crates/egui_demo_lib/src/demo/sliders.rs
+++ b/crates/egui_demo_lib/src/demo/sliders.rs
@@ -1,4 +1,4 @@
-use egui::{style::HandleShape, Slider, SliderClamping, SliderOrientation, Ui};
+use egui::{Slider, SliderClamping, SliderOrientation, Ui, style::HandleShape};
 
 /// Showcase sliders
 #[derive(PartialEq)]
diff --git a/crates/egui_demo_lib/src/demo/table_demo.rs b/crates/egui_demo_lib/src/demo/table_demo.rs
index 5c6f42d96..a347df502 100644
--- a/crates/egui_demo_lib/src/demo/table_demo.rs
+++ b/crates/egui_demo_lib/src/demo/table_demo.rs
@@ -13,6 +13,7 @@ enum DemoType {
 pub struct TableDemo {
     demo: DemoType,
     striped: bool,
+    overline: bool,
     resizable: bool,
     clickable: bool,
     num_rows: usize,
@@ -28,6 +29,7 @@ impl Default for TableDemo {
         Self {
             demo: DemoType::Manual,
             striped: true,
+            overline: true,
             resizable: true,
             clickable: true,
             num_rows: 10_000,
@@ -65,6 +67,7 @@ impl crate::View for TableDemo {
         ui.vertical(|ui| {
             ui.horizontal(|ui| {
                 ui.checkbox(&mut self.striped, "Striped");
+                ui.checkbox(&mut self.overline, "Overline some rows");
                 ui.checkbox(&mut self.resizable, "Resizable columns");
                 ui.checkbox(&mut self.clickable, "Clickable rows");
             });
@@ -212,6 +215,7 @@ impl TableDemo {
                         let row_height = if is_thick { 30.0 } else { 18.0 };
                         body.row(row_height, |mut row| {
                             row.set_selected(self.selection.contains(&row_index));
+                            row.set_overline(self.overline && row_index % 7 == 3);
 
                             row.col(|ui| {
                                 ui.label(row_index.to_string());
@@ -247,6 +251,7 @@ impl TableDemo {
                         };
 
                         row.set_selected(self.selection.contains(&row_index));
+                        row.set_overline(self.overline && row_index % 7 == 3);
 
                         row.col(|ui| {
                             ui.label(row_index.to_string());
@@ -280,6 +285,7 @@ impl TableDemo {
                         };
 
                         row.set_selected(self.selection.contains(&row_index));
+                        row.set_overline(self.overline && row_index % 7 == 3);
 
                         row.col(|ui| {
                             ui.label(row_index.to_string());
@@ -324,9 +330,11 @@ fn expanding_content(ui: &mut egui::Ui) {
 }
 
 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!")
+    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
+    row_index.is_multiple_of(6)
 }
diff --git a/crates/egui_demo_lib/src/demo/tests/clipboard_test.rs b/crates/egui_demo_lib/src/demo/tests/clipboard_test.rs
index e602d046c..fb4cf0906 100644
--- a/crates/egui_demo_lib/src/demo/tests/clipboard_test.rs
+++ b/crates/egui_demo_lib/src/demo/tests/clipboard_test.rs
@@ -67,10 +67,9 @@ impl crate::View for ClipboardTest {
 
             if let Ok(egui::load::ImagePoll::Ready { image }) =
                 ui.ctx().try_load_image(&uri, Default::default())
+                && ui.button("📋").clicked()
             {
-                if ui.button("📋").clicked() {
-                    ui.ctx().copy_image((*image).clone());
-                }
+                ui.ctx().copy_image((*image).clone());
             }
         });
 
diff --git a/crates/egui_demo_lib/src/demo/tests/grid_test.rs b/crates/egui_demo_lib/src/demo/tests/grid_test.rs
index 511aa428f..0b7bfa485 100644
--- a/crates/egui_demo_lib/src/demo/tests/grid_test.rs
+++ b/crates/egui_demo_lib/src/demo/tests/grid_test.rs
@@ -110,7 +110,7 @@ impl crate::View for GridTest {
             ui.end_row();
 
             let mut dyn_text = String::from("O");
-            dyn_text.extend(std::iter::repeat('h').take(self.text_length));
+            dyn_text.extend(std::iter::repeat_n('h', self.text_length));
             ui.label(dyn_text);
             ui.label("Fifth row, second column");
             ui.end_row();
diff --git a/crates/egui_demo_lib/src/demo/tests/input_event_history.rs b/crates/egui_demo_lib/src/demo/tests/input_event_history.rs
index 9564e1b6d..25a242089 100644
--- a/crates/egui_demo_lib/src/demo/tests/input_event_history.rs
+++ b/crates/egui_demo_lib/src/demo/tests/input_event_history.rs
@@ -12,11 +12,11 @@ struct DeduplicatedHistory {
 
 impl DeduplicatedHistory {
     fn add(&mut self, summary: String, full: String) {
-        if let Some(entry) = self.history.back_mut() {
-            if entry.summary == summary {
-                entry.entries.push(full);
-                return;
-            }
+        if let Some(entry) = self.history.back_mut()
+            && entry.summary == summary
+        {
+            entry.entries.push(full);
+            return;
         }
         self.history.push_back(HistoryEntry {
             summary,
diff --git a/crates/egui_demo_lib/src/demo/tests/input_test.rs b/crates/egui_demo_lib/src/demo/tests/input_test.rs
index f6d3a310f..896716686 100644
--- a/crates/egui_demo_lib/src/demo/tests/input_test.rs
+++ b/crates/egui_demo_lib/src/demo/tests/input_test.rs
@@ -10,11 +10,11 @@ struct DeduplicatedHistory {
 
 impl DeduplicatedHistory {
     fn add(&mut self, text: String) {
-        if let Some(entry) = self.history.back_mut() {
-            if entry.text == text {
-                entry.repeated += 1;
-                return;
-            }
+        if let Some(entry) = self.history.back_mut()
+            && entry.text == text
+        {
+            entry.repeated += 1;
+            return;
         }
         self.history.push_back(HistoryEntry { text, repeated: 1 });
         if self.history.len() > 100 {
diff --git a/crates/egui_demo_lib/src/demo/tests/layout_test.rs b/crates/egui_demo_lib/src/demo/tests/layout_test.rs
index f58369121..f63eff0a9 100644
--- a/crates/egui_demo_lib/src/demo/tests/layout_test.rs
+++ b/crates/egui_demo_lib/src/demo/tests/layout_test.rs
@@ -1,4 +1,4 @@
-use egui::{vec2, Align, Direction, Layout, Resize, Slider, Ui};
+use egui::{Align, Direction, Layout, Resize, Slider, Ui, vec2};
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
diff --git a/crates/egui_demo_lib/src/demo/tests/mod.rs b/crates/egui_demo_lib/src/demo/tests/mod.rs
index d9fad5382..dc69cca70 100644
--- a/crates/egui_demo_lib/src/demo/tests/mod.rs
+++ b/crates/egui_demo_lib/src/demo/tests/mod.rs
@@ -6,6 +6,7 @@ mod input_event_history;
 mod input_test;
 mod layout_test;
 mod manual_layout_test;
+mod svg_test;
 mod tessellation_test;
 mod window_resize_test;
 
@@ -17,5 +18,6 @@ pub use input_event_history::InputEventHistory;
 pub use input_test::InputTest;
 pub use layout_test::LayoutTest;
 pub use manual_layout_test::ManualLayoutTest;
+pub use svg_test::SvgTest;
 pub use tessellation_test::TessellationTest;
 pub use window_resize_test::WindowResizeTest;
diff --git a/crates/egui_demo_lib/src/demo/tests/svg_test.rs b/crates/egui_demo_lib/src/demo/tests/svg_test.rs
new file mode 100644
index 000000000..930d1b5f6
--- /dev/null
+++ b/crates/egui_demo_lib/src/demo/tests/svg_test.rs
@@ -0,0 +1,42 @@
+pub struct SvgTest {
+    color: egui::Color32,
+}
+
+impl Default for SvgTest {
+    fn default() -> Self {
+        Self {
+            color: egui::Color32::LIGHT_RED,
+        }
+    }
+}
+
+impl crate::Demo for SvgTest {
+    fn name(&self) -> &'static str {
+        "SVG Test"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name()).open(open).show(ctx, |ui| {
+            use crate::View as _;
+            self.ui(ui);
+        });
+    }
+}
+
+impl crate::View for SvgTest {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        let Self { color } = self;
+        ui.color_edit_button_srgba(color);
+        let img_src = egui::include_image!("../../../data/peace.svg");
+
+        // First paint a small version, sized the same as the source…
+        ui.add(
+            egui::Image::new(img_src.clone())
+                .fit_to_original_size(1.0)
+                .tint(*color),
+        );
+
+        // …then a big one, to make sure they are both crisp
+        ui.add(egui::Image::new(img_src).tint(*color));
+    }
+}
diff --git a/crates/egui_demo_lib/src/demo/tests/tessellation_test.rs b/crates/egui_demo_lib/src/demo/tests/tessellation_test.rs
index 031f3e2ce..cb08cf24e 100644
--- a/crates/egui_demo_lib/src/demo/tests/tessellation_test.rs
+++ b/crates/egui_demo_lib/src/demo/tests/tessellation_test.rs
@@ -1,7 +1,8 @@
 use egui::{
-    emath::{GuiRounding, TSTransform},
+    Color32, Pos2, Rect, Sense, StrokeKind, Vec2,
+    emath::{GuiRounding as _, TSTransform},
     epaint::{self, RectShape},
-    vec2, Color32, Pos2, Rect, Sense, StrokeKind, Vec2,
+    vec2,
 };
 
 #[derive(Clone, Debug, PartialEq)]
@@ -373,7 +374,7 @@ mod tests {
             harness.fit_contents();
             harness.run();
 
-            harness.snapshot(&format!("tessellation_test/{name}"));
+            harness.snapshot(format!("tessellation_test/{name}"));
         }
     }
 }
diff --git a/crates/egui_demo_lib/src/demo/text_edit.rs b/crates/egui_demo_lib/src/demo/text_edit.rs
index 06911957f..345c88efe 100644
--- a/crates/egui_demo_lib/src/demo/text_edit.rs
+++ b/crates/egui_demo_lib/src/demo/text_edit.rs
@@ -65,20 +65,20 @@ impl crate::View for TextEditDemo {
             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);
-            }
+        if ui.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Y))
+            && 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| {
@@ -113,9 +113,9 @@ impl crate::View for TextEditDemo {
 
 #[cfg(test)]
 mod tests {
-    use egui::{accesskit, CentralPanel};
-    use egui_kittest::kittest::{Key, Queryable};
+    use egui::{CentralPanel, Key, Modifiers, accesskit};
     use egui_kittest::Harness;
+    use egui_kittest::kittest::Queryable as _;
 
     #[test]
     pub fn should_type() {
@@ -133,8 +133,9 @@ mod tests {
 
         let text_edit = harness.get_by_role(accesskit::Role::TextInput);
         assert_eq!(text_edit.value().as_deref(), Some("Hello, world!"));
+        text_edit.focus();
 
-        text_edit.key_combination(&[Key::Command, Key::A]);
+        harness.key_press_modifiers(Modifiers::COMMAND, Key::A);
         text_edit.type_text("Hi ");
 
         harness.run();
diff --git a/crates/egui_demo_lib/src/demo/text_layout.rs b/crates/egui_demo_lib/src/demo/text_layout.rs
index e4e7ddcc3..8f100b55d 100644
--- a/crates/egui_demo_lib/src/demo/text_layout.rs
+++ b/crates/egui_demo_lib/src/demo/text_layout.rs
@@ -5,7 +5,7 @@ pub struct TextLayoutDemo {
     break_anywhere: bool,
     max_rows: usize,
     overflow_character: Option<char>,
-    extra_letter_spacing_pixels: i32,
+    extra_letter_spacing: f32,
     line_height_pixels: u32,
     lorem_ipsum: bool,
 }
@@ -16,7 +16,7 @@ impl Default for TextLayoutDemo {
             max_rows: 6,
             break_anywhere: true,
             overflow_character: Some('…'),
-            extra_letter_spacing_pixels: 0,
+            extra_letter_spacing: 0.0,
             line_height_pixels: 0,
             lorem_ipsum: true,
         }
@@ -45,7 +45,7 @@ impl crate::View for TextLayoutDemo {
             break_anywhere,
             max_rows,
             overflow_character,
-            extra_letter_spacing_pixels,
+            extra_letter_spacing,
             line_height_pixels,
             lorem_ipsum,
         } = self;
@@ -85,7 +85,7 @@ impl crate::View for TextLayoutDemo {
                 ui.end_row();
 
                 ui.label("Extra letter spacing:");
-                ui.add(egui::DragValue::new(extra_letter_spacing_pixels).suffix(" pixels"));
+                ui.add(egui::DragValue::new(extra_letter_spacing).speed(0.1));
                 ui.end_row();
 
                 ui.label("Line height:");
@@ -126,14 +126,13 @@ impl crate::View for TextLayoutDemo {
         egui::ScrollArea::vertical()
             .auto_shrink(false)
             .show(ui, |ui| {
-                let extra_letter_spacing = points_per_pixel * *extra_letter_spacing_pixels as f32;
                 let line_height = (*line_height_pixels != 0)
                     .then_some(points_per_pixel * *line_height_pixels as f32);
 
                 let mut job = LayoutJob::single_section(
                     text.to_owned(),
                     egui::TextFormat {
-                        extra_letter_spacing,
+                        extra_letter_spacing: *extra_letter_spacing,
                         line_height,
                         ..Default::default()
                     },
diff --git a/crates/egui_demo_lib/src/demo/toggle_switch.rs b/crates/egui_demo_lib/src/demo/toggle_switch.rs
index 9619bd2c0..19d329e2f 100644
--- a/crates/egui_demo_lib/src/demo/toggle_switch.rs
+++ b/crates/egui_demo_lib/src/demo/toggle_switch.rs
@@ -76,7 +76,7 @@ pub fn toggle_ui(ui: &mut egui::Ui, on: &mut bool) -> egui::Response {
 }
 
 /// Here is the same code again, but a bit more compact:
-#[allow(dead_code)]
+#[expect(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());
@@ -121,5 +121,5 @@ pub fn toggle(on: &mut bool) -> impl egui::Widget + '_ {
 }
 
 pub fn url_to_file_source_code() -> String {
-    format!("https://github.com/emilk/egui/blob/master/{}", file!())
+    format!("https://github.com/emilk/egui/blob/main/{}", file!())
 }
diff --git a/crates/egui_demo_lib/src/demo/tooltips.rs b/crates/egui_demo_lib/src/demo/tooltips.rs
index 353727f1c..cc474bd4d 100644
--- a/crates/egui_demo_lib/src/demo/tooltips.rs
+++ b/crates/egui_demo_lib/src/demo/tooltips.rs
@@ -83,6 +83,9 @@ impl Tooltips {
                 ui.label("You can select this text.");
             });
 
+        ui.label("This tooltip shows at the mouse cursor.")
+            .on_hover_text_at_pointer("Move me around!!");
+
         ui.separator(); // ---------------------------------------------------------
 
         let tooltip_ui = |ui: &mut egui::Ui| {
diff --git a/crates/egui_demo_lib/src/demo/undo_redo.rs b/crates/egui_demo_lib/src/demo/undo_redo.rs
index 525e26c6f..5e6aff2ca 100644
--- a/crates/egui_demo_lib/src/demo/undo_redo.rs
+++ b/crates/egui_demo_lib/src/demo/undo_redo.rs
@@ -1,4 +1,4 @@
-use egui::{util::undoer::Undoer, Button};
+use egui::{Button, util::undoer::Undoer};
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -60,15 +60,11 @@ impl crate::View for UndoRedoDemo {
             let undo = ui.add_enabled(can_undo, Button::new("⟲ Undo")).clicked();
             let redo = ui.add_enabled(can_redo, Button::new("⟳ Redo")).clicked();
 
-            if undo {
-                if let Some(undo_text) = self.undoer.undo(&self.state) {
-                    self.state = undo_text.clone();
-                }
+            if undo && let Some(undo_text) = self.undoer.undo(&self.state) {
+                self.state = undo_text.clone();
             }
-            if redo {
-                if let Some(redo_text) = self.undoer.redo(&self.state) {
-                    self.state = redo_text.clone();
-                }
+            if redo && let Some(redo_text) = self.undoer.redo(&self.state) {
+                self.state = redo_text.clone();
             }
         });
 
diff --git a/crates/egui_demo_lib/src/demo/widget_gallery.rs b/crates/egui_demo_lib/src/demo/widget_gallery.rs
index 6005d6aec..214646d49 100644
--- a/crates/egui_demo_lib/src/demo/widget_gallery.rs
+++ b/crates/egui_demo_lib/src/demo/widget_gallery.rs
@@ -48,7 +48,7 @@ impl Default for WidgetGallery {
 }
 
 impl WidgetGallery {
-    #[allow(unused_mut)] // if not chrono
+    #[allow(unused_mut, clippy::allow_attributes)] // if not chrono
     #[inline]
     pub fn with_date_button(mut self, _with_date_button: bool) -> Self {
         #[cfg(feature = "chrono")]
@@ -308,7 +308,7 @@ fn doc_link_label_with_crate<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::View;
+    use crate::View as _;
     use egui::Vec2;
     use egui_kittest::Harness;
 
@@ -319,13 +319,27 @@ mod tests {
             date: Some(chrono::NaiveDate::from_ymd_opt(2024, 1, 1).unwrap()),
             ..Default::default()
         };
-        let mut harness = Harness::builder()
-            .with_pixels_per_point(2.0)
-            .with_size(Vec2::new(380.0, 550.0))
-            .build_ui(|ui| demo.ui(ui));
 
-        harness.fit_contents();
+        for pixels_per_point in [1, 2] {
+            for theme in [egui::Theme::Light, egui::Theme::Dark] {
+                let mut harness = Harness::builder()
+                    .with_pixels_per_point(pixels_per_point as f32)
+                    .with_theme(theme)
+                    .with_size(Vec2::new(380.0, 550.0))
+                    .build_ui(|ui| {
+                        egui_extras::install_image_loaders(ui.ctx());
+                        demo.ui(ui);
+                    });
 
-        harness.snapshot("widget_gallery");
+                harness.fit_contents();
+
+                let theme_name = match theme {
+                    egui::Theme::Light => "light",
+                    egui::Theme::Dark => "dark",
+                };
+                let image_name = format!("widget_gallery_{theme_name}_x{pixels_per_point}");
+                harness.snapshot(&image_name);
+            }
+        }
     }
 }
diff --git a/crates/egui_demo_lib/src/demo/window_options.rs b/crates/egui_demo_lib/src/demo/window_options.rs
index f0d24b460..67ec22463 100644
--- a/crates/egui_demo_lib/src/demo/window_options.rs
+++ b/crates/egui_demo_lib/src/demo/window_options.rs
@@ -1,4 +1,4 @@
-use egui::Vec2b;
+use egui::{UiKind, Vec2b};
 
 #[derive(Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -149,6 +149,16 @@ impl crate::View for WindowOptions {
                 self.disabled_time = ui.input(|i| i.time);
             }
             egui::reset_button(ui, self, "Reset");
+            if ui
+                .button("Close")
+                .on_hover_text("You can collapse / close Windows via Ui::close")
+                .clicked()
+            {
+                // Calling close would close the collapsible within the window
+                // ui.close();
+                // Instead, we close the window itself
+                ui.close_kind(UiKind::Window);
+            }
             ui.add(crate::egui_github_link_file!());
         });
     }
diff --git a/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs b/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
index e12a4dcb6..28e12630e 100644
--- a/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
+++ b/crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
@@ -1,5 +1,5 @@
 use egui::{
-    text::CCursorRange, Key, KeyboardShortcut, Modifiers, ScrollArea, TextBuffer, TextEdit, Ui,
+    Key, KeyboardShortcut, Modifiers, ScrollArea, TextBuffer, TextEdit, Ui, text::CCursorRange,
 };
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -80,10 +80,10 @@ impl EasyMarkEditor {
         } = 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);
+            let mut layouter = |ui: &egui::Ui, easymark: &dyn TextBuffer, wrap_width: f32| {
+                let mut layout_job = highlighter.highlight(ui.style(), easymark.as_str());
                 layout_job.wrap.max_width = wrap_width;
-                ui.fonts(|f| f.layout_job(layout_job))
+                ui.fonts_mut(|f| f.layout_job(layout_job))
             };
 
             ui.add(
@@ -96,13 +96,13 @@ impl EasyMarkEditor {
             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.cursor.char_range() {
-                let any_change = shortcuts(ui, code, &mut ccursor_range);
-                if any_change {
-                    state.cursor.set_char_range(Some(ccursor_range));
-                    state.store(ui.ctx(), response.id);
-                }
+        if let Some(mut state) = TextEdit::load_state(ui.ctx(), response.id)
+            && let Some(mut ccursor_range) = state.cursor.char_range()
+        {
+            let any_change = shortcuts(ui, code, &mut ccursor_range);
+            if any_change {
+                state.cursor.set_char_range(Some(ccursor_range));
+                state.store(ui.ctx(), response.id);
             }
         }
     }
@@ -146,7 +146,7 @@ fn shortcuts(ui: &Ui, code: &mut dyn TextBuffer, ccursor_range: &mut CCursorRang
     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 [primary, _secondary] = ccursor_range.sorted_cursors();
 
         let advance = code.insert_text("  ", primary.index);
         ccursor_range.primary.index += advance;
@@ -165,7 +165,7 @@ fn shortcuts(ui: &Ui, code: &mut dyn TextBuffer, ccursor_range: &mut CCursorRang
         if ui.input_mut(|i| i.consume_shortcut(&shortcut)) {
             any_change = true;
             toggle_surrounding(code, ccursor_range, surrounding);
-        };
+        }
     }
 
     any_change
@@ -177,7 +177,7 @@ fn toggle_surrounding(
     ccursor_range: &mut CCursorRange,
     surrounding: &str,
 ) {
-    let [primary, secondary] = ccursor_range.sorted();
+    let [primary, secondary] = ccursor_range.sorted_cursors();
 
     let surrounding_ccount = surrounding.chars().count();
 
@@ -237,7 +237,7 @@ Goals:
 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.
+[The reference parser](https://github.com/emilk/egui/blob/main/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.
 
diff --git a/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs b/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
index 5c6bc2ef0..8ed3eb387 100644
--- a/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
+++ b/crates/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
@@ -108,7 +108,7 @@ pub fn highlight_easymark(egui_style: &egui::Style, mut text: &str) -> egui::tex
         // Swallow everything up to the next special character:
         let line_end = text[skip..]
             .find('\n')
-            .map_or_else(|| text.len(), |i| (skip + i + 1));
+            .map_or_else(|| text.len(), |i| skip + i + 1);
         let end = text[skip..]
             .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '['][..])
             .map_or_else(|| text.len(), |i| (skip + i).max(1));
diff --git a/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs b/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
index ed3ebe7f9..66c0dc04f 100644
--- a/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
+++ b/crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
@@ -113,19 +113,19 @@ impl<'a> Parser<'a> {
 
     // ```{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));
-                }
+        if let Some(language_start) = self.s.strip_prefix("```")
+            && 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
@@ -171,14 +171,14 @@ impl<'a> Parser<'a> {
             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));
-                    }
+                if this_line[bracket_end + 1..].starts_with('(')
+                    && 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));
                 }
             }
         }
diff --git a/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs b/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
index 17d3858f7..f9d078b28 100644
--- a/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
+++ b/crates/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
@@ -1,7 +1,7 @@
 use super::easy_mark_parser as easy_mark;
 use egui::{
-    vec2, Align, Align2, Hyperlink, Layout, Response, RichText, Sense, Separator, Shape, TextStyle,
-    Ui,
+    Align, Align2, Hyperlink, Layout, Response, RichText, Sense, Separator, Shape, TextStyle, Ui,
+    vec2,
 };
 
 /// Parse and display a VERY simple and small subset of Markdown.
@@ -101,7 +101,7 @@ pub fn item_ui(ui: &mut Ui, item: easy_mark::Item<'_>) {
                 Shape::rect_filled(rect, 1.0, code_bg_color),
             );
         }
-    };
+    }
 }
 
 fn rich_text_from_style(text: &str, style: &easy_mark::Style) -> RichText {
@@ -162,7 +162,7 @@ fn bullet_point(ui: &mut Ui, width: f32) -> 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 row_height = ui.fonts_mut(|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();
diff --git a/crates/egui_demo_lib/src/lib.rs b/crates/egui_demo_lib/src/lib.rs
index 23c28bcb6..76be28859 100644
--- a/crates/egui_demo_lib/src/lib.rs
+++ b/crates/egui_demo_lib/src/lib.rs
@@ -35,7 +35,7 @@ macro_rules! egui_github_link_file {
     };
     ($label: expr) => {
         egui::github_link_file!(
-            "https://github.com/emilk/egui/blob/master/",
+            "https://github.com/emilk/egui/blob/main/",
             egui::RichText::new($label).small()
         )
     };
@@ -49,7 +49,7 @@ macro_rules! egui_github_link_file_line {
     };
     ($label: expr) => {
         egui::github_link_file_line!(
-            "https://github.com/emilk/egui/blob/master/",
+            "https://github.com/emilk/egui/blob/main/",
             egui::RichText::new($label).small()
         )
     };
@@ -109,6 +109,6 @@ fn test_egui_zero_window_size() {
 /// 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();
+    let screen_size = ctx.content_rect().size();
     screen_size.x < 550.0
 }
diff --git a/crates/egui_demo_lib/src/rendering_test.rs b/crates/egui_demo_lib/src/rendering_test.rs
index e83e643bb..e6f8b2c2d 100644
--- a/crates/egui_demo_lib/src/rendering_test.rs
+++ b/crates/egui_demo_lib/src/rendering_test.rs
@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 
 use egui::{
-    emath::GuiRounding as _, epaint, lerp, pos2, vec2, widgets::color_picker::show_color, Align2,
-    Color32, FontId, Image, Mesh, Pos2, Rect, Response, Rgba, RichText, Sense, Shape, Stroke,
-    TextureHandle, TextureOptions, Ui, Vec2,
+    Align2, Color32, FontId, Image, Mesh, Pos2, Rect, Response, Rgba, RichText, Sense, Shape,
+    Stroke, TextureHandle, TextureOptions, Ui, Vec2, emath::GuiRounding as _, epaint, lerp, pos2,
+    vec2, widgets::color_picker::show_color,
 };
 
 const GRADIENT_SIZE: Vec2 = vec2(256.0, 18.0);
@@ -92,8 +92,6 @@ impl ColorTest {
 
         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);
@@ -106,6 +104,9 @@ impl ColorTest {
                 show_color(ui, vertex_color, color_size);
                 ui.label(" vertex color =");
             });
+
+            ui.spacing_mut().item_spacing.y = 0.0; // No spacing between gradients
+
             {
                 let g = Gradient::one_color(ground_truth);
                 self.vertex_gradient(ui, "Ground truth (vertices)", WHITE, &g);
@@ -129,8 +130,36 @@ impl ColorTest {
 
         ui.separator();
 
+        ui.label("Test that blending is done in gamma space:");
+        ui.scope(|ui| {
+            let background = Color32::from_rgb(200, 60, 10);
+            let foreground = Color32::from_rgba_unmultiplied(108, 65, 200, 82);
+            let ground_truth = background.blend(foreground);
+
+            ui.horizontal(|ui| {
+                let color_size = ui.spacing().interact_size;
+                ui.label("Background:");
+                show_color(ui, background, color_size);
+                ui.label(", foreground: ");
+                show_color(ui, foreground, color_size);
+            });
+            ui.spacing_mut().item_spacing.y = 0.0; // No spacing between gradients
+            {
+                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);
+            }
+            {
+                let g = Gradient::one_color(foreground);
+                self.vertex_gradient(ui, "Vertex blending", background, &g);
+                self.tex_gradient(ui, "Texture blending", background, &g);
+            }
+        });
+
+        ui.separator();
+
         // TODO(emilk): test color multiplication (image tint),
-        // to make sure vertex and texture color multiplication is done in linear space.
+        // to make sure vertex and texture color multiplication is done in gamma space.
 
         ui.label("Gamma interpolation:");
         self.show_gradients(ui, WHITE, (RED, GREEN), Interpolation::Gamma);
@@ -162,8 +191,8 @@ impl ColorTest {
 
         ui.separator();
 
-        ui.label("Linear interpolation (texture sampling):");
-        self.show_gradients(ui, WHITE, (RED, GREEN), Interpolation::Linear);
+        ui.label("Texture interpolation (texture sampling) should be in gamma space:");
+        self.show_gradients(ui, WHITE, (RED, GREEN), Interpolation::Gamma);
     }
 
     fn show_gradients(
@@ -216,11 +245,10 @@ impl ColorTest {
             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::Linear => {}
                 Interpolation::Gamma => {
+                    self.tex_gradient(ui, "Texture of width 2 (test texture sampler)", bg_fill, &g);
+
                     // vertex shader uses gamma
                     self.vertex_gradient(
                         ui,
@@ -278,7 +306,10 @@ fn vertex_gradient(ui: &mut Ui, bg_fill: Color32, gradient: &Gradient) -> Respon
     }
     {
         let n = gradient.0.len();
-        assert!(n >= 2);
+        assert!(
+            n >= 2,
+            "A gradient must have at least two colors, but this had {n}"
+        );
         let mut mesh = Mesh::default();
         for (i, &color) in gradient.0.iter().enumerate() {
             let t = i as f32 / (n as f32 - 1.0);
@@ -298,7 +329,10 @@ fn vertex_gradient(ui: &mut Ui, bg_fill: Color32, gradient: &Gradient) -> Respon
 
 #[derive(Clone, Copy)]
 enum Interpolation {
+    /// egui used to want Linear interpolation for some things, but now we're always in gamma space.
+    #[expect(unused)]
     Linear,
+
     Gamma,
 }
 
@@ -387,10 +421,7 @@ impl TextureManager {
             let height = 1;
             ctx.load_texture(
                 "color_test_gradient",
-                epaint::ColorImage {
-                    size: [width, height],
-                    pixels,
-                },
+                epaint::ColorImage::new([width, height], pixels),
                 TextureOptions::LINEAR,
             )
         })
@@ -437,7 +468,7 @@ fn pixel_test_strokes(ui: &mut Ui) {
         let thickness_points = thickness_pixels / pixels_per_point;
         let num_squares = (pixels_per_point * 10.0).round().max(10.0) as u32;
         let size_pixels = vec2(ui.min_size().x, num_squares as f32 + thickness_pixels * 2.0);
-        let size_points = size_pixels / pixels_per_point + Vec2::splat(2.0);
+        let size_points = size_pixels / pixels_per_point;
         let (response, painter) = ui.allocate_painter(size_points, Sense::hover());
 
         let mut cursor_pixel = Pos2::new(
@@ -565,8 +596,14 @@ fn blending_and_feathering_test(ui: &mut Ui) {
 }
 
 fn text_on_bg(ui: &mut egui::Ui, fg: Color32, bg: Color32) {
-    assert!(fg.is_opaque());
-    assert!(bg.is_opaque());
+    assert!(
+        fg.is_opaque(),
+        "Foreground color must be opaque, but was: {fg:?}",
+    );
+    assert!(
+        bg.is_opaque(),
+        "Background color must be opaque, but was: {bg:?}",
+    );
 
     ui.horizontal(|ui| {
         ui.label(
@@ -687,8 +724,8 @@ fn mul_color_gamma(left: Color32, right: Color32) -> Color32 {
 #[cfg(test)]
 mod tests {
     use crate::ColorTest;
-    use egui_kittest::kittest::Queryable as _;
     use egui_kittest::SnapshotResults;
+    use egui_kittest::kittest::Queryable as _;
 
     #[test]
     pub fn rendering_test() {
@@ -702,14 +739,15 @@ mod tests {
                 });
 
             {
-                // Expand color-test collapsing header
-                harness.get_by_label("Color test").click();
+                // Expand color-test collapsing header. We accesskit-click since collapsing header
+                // might not be on screen at this point.
+                harness.get_by_label("Color test").click_accesskit();
                 harness.run();
             }
 
             harness.fit_contents();
 
-            results.add(harness.try_snapshot(&format!("rendering_test/dpi_{dpi:.2}")));
+            results.add(harness.try_snapshot(format!("rendering_test/dpi_{dpi:.2}")));
         }
     }
 }
diff --git a/crates/egui_demo_lib/tests/image_blending.rs b/crates/egui_demo_lib/tests/image_blending.rs
new file mode 100644
index 000000000..c8e5775a8
--- /dev/null
+++ b/crates/egui_demo_lib/tests/image_blending.rs
@@ -0,0 +1,25 @@
+use egui::{hex_color, include_image};
+use egui_kittest::Harness;
+
+#[test]
+fn test_image_blending() {
+    for pixels_per_point in [1.0, 2.0] {
+        let mut harness = Harness::builder()
+            .with_pixels_per_point(pixels_per_point)
+            .build_ui(|ui| {
+                egui_extras::install_image_loaders(ui.ctx());
+                egui::Frame::new()
+                    .fill(hex_color!("#5981FF"))
+                    .show(ui, |ui| {
+                        ui.add(
+                            egui::Image::new(include_image!("../data/ring.png"))
+                                .max_height(18.0)
+                                .tint(egui::Color32::GRAY),
+                        );
+                    });
+            });
+        harness.run();
+        harness.fit_contents();
+        harness.snapshot(format!("image_blending/image_x{pixels_per_point}"));
+    }
+}
diff --git a/crates/egui_demo_lib/tests/misc.rs b/crates/egui_demo_lib/tests/misc.rs
new file mode 100644
index 000000000..af8858bca
--- /dev/null
+++ b/crates/egui_demo_lib/tests/misc.rs
@@ -0,0 +1,75 @@
+use egui::{Color32, accesskit::Role};
+use egui_kittest::{Harness, kittest::Queryable as _};
+
+#[test]
+fn test_kerning() {
+    for pixels_per_point in [1.0, 2.0] {
+        for theme in [egui::Theme::Dark, egui::Theme::Light] {
+            let mut harness = Harness::builder()
+                .with_pixels_per_point(pixels_per_point)
+                .with_theme(theme)
+                .build_ui(|ui| {
+                    ui.label("Hello world!");
+                    ui.label("Repeated characters: iiiiiiiiiiiii lllllllll mmmmmmmmmmmmmmmm");
+                    ui.label("Thin spaces: −123 456 789");
+                    ui.label("Ligature: fi :)");
+                    ui.label("\ttabbed");
+                });
+            harness.run();
+            harness.fit_contents();
+            harness.snapshot(format!(
+                "image_kerning/image_{theme}_x{pixels_per_point}",
+                theme = match theme {
+                    egui::Theme::Dark => "dark",
+                    egui::Theme::Light => "light",
+                }
+            ));
+        }
+    }
+}
+
+#[test]
+fn test_italics() {
+    for pixels_per_point in [1.0, 2.0_f32.sqrt(), 2.0] {
+        for theme in [egui::Theme::Dark, egui::Theme::Light] {
+            let mut harness = Harness::builder()
+                .with_pixels_per_point(pixels_per_point)
+                .with_theme(theme)
+                .build_ui(|ui| {
+                    ui.label(egui::RichText::new("Small italics").italics().small());
+                    ui.label(egui::RichText::new("Normal italics").italics());
+                    ui.label(egui::RichText::new("Large italics").italics().size(22.0));
+                });
+            harness.run();
+            harness.fit_contents();
+            harness.snapshot(format!(
+                "italics/image_{theme}_x{pixels_per_point:.2}",
+                theme = match theme {
+                    egui::Theme::Dark => "dark",
+                    egui::Theme::Light => "light",
+                }
+            ));
+        }
+    }
+}
+
+#[test]
+fn test_text_selection() {
+    let mut harness = Harness::builder().build_ui(|ui| {
+        let visuals = ui.visuals_mut();
+        visuals.selection.bg_fill = Color32::LIGHT_GREEN;
+        visuals.selection.stroke.color = Color32::DARK_BLUE;
+
+        ui.label("Some varied ☺ text :)\nAnd it has a second line!");
+    });
+    harness.run();
+    harness.fit_contents();
+
+    // Drag to select text:
+    let label = harness.get_by_role(Role::Label);
+    harness.drag_at(label.rect().lerp_inside([0.2, 0.25]));
+    harness.drop_at(label.rect().lerp_inside([0.6, 0.75]));
+    harness.run();
+
+    harness.snapshot("text_selection");
+}
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Bézier Curve.png b/crates/egui_demo_lib/tests/snapshots/demos/Bézier Curve.png
index 190f7055c..fcab88179 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Bézier Curve.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Bézier Curve.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:536fa3adb51f69fac91396b50e26b3b18e0aa8ff245e4a187087b02240839a90
-size 31780
+oid sha256:30929184fab7e7d5975243d86bcab79cd9f7a0c5d57dd9ae827464ff6570be7b
+size 31795
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Clipboard Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Clipboard Test.png
new file mode 100644
index 000000000..373adc234
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Clipboard Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb944eca56724f6a2106ea8db2043dc94c0ea40bdd4cdeb0e520790f97cc9598
+size 27049
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Code Editor.png b/crates/egui_demo_lib/tests/snapshots/demos/Code Editor.png
index 8574b6d22..a62936ff2 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Code Editor.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Code Editor.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c129436a0b1dbfae999adfe0dcc6f5c4e0683c4e9b9a1e52f4b7bbb85ce3a462
-size 27162
+oid sha256:5e4a6476a2bb8980a9207868b77a253c65c0ba8433f843bb17e622856695b720
+size 27686
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Code Example.png b/crates/egui_demo_lib/tests/snapshots/demos/Code Example.png
index ed731869b..22341d7b3 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Code Example.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Code Example.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:322a50c522ba4ac67206332e1d251e121c8c3d5538ca7961880623b20f4933e5
-size 81732
+oid sha256:5c1951b99908326b3f05ebb72aa4d02d0f297bdd925f38ded09041fae45400c1
+size 85217
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Context Menus.png b/crates/egui_demo_lib/tests/snapshots/demos/Context Menus.png
index ea25033bf..ac3c736a0 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Context Menus.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Context Menus.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d4cc8e0919fed5bd1ef981658626dba728435ab95da8ee96ced1fb4838d535ff
-size 11741
+oid sha256:eb2bc4a38f20ed0f5fced36e8e56936bee328b24a0a45127d5d3739d40331cb7
+size 15514
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Cursor Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Cursor Test.png
new file mode 100644
index 000000000..9afd1794a
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Cursor Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c303fa620a2c7bc491a0ac1f9afdf9601b352e0e5163526c5f8732edf6bd6b3
+size 63404
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Dancing Strings.png b/crates/egui_demo_lib/tests/snapshots/demos/Dancing Strings.png
index d216ff1fe..05a412548 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Dancing Strings.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Dancing Strings.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d6ba28dacacf5b6f67746fb5187b601e222fd6baf190af2248fdc98909fc17fd
-size 25921
+oid sha256:0df751bac5947c9bf6f82d075cf5670a562742b80d6c512bcd642da5ed449d26
+size 25975
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Drag and Drop.png b/crates/egui_demo_lib/tests/snapshots/demos/Drag and Drop.png
index 097415b60..9b1b65636 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Drag and Drop.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Drag and Drop.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8196e08717f16c5ad17d0f84a4e57e63bb5a51c8f2b171071bf983af18ec161d
-size 20834
+oid sha256:0e26e87f2909414b614278a1cf0b485cda425aceb5419906426615dccdcbef2b
+size 20877
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Extra Viewport.png b/crates/egui_demo_lib/tests/snapshots/demos/Extra Viewport.png
index cc8c50e54..69d55cd27 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Extra Viewport.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Extra Viewport.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:df029c69651ee452cc4b265828280e47ffbcafb2958d71d67a5fe38f5211afe7
-size 10788
+oid sha256:20e3050bd41c7b9d225feb71f3bea3fdd1b8f749f77c4d140b5e560f53eb32b7
+size 10731
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Font Book.png b/crates/egui_demo_lib/tests/snapshots/demos/Font Book.png
index 230c7151e..2a12a3152 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Font Book.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Font Book.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0a62d309912501be8a5de7af4f1039a2a5731b1ed76fad17527f5783a5375f42
-size 133230
+oid sha256:1227636b03a7d35db3482b19f6059ec7aaf03ca795edadd5338056be6f6a8f7f
+size 126724
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Frame.png b/crates/egui_demo_lib/tests/snapshots/demos/Frame.png
index bfba77f18..0385ab120 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Frame.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Frame.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9870334dd6091fa684b78f487ad9a1bb39e6e8d97f987eb74a55de2d7b764f70
-size 24345
+oid sha256:c01e96bf0aab24dbcfc05f2a6dcb0ffcddff69ec2474797de4fbce0a0670a8cd
+size 24964
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Grid Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Grid Test.png
new file mode 100644
index 000000000..e14a4ecb5
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Grid Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec357eafd145194f99c36a53a149a8b331fd691c5088df43ee96282b84bc81a4
+size 99439
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Highlighting.png b/crates/egui_demo_lib/tests/snapshots/demos/Highlighting.png
index 7b14e8870..99cfc8f5d 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Highlighting.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Highlighting.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bae5f410ed30ef4dba6f3b529ae20e34a26f6c15c4cafd197899cf876271f5f1
-size 17828
+oid sha256:b5c95085e3c78b3fa1cc39ebd032834bd5ab5a80c3a2cad482d8a5bcbad004b9
+size 18064
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/ID Test.png b/crates/egui_demo_lib/tests/snapshots/demos/ID Test.png
new file mode 100644
index 000000000..f2d914cc2
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/ID Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28a69a52c07344576f2b5335497151e4e923b838dfaec9791402949ffb099c12
+size 116116
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Input Event History.png b/crates/egui_demo_lib/tests/snapshots/demos/Input Event History.png
new file mode 100644
index 000000000..c100d9209
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Input Event History.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1378d865af3df02e12a0c4bc087620a4e9ef0029221db3180cdd2fd34f69d7f
+size 24832
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Input Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Input Test.png
new file mode 100644
index 000000000..dd2d414a4
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Input Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb3f7b5f790830b46d1410c2bbb5e19c6beb403f8fe979eb8d250fba4f89be3e
+size 51670
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Interactive Container.png b/crates/egui_demo_lib/tests/snapshots/demos/Interactive Container.png
index d118733ba..1ef6bf0db 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Interactive Container.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Interactive Container.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:68ded8dccceb3da2764243f2a554c2b4cf825fca09008d60dd520c7fbb2c5d3e
-size 22445
+oid sha256:70b00222e6c63f97bfd8c7a179c15cfaba93f8f2566702d4b03997f4714fe6cb
+size 22609
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Layout Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Layout Test.png
new file mode 100644
index 000000000..ed84d7428
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Layout Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad26106a86a6236f0db1c51bed754b370530813e9bb6e36c1be2948820fbef25
+size 47827
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Manual Layout Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Manual Layout Test.png
new file mode 100644
index 000000000..9f42483fe
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Manual Layout Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afa66ba8daca5c00f9c49b1d9173ad8f5e826247d3a9369d7e7c360cbdfcb72e
+size 22928
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Misc Demos.png b/crates/egui_demo_lib/tests/snapshots/demos/Misc Demos.png
index 8aff2977f..919bdc66d 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Misc Demos.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Misc Demos.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d55baa6e3d4af44a35ec847639c35f968b05ad907352c45b3eb09cce6cd24280
-size 64357
+oid sha256:170cee9d72a4ab59aa2faf1b77aff4a9eee64f3380aa3f1b256340d88b1dabc2
+size 66525
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Modals.png b/crates/egui_demo_lib/tests/snapshots/demos/Modals.png
index 7c20eab75..47718fdd1 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Modals.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Modals.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:98f7210fa72bdb00364e3576aefca126a6f31eff52870d116ba74c167354b13b
-size 32533
+oid sha256:90ab689d8a5034f5cab2ae2b44a8054d6dd815b3d295bee040c5bfcdf4564dee
+size 33063
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Multi Touch.png b/crates/egui_demo_lib/tests/snapshots/demos/Multi Touch.png
index bd25e38a8..daa9da35a 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Multi Touch.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Multi Touch.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7868d662bd61d490dce9c049fca6c6e6b978255664fa709e959891bb40a7d434
-size 36577
+oid sha256:bf7f0a76424a959ede7afbb0eaf777638038cc6fe208ef710d9d82638d68b4d0
+size 37848
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Painting.png b/crates/egui_demo_lib/tests/snapshots/demos/Painting.png
index 749ecd471..e53f4f7af 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Painting.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Painting.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fb3d031b8f658a90cf98e7a7bc5e0d7a3b601d742e2a9469cd115e7466e06524
-size 17628
+oid sha256:2d2370972781f15a1d602deca28bca38f1c077152801870edf2112650b8b1349
+size 17708
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Panels.png b/crates/egui_demo_lib/tests/snapshots/demos/Panels.png
index a4527a73b..ca9bacfca 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Panels.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Panels.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7ace9a6626446f8e29ec4c3f688e60cbeb86e79ad962044858aabe33a9c3d0e9
-size 264538
+oid sha256:f7a7d0e2618b852b5966073438c95cb62901d5410c1473639920b0b0bf2ec59b
+size 256913
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Popups.png b/crates/egui_demo_lib/tests/snapshots/demos/Popups.png
new file mode 100644
index 000000000..d00256a7e
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Popups.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8b937a8a63de6fedcd0f9748b1d04cd863331a297bec78906885a0107def32a
+size 61242
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/SVG Test.png b/crates/egui_demo_lib/tests/snapshots/demos/SVG Test.png
new file mode 100644
index 000000000..f96fce916
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/SVG Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a11b0aeb8b8a7ff3acd54b99869af03cd04cc2edf13afc713ce924c52d39262d
+size 24826
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Scene.png b/crates/egui_demo_lib/tests/snapshots/demos/Scene.png
index e79968364..2344a3868 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Scene.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Scene.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7d412700c156c641f0184a239198f33bd2427a1ea998a3ee07160cf0f837df94
-size 35451
+oid sha256:2855bd95ab33b5232edada1f65684bbba2748025b6b64eb9ac68a5f2d10ad4bd
+size 34491
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Screenshot.png b/crates/egui_demo_lib/tests/snapshots/demos/Screenshot.png
index 803a39f99..7e49a8613 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Screenshot.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:89efd018caac097a5f9be37dcae15fc60b1475c72fc913ec9940540344e0b09f
-size 23622
+oid sha256:be599ae66323140bba4a7d63546acbf84340b57e2d82d4736bf3fe590040319d
+size 23623
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Scrolling.png b/crates/egui_demo_lib/tests/snapshots/demos/Scrolling.png
index 2e2af10c9..6de002ee4 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Scrolling.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Scrolling.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:22c89f7b9b84563d6ee7db0d9a66f6b95c9034261fdffca53ae9737d70d2b376
-size 183881
+oid sha256:01c3cb5e8972e0cab5325328f93af8f51b35a0d61016e74969eab0f7ddea1e02
+size 176973
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Sliders.png b/crates/egui_demo_lib/tests/snapshots/demos/Sliders.png
index e47f11082..417b183b5 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Sliders.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Sliders.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:316c172a936f215afdcc45e7f5b32400e6acd759551adb2cc741f7121b9d83eb
-size 117790
+oid sha256:f2f6cedc262259d52c1fbf4283d99b4b62ec732e8688b1e2799a2581425e0564
+size 120342
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Strip.png b/crates/egui_demo_lib/tests/snapshots/demos/Strip.png
index ea9a21881..be51e5062 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Strip.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Strip.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:88913690a2b225ca634e38406a6a852250019a19d9bb33a4242e77c10fe88422
-size 26142
+oid sha256:142f65cee971f82a4917734c4f49ae233aa9a873028dca8c807d2825672bf2b2
+size 26657
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Table.png b/crates/egui_demo_lib/tests/snapshots/demos/Table.png
index 3012f2f36..188c548d8 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Table.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Table.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:43b8dae4a936bf56b92368fcef64ff2ce2518aabc534a77fa578730493034f0f
-size 70536
+oid sha256:72f4c6fe4f5ec243506152027e1150f3069caf98511ceef92b8fea4f6a1563d5
+size 77614
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Tessellation Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Tessellation Test.png
new file mode 100644
index 000000000..cd8524cef
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Tessellation Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc24f146adf0282cfb51723b56c76eceb92f2988fc67bbeefd16b93950505922
+size 70110
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Text Layout.png b/crates/egui_demo_lib/tests/snapshots/demos/Text Layout.png
index 84f7cc7bd..28c9f57ac 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Text Layout.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Text Layout.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a307ac48abc79548c16468b3606a5df283ab2a5ac28345bd801bcc3887063414
-size 66384
+oid sha256:77aeaa1dcd391a571cb38732686e0b85b2d727975c02507a114d4e932f2c351b
+size 65562
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/TextEdit.png b/crates/egui_demo_lib/tests/snapshots/demos/TextEdit.png
index 93789ff45..3ee3adf6e 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/TextEdit.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/TextEdit.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6311be2b850b5e41ac6dadf639b00584438b56f651a3c8d75ac8f5e06c9ad6fa
-size 21224
+oid sha256:5f964939ed1b3904706592915ca4fbbb951855ac88b466c51b835cd1c7467fb0
+size 21501
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Tooltips.png b/crates/egui_demo_lib/tests/snapshots/demos/Tooltips.png
index 6d9aced18..265dfdc1e 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Tooltips.png
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Tooltips.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c80158ac9c823f94d2830d1423236ad441dc7da31e748b6815c69663fa2a03d0
-size 59662
+oid sha256:415b1ce17dd6df7ca7a86fed92750c2ef811ff64720a447ae3ca6be10090666e
+size 64624
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Undo Redo.png b/crates/egui_demo_lib/tests/snapshots/demos/Undo Redo.png
index 5f77c2db3..fb2bd06aa 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Undo Redo.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Undo Redo.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3584f16229bae50cc04b31df6bf5ccf43288fd05b447b34b29f118eb7435a090
-size 13103
+oid sha256:0eaf717bf0083737c4186ac39e7baf98f42fffb36b49434a6658eff1430a0ac6
+size 13187
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Window Options.png b/crates/egui_demo_lib/tests/snapshots/demos/Window Options.png
index 21b08252a..e782c983a 100644
--- a/crates/egui_demo_lib/tests/snapshots/demos/Window Options.png	
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Window Options.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3411a4a8939b7e731c9c1a6331921b0ac905f4e3e86a51af70bdb38d9446f5e1
-size 35193
+oid sha256:611a2d6c793a85eebe807b2ddd4446cc0bc21e4284343dd756e64f0232fb6815
+size 35991
diff --git a/crates/egui_demo_lib/tests/snapshots/demos/Window Resize Test.png b/crates/egui_demo_lib/tests/snapshots/demos/Window Resize Test.png
new file mode 100644
index 000000000..7a042bdba
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/demos/Window Resize Test.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b85a2af24c3361a0008fd0996e8d7244dc3e289646ec7233e8bad39a586c871c
+size 44512
diff --git a/crates/egui_demo_lib/tests/snapshots/image_blending/image_x1.png b/crates/egui_demo_lib/tests/snapshots/image_blending/image_x1.png
new file mode 100644
index 000000000..e06a95c92
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/image_blending/image_x1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:614046db82ef103f65bec3c09cc6afd9ee2b3835e9d32e2adff98f6d56714b22
+size 807
diff --git a/crates/egui_demo_lib/tests/snapshots/image_blending/image_x2.png b/crates/egui_demo_lib/tests/snapshots/image_blending/image_x2.png
new file mode 100644
index 000000000..42ee2f1dd
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/image_blending/image_x2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6298072b162623cec47d268fed5f8aa6189a2cf69074924a6eba26994fc6330
+size 2027
diff --git a/crates/egui_demo_lib/tests/snapshots/image_kerning/image_dark_x1.png b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_dark_x1.png
new file mode 100644
index 000000000..3d6c3f55c
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_dark_x1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67b709c116f56fba7e4e9f182018e84f46f6c6dd33a51f9d0524125dc2056b8c
+size 12950
diff --git a/crates/egui_demo_lib/tests/snapshots/image_kerning/image_dark_x2.png b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_dark_x2.png
new file mode 100644
index 000000000..e28eaeda9
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_dark_x2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b0a70c0d66306edbbc6f77d03ea624aa68b846656811d4cc7d76d28572d177b
+size 30723
diff --git a/crates/egui_demo_lib/tests/snapshots/image_kerning/image_light_x1.png b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_light_x1.png
new file mode 100644
index 000000000..391257018
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_light_x1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:137ba69ac73a5e9aacc6bf3bbd589e8640b41c50ccfb49edcda4e2d6efed6c09
+size 13384
diff --git a/crates/egui_demo_lib/tests/snapshots/image_kerning/image_light_x2.png b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_light_x2.png
new file mode 100644
index 000000000..f5e700ee3
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/image_kerning/image_light_x2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f798c666ad21d3f9bb57826e30f2f6ef044543bc05af8c185e0e63c8297e824
+size 33181
diff --git a/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x1.00.png b/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x1.00.png
new file mode 100644
index 000000000..0d70d6973
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x1.00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44fc7d745b478fe937fa7c131871a00b26712a0317aaa027a088782533be6136
+size 7125
diff --git a/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x1.41.png b/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x1.41.png
new file mode 100644
index 000000000..505c764d5
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x1.41.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abfa00ef9385d380bbd188d6254f92d6839a94f368100e75a2780337438f969f
+size 11068
diff --git a/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x2.00.png b/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x2.00.png
new file mode 100644
index 000000000..7c040d71a
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/italics/image_dark_x2.00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e5c9015e2005429ba83a407ed1f7d4dfbf30624f666152e82079c6ed3b3cda5
+size 17238
diff --git a/crates/egui_demo_lib/tests/snapshots/italics/image_light_x1.00.png b/crates/egui_demo_lib/tests/snapshots/italics/image_light_x1.00.png
new file mode 100644
index 000000000..b2291e9f1
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/italics/image_light_x1.00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3319a8bca1213fc3a2dd91ead155be1e25045bc614701250bc961848cfc42176
+size 7327
diff --git a/crates/egui_demo_lib/tests/snapshots/italics/image_light_x1.41.png b/crates/egui_demo_lib/tests/snapshots/italics/image_light_x1.41.png
new file mode 100644
index 000000000..995789de1
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/italics/image_light_x1.41.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5172aa12f07b4abf4bb217b8952b4cf5cf61b688455751964a1b54433d8c05b1
+size 11709
diff --git a/crates/egui_demo_lib/tests/snapshots/italics/image_light_x2.00.png b/crates/egui_demo_lib/tests/snapshots/italics/image_light_x2.00.png
new file mode 100644
index 000000000..8c5e7ab03
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/italics/image_light_x2.00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e3eedd952d4416af73179451c0c90bcb76635c9c3c94d37f42bdd228ddbdd03
+size 18802
diff --git a/crates/egui_demo_lib/tests/snapshots/modals_1.png b/crates/egui_demo_lib/tests/snapshots/modals_1.png
index 2036be3c9..a184b67dc 100644
--- a/crates/egui_demo_lib/tests/snapshots/modals_1.png
+++ b/crates/egui_demo_lib/tests/snapshots/modals_1.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1ac48ec9f7bde9869f1b3097e9f897b5e8df96cd6159a6ded542582dc69ab32c
-size 47913
+oid sha256:60a44771c6bc9236593717236f9eca40bcb4723bac7567493cab4326f003eba3
+size 48693
diff --git a/crates/egui_demo_lib/tests/snapshots/modals_2.png b/crates/egui_demo_lib/tests/snapshots/modals_2.png
index 60e6ddef5..c8e7cb55a 100644
--- a/crates/egui_demo_lib/tests/snapshots/modals_2.png
+++ b/crates/egui_demo_lib/tests/snapshots/modals_2.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:795e16389b31ad719050247eb9e736782380a83fa71b5b35b50e17812c8d9bdd
-size 47886
+oid sha256:53c1509f7be264ed2947cd4ec0f10b555e9f710e949ed6fd8a73ca8ade53abd4
+size 48570
diff --git a/crates/egui_demo_lib/tests/snapshots/modals_3.png b/crates/egui_demo_lib/tests/snapshots/modals_3.png
index 1ae5a3314..777b700c2 100644
--- a/crates/egui_demo_lib/tests/snapshots/modals_3.png
+++ b/crates/egui_demo_lib/tests/snapshots/modals_3.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a62a286e29aa0e0f949088ddefe01137535877408ba88778f61cbfe8d50c2261
-size 43750
+oid sha256:20eecafb998f69c2384afabc27eec1f97f413d603ece944adae9a99139be0b58
+size 44689
diff --git a/crates/egui_demo_lib/tests/snapshots/modals_backdrop_should_prevent_focusing_lower_area.png b/crates/egui_demo_lib/tests/snapshots/modals_backdrop_should_prevent_focusing_lower_area.png
index e059b556f..700eaf46b 100644
--- a/crates/egui_demo_lib/tests/snapshots/modals_backdrop_should_prevent_focusing_lower_area.png
+++ b/crates/egui_demo_lib/tests/snapshots/modals_backdrop_should_prevent_focusing_lower_area.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9c1bc8e22aa1050a4e7d1b2abe407251e22d338c38a7e41c045a384c9139b4de
-size 43895
+oid sha256:9a7f8282946761e6ab40193267e47a9421f5642bae67458a9aadb71ac1231c8f
+size 44581
diff --git a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.00.png b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.00.png
index e1b600fe5..640d84c2b 100644
--- a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.00.png
+++ b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.00.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:03ee62427611101758958adf2650a4a0eea4e023f07c9ec4ebc63425233e8a04
-size 554949
+oid sha256:f9980486c36a0242f3b043a172c411d4fc9573543d3cd7c1c43bf020c18868a9
+size 619816
diff --git a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.25.png b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.25.png
index ab9c8b818..df05ada25 100644
--- a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.25.png
+++ b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.25.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:82ef265f0e22649c7fcdb9556879c1a30df582bd4e97c647258b3e5acc03d112
-size 771298
+oid sha256:040e2e486ae4773a084da99513a53c620e8e2bba215183ec26c6e489381d6254
+size 823086
diff --git a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.50.png b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.50.png
index b2d8c3113..c6aa2914f 100644
--- a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.50.png
+++ b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.50.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cad71b486a479eb9c5339a93f4acc3df2d0b6b188ad023b9b044be7311b0ab72
-size 918775
+oid sha256:439a5f942a5f05b9c09685ef90be94c150a21a68d1d235af22372b9b6a7b7389
+size 1035734
diff --git a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.67.png b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.67.png
index 2056c3fa0..1344edcfb 100644
--- a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.67.png
+++ b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.67.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dc9ed4d29f4227b9d38b477ee8f546ea8597acda56a6909ba4826891ebdbea01
-size 1039263
+oid sha256:9b7d7e290b97a8042af3af3cd9ceb274950cf607dd7e9cd6c71d5a113d3b57a5
+size 1206155
diff --git a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.75.png b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.75.png
index 586916e56..9804e2942 100644
--- a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.75.png
+++ b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_1.75.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e9bf826bee811d8af345ec1281266fc9bef6d7c3782279516984a6c75130a929
-size 1130895
+oid sha256:fedd5546e36a89121c0bb0a780b0bbe081611c2c04013064872801181503fb83
+size 1231599
diff --git a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_2.00.png b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_2.00.png
index b764e7bee..04d4bb4ea 100644
--- a/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_2.00.png
+++ b/crates/egui_demo_lib/tests/snapshots/rendering_test/dpi_2.00.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9345de28f09e2891fd01db20bb0b94176ec3c89d8c2f344a6640d33e97ab5400
-size 1311417
+oid sha256:69a7040336fc92c6d7b158283aabbc5817980c2fa84a1120b788516cf437b985
+size 1461979
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Additive rectangle.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Additive rectangle.png
index 979991d13..50e84c900 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Additive rectangle.png	
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Additive rectangle.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5524138c3cb98aa71ef67083ad2d01813ab2394f93f9a7897f2e465ef5a1d0bc
-size 46270
+oid sha256:1a32d361afa20fc8c20122a89b01fe14b45849da42663991e589579f70fb8577
+size 46790
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred stroke.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred stroke.png
index 249b5db4d..ca5a23f97 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred stroke.png	
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred stroke.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bdf06c41b69eef1eadc8b46020e6e2a7b985a54e1cf75646ca47caaaea525b95
-size 88092
+oid sha256:c8d55205cf4225123da33895ed45eb186e5e57184ef5928400a4bae3ab6092be
+size 88548
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred.png
index c81deb054..41f9ef2f5 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred.png
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Blurred.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c5ca9c97cef8242ee6ff73d571479be12a8d4e9b3508b3eb6cdf93abda62f4e6
-size 120314
+oid sha256:77ab9e2e18c788f8cdbec171269afe4d0a90c52abeda7063cae3766dcaa5e93b
+size 120612
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Minimal rounding.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Minimal rounding.png
index 2a29cd732..85d844c79 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Minimal rounding.png	
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Minimal rounding.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f0481c97c34693b32575d96b1d4bc1238cbb0eb75a934661072f1b52ffee71cf
-size 52171
+oid sha256:36622a2f934503a7b60ded2f44b002e37eedde22d548dcf5a209f54c19548665
+size 53064
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Normal.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Normal.png
index b7d315e47..6e6d9f0f2 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Normal.png
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Normal.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:883fdf81e51bfe6333ddcad7998458db251f9cf513c9433179061d7d086eebe0
-size 55367
+oid sha256:4adeb7a77a0d0fe85097fcd190a99b49858dce11bde601d30335afcb6cc3d5f6
+size 56276
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thick stroke, minimal rounding.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thick stroke, minimal rounding.png
index 2fe78dd62..eefbac2bb 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thick stroke, minimal rounding.png	
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thick stroke, minimal rounding.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4294949669042e009ac6825ea599dc96e33cdde25e21174b01e3ef108ad478d5
-size 55944
+oid sha256:f45249f7cc90433a64856905c727571c4ef20468e2c7d3ac2029e18a0477932d
+size 56743
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin filled.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin filled.png
index 603442ac0..08178eaa8 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin filled.png	
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin filled.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:39e5d196ddcaa213b30b0655fe29881a1551c3036c2262f84af8960f66365300
-size 37207
+oid sha256:d437f68c521f3e627a1b50d46605e8b0b343c5fc3716d9669e8c4436c8992b6f
+size 37602
diff --git a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin stroked.png b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin stroked.png
index 266c77826..13f057df9 100644
--- a/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin stroked.png	
+++ b/crates/egui_demo_lib/tests/snapshots/tessellation_test/Thin stroked.png	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f9cf9d7f1921bfc0d61a2ae31e69a98d28280e4699823de5e732cdb102aee5ac
-size 37253
+oid sha256:08ba98437403a08cca825ed8e288c9f088a46d9a1081f0b0a4ed7fbb9b49bb85
+size 37640
diff --git a/crates/egui_demo_lib/tests/snapshots/text_selection.png b/crates/egui_demo_lib/tests/snapshots/text_selection.png
new file mode 100644
index 000000000..78ebc0dbf
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/text_selection.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14f253fedc94985ff1431f1016d901d747e1f9948531cc6350f6615649f29056
+size 4862
diff --git a/crates/egui_demo_lib/tests/snapshots/widget_gallery.png b/crates/egui_demo_lib/tests/snapshots/widget_gallery.png
deleted file mode 100644
index 87f13e8e5..000000000
--- a/crates/egui_demo_lib/tests/snapshots/widget_gallery.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:946bf96ae558ee7373b50bf11959e82b1f4d91866ec61b04b0336ae170b6f7b2
-size 158553
diff --git a/crates/egui_demo_lib/tests/snapshots/widget_gallery_dark_x1.png b/crates/egui_demo_lib/tests/snapshots/widget_gallery_dark_x1.png
new file mode 100644
index 000000000..ab2db5eb5
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/widget_gallery_dark_x1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1ed0e40d08b2b9ea978a07a4b7bf282c9e2cba8c52896f12210f396241e1b78
+size 66859
diff --git a/crates/egui_demo_lib/tests/snapshots/widget_gallery_dark_x2.png b/crates/egui_demo_lib/tests/snapshots/widget_gallery_dark_x2.png
new file mode 100644
index 000000000..e84863bf4
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/widget_gallery_dark_x2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28f9862dd6f16b99523f5880bf90346fd9455d0d44e7bdd530d523e0b2ef2d2c
+size 158892
diff --git a/crates/egui_demo_lib/tests/snapshots/widget_gallery_light_x1.png b/crates/egui_demo_lib/tests/snapshots/widget_gallery_light_x1.png
new file mode 100644
index 000000000..87eb5ce70
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/widget_gallery_light_x1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98c40c99a237f8388d82259fba4388d7b1759fe7b4bf657d326532934135c934
+size 61119
diff --git a/crates/egui_demo_lib/tests/snapshots/widget_gallery_light_x2.png b/crates/egui_demo_lib/tests/snapshots/widget_gallery_light_x2.png
new file mode 100644
index 000000000..c2c4705e1
--- /dev/null
+++ b/crates/egui_demo_lib/tests/snapshots/widget_gallery_light_x2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90d36311ce5b1dcf81cab22113620a3362f255059d1f52c6794c8249f960549e
+size 152215
diff --git a/crates/egui_extras/CHANGELOG.md b/crates/egui_extras/CHANGELOG.md
index d6cc2e9c8..9dbeb5879 100644
--- a/crates/egui_extras/CHANGELOG.md
+++ b/crates/egui_extras/CHANGELOG.md
@@ -5,6 +5,57 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+Nothing new
+
+
+## 0.33.0 - 2025-10-09
+* Fix: use unique id for resize columns in `Table` [#7414](https://github.com/emilk/egui/pull/7414) by [@zezic](https://github.com/zezic)
+* Feat: Add serde serialization to SyntectSettings [#7506](https://github.com/emilk/egui/pull/7506) by [@bircni](https://github.com/bircni)
+* Make individual egui_extras image loaders public [#7551](https://github.com/emilk/egui/pull/7551) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+
+
+## 0.32.3 - 2025-09-12
+* Fix deadlock in `FileLoader` and `EhttpLoader` [#7515](https://github.com/emilk/egui/pull/7515) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.2 - 2025-09-04
+* Fix memory leak when `forget_image` is called while loading [#7380](https://github.com/emilk/egui/pull/7380) by [@Vanadiae](https://github.com/Vanadiae)
+* Fix deadlock in `ImageLoader`, `FileLoader`, `EhttpLoader` [#7494](https://github.com/emilk/egui/pull/7494) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.32.1 - 2025-08-15
+Nothing new
+
+
+## 0.32.0 - 2025-07-10 - Improved SVG support
+### ⭐ Added
+* Allow loading multi-MIME formats using the image_loader [#5769](https://github.com/emilk/egui/pull/5769) by [@MYDIH](https://github.com/MYDIH)
+* Make ImageLoader use background thread [#5394](https://github.com/emilk/egui/pull/5394) by [@bircni](https://github.com/bircni)
+* Add overline option for Table rows [#5637](https://github.com/emilk/egui/pull/5637) by [@akx](https://github.com/akx)
+* Support text in SVGs [#5979](https://github.com/emilk/egui/pull/5979) by [@cernec1999](https://github.com/cernec1999)
+* Enable setting DatePickerButton start and end year explicitly [#7061](https://github.com/emilk/egui/pull/7061) by [@zachbateman](https://github.com/zachbateman)
+* Support custom syntect settings in syntax highlighter [#7084](https://github.com/emilk/egui/pull/7084) by [@mkeeter](https://github.com/mkeeter)
+
+### 🔧 Changed
+* Use enum-map serde feature only when serde is enabled [#5748](https://github.com/emilk/egui/pull/5748) by [@tyssyt](https://github.com/tyssyt)
+* Better define the meaning of `SizeHint` [#7079](https://github.com/emilk/egui/pull/7079) by [@emilk](https://github.com/emilk)
+
+### 🔥 Removed
+* Remove things that have been deprecated for over a year [#7099](https://github.com/emilk/egui/pull/7099) by [@emilk](https://github.com/emilk)
+
+### 🐛 Fixed
+* Refactor MIME type support detection in image loader to allow for deferred handling and appended encoding info [#5686](https://github.com/emilk/egui/pull/5686) by [@markusdd](https://github.com/markusdd)
+* Fix incorrect color fringe colors on SVG:s [#7069](https://github.com/emilk/egui/pull/7069) by [@emilk](https://github.com/emilk)
+* Fix sometimes blurry SVGs [#7071](https://github.com/emilk/egui/pull/7071) by [@emilk](https://github.com/emilk)
+* Fix crash in `egui_extras::FileLoader` after `forget_image` [#6995](https://github.com/emilk/egui/pull/6995) by [@bircni](https://github.com/bircni)
+
+
+## 0.31.1 - 2025-03-05
+* Fix image_loader for animated image types [#5688](https://github.com/emilk/egui/pull/5688) by [@BSteffaniak](https://github.com/BSteffaniak)
+
+
 ## 0.31.0 - 2025-02-04
 * Animated WebP support [#5470](https://github.com/emilk/egui/pull/5470), [#5586](https://github.com/emilk/egui/pull/5586) by [@Aely0](https://github.com/Aely0)
 * Make image extension check case-insensitive [#5501](https://github.com/emilk/egui/pull/5501) by [@RyanBluth](https://github.com/RyanBluth)
diff --git a/crates/egui_extras/Cargo.toml b/crates/egui_extras/Cargo.toml
index 89465f6d1..6639126ef 100644
--- a/crates/egui_extras/Cargo.toml
+++ b/crates/egui_extras/Cargo.toml
@@ -30,7 +30,7 @@ rustdoc-args = ["--generate-link-to-definition"]
 [features]
 default = ["dep:mime_guess2"]
 
-## Shorthand for enabling the different types of image loaders (`file`, `http`, `image`, `svg`).
+## Shorthand for enabling all the different types of image loaders.
 all_loaders = ["file", "http", "image", "svg", "gif", "webp"]
 
 ## Enable [`DatePickerButton`] widget.
@@ -57,11 +57,14 @@ http = ["dep:ehttp"]
 image = ["dep:image"]
 
 ## Derive serde Serialize/Deserialize on stateful structs
-serde = ["egui/serde", "dep:serde"]
+serde = ["egui/serde", "enum-map/serde", "dep:serde"]
 
 ## Support loading svg images.
 svg = ["resvg"]
 
+## Support rendering text in svg images.
+svg_text = ["svg", "resvg/text", "resvg/system-fonts"]
+
 ## Enable better syntax highlighting using [`syntect`](https://docs.rs/syntect).
 syntect = ["dep:syntect"]
 
@@ -70,7 +73,7 @@ syntect = ["dep:syntect"]
 egui = { workspace = true, default-features = false }
 
 ahash.workspace = true
-enum-map = { version = "2", features = ["serde"] }
+enum-map.workspace = true
 log.workspace = true
 profiling.workspace = true
 
@@ -80,12 +83,7 @@ profiling.workspace = true
 serde = { workspace = true, optional = true }
 
 # Date operations needed for datepicker widget
-chrono = { version = "0.4", optional = true, default-features = false, features = [
-  "clock",
-  "js-sys",
-  "std",
-  "wasmbind",
-] }
+chrono = { workspace = true, optional = true, features = ["clock", "js-sys", "std", "wasmbind"] }
 
 ## Enable this when generating docs.
 document-features = { workspace = true, optional = true }
@@ -93,15 +91,13 @@ document-features = { workspace = true, optional = true }
 image = { workspace = true, optional = true }
 
 # file feature
-mime_guess2 = { version = "2", optional = true, default-features = false }
+mime_guess2 = { workspace = true, optional = true }
 
-
-syntect = { version = "5", optional = true, default-features = false, features = [
-  "default-fancy",
-] }
+# syntax highlighting
+syntect = { workspace = true, optional = true, features = ["default-fancy"] }
 
 # svg feature
-resvg = { version = "0.37", optional = true, default-features = false }
+resvg = { workspace = true, optional = true }
 
 # http feature
-ehttp = { version = "0.5", optional = true, default-features = false }
+ehttp = { workspace = true, optional = true }
diff --git a/crates/egui_extras/src/datepicker/button.rs b/crates/egui_extras/src/datepicker/button.rs
index 601c16f67..a6e278286 100644
--- a/crates/egui_extras/src/datepicker/button.rs
+++ b/crates/egui_extras/src/datepicker/button.rs
@@ -1,6 +1,7 @@
 use super::popup::DatePickerPopup;
 use chrono::NaiveDate;
 use egui::{Area, Button, Frame, InnerResponse, Key, Order, RichText, Ui, Widget};
+use std::ops::RangeInclusive;
 
 #[derive(Default, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -19,6 +20,7 @@ pub struct DatePickerButton<'a> {
     show_icon: bool,
     format: String,
     highlight_weekends: bool,
+    start_end_years: Option<RangeInclusive<i32>>,
 }
 
 impl<'a> DatePickerButton<'a> {
@@ -33,6 +35,7 @@ impl<'a> DatePickerButton<'a> {
             show_icon: true,
             format: "%Y-%m-%d".to_owned(),
             highlight_weekends: true,
+            start_end_years: None,
         }
     }
 
@@ -101,6 +104,17 @@ impl<'a> DatePickerButton<'a> {
         self.highlight_weekends = highlight_weekends;
         self
     }
+
+    /// Set the start and end years for the date picker. (Default: today's year - 100 to today's year + 10)
+    /// This will limit the years you can choose from in the dropdown to the specified range.
+    ///
+    /// For example, if you want to provide the range of years from 2000 to 2035, you can use:
+    /// `start_end_years(2000..=2035)`.
+    #[inline]
+    pub fn start_end_years(mut self, start_end_years: RangeInclusive<i32>) -> Self {
+        self.start_end_years = Some(start_end_years);
+        self
+    }
 }
 
 impl Widget for DatePickerButton<'_> {
@@ -167,6 +181,7 @@ impl Widget for DatePickerButton<'_> {
                                 calendar: self.calendar,
                                 calendar_week: self.calendar_week,
                                 highlight_weekends: self.highlight_weekends,
+                                start_end_years: self.start_end_years,
                             }
                             .draw(ui)
                         })
@@ -177,7 +192,11 @@ impl Widget for DatePickerButton<'_> {
                 button_response.mark_changed();
             }
 
+            // We don't want to close our popup if any other popup is open, since other popups would
+            // most likely be the combo boxes in the date picker.
+            let any_popup_open = ui.ctx().is_popup_open();
             if !button_response.clicked()
+                && !any_popup_open
                 && (ui.input(|i| i.key_pressed(Key::Escape)) || area_response.clicked_elsewhere())
             {
                 button_state.picker_visible = false;
diff --git a/crates/egui_extras/src/datepicker/mod.rs b/crates/egui_extras/src/datepicker/mod.rs
index 33038d763..e7ba47e74 100644
--- a/crates/egui_extras/src/datepicker/mod.rs
+++ b/crates/egui_extras/src/datepicker/mod.rs
@@ -2,7 +2,7 @@ mod button;
 mod popup;
 
 pub use button::DatePickerButton;
-use chrono::{Datelike, Duration, NaiveDate, Weekday};
+use chrono::{Datelike as _, Duration, NaiveDate, Weekday};
 
 #[derive(Debug)]
 struct Week {
diff --git a/crates/egui_extras/src/datepicker/popup.rs b/crates/egui_extras/src/datepicker/popup.rs
index 8bf2f1a12..d353307b3 100644
--- a/crates/egui_extras/src/datepicker/popup.rs
+++ b/crates/egui_extras/src/datepicker/popup.rs
@@ -1,4 +1,4 @@
-use chrono::{Datelike, NaiveDate, Weekday};
+use chrono::{Datelike as _, NaiveDate, Weekday};
 
 use egui::{Align, Button, Color32, ComboBox, Direction, Id, Layout, RichText, Ui, Vec2};
 
@@ -35,6 +35,7 @@ pub(crate) struct DatePickerPopup<'a> {
     pub calendar: bool,
     pub calendar_week: bool,
     pub highlight_weekends: bool,
+    pub start_end_years: Option<std::ops::RangeInclusive<i32>>,
 }
 
 impl DatePickerPopup<'_> {
@@ -84,7 +85,11 @@ impl DatePickerPopup<'_> {
                                 ComboBox::from_id_salt("date_picker_year")
                                     .selected_text(popup_state.year.to_string())
                                     .show_ui(ui, |ui| {
-                                        for year in today.year() - 100..today.year() + 10 {
+                                        let (start_year, end_year) = match &self.start_end_years {
+                                            Some(range) => (*range.start(), *range.end()),
+                                            None => (today.year() - 100, today.year() + 10),
+                                        };
+                                        for year in start_year..=end_year {
                                             if ui
                                                 .selectable_value(
                                                     &mut popup_state.year,
@@ -331,7 +336,7 @@ impl DatePickerPopup<'_> {
                                                         if day.month() != popup_state.month {
                                                             text_color =
                                                                 text_color.linear_multiply(0.5);
-                                                        };
+                                                        }
 
                                                         let button_response = ui.add(
                                                             Button::new(
diff --git a/crates/egui_extras/src/image.rs b/crates/egui_extras/src/image.rs
index 46d9df170..b5ed70fa1 100644
--- a/crates/egui_extras/src/image.rs
+++ b/crates/egui_extras/src/image.rs
@@ -1,193 +1,6 @@
-#![allow(deprecated)]
-
-use egui::{mutex::Mutex, TextureOptions};
-
 #[cfg(feature = "svg")]
 use egui::SizeHint;
 
-/// 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.
-///
-/// ⚠ This type is deprecated: Consider using [`egui::Image`] instead.
-#[deprecated = "consider using `egui::Image` instead"]
-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: egui::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.25", 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).map_err(|err| err.to_string())?,
-        ))
-    }
-
-    /// 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, None)
-    }
-
-    /// 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_hint: Option<SizeHint>,
-    ) -> Result<Self, String> {
-        Ok(Self::from_color_image(
-            debug_name,
-            load_svg_bytes_with_size(svg_bytes, size_hint)?,
-        ))
-    }
-
-    /// 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);
-    /// ```
-    #[inline]
-    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
-    }
-
-    /// 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 id for this image.
-    pub fn texture_id(&self, ctx: &egui::Context) -> egui::TextureId {
-        self.texture
-            .lock()
-            .get_or_insert_with(|| {
-                let image: &mut egui::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))
-    }
-}
-
 // ----------------------------------------------------------------------------
 
 /// Load a (non-svg) image.
@@ -214,6 +27,10 @@ pub fn load_image_bytes(image_bytes: &[u8]) -> Result<egui::ColorImage, egui::lo
     let size = [image.width() as _, image.height() as _];
     let image_buffer = image.to_rgba8();
     let pixels = image_buffer.as_flat_samples();
+
+    // TODO(emilk): if this is a PNG, looks for DPI info to calculate the source size,
+    // e.g. for screenshots taken on a high-DPI/retina display.
+
     Ok(egui::ColorImage::from_rgba_unmultiplied(
         size,
         pixels.as_slice(),
@@ -227,8 +44,11 @@ pub fn load_image_bytes(image_bytes: &[u8]) -> Result<egui::ColorImage, egui::lo
 /// # 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, None)
+pub fn load_svg_bytes(
+    svg_bytes: &[u8],
+    options: &resvg::usvg::Options<'_>,
+) -> Result<egui::ColorImage, String> {
+    load_svg_bytes_with_size(svg_bytes, Default::default(), options)
 }
 
 /// Load an SVG and rasterize it into an egui image with a scaling parameter.
@@ -240,51 +60,58 @@ pub fn load_svg_bytes(svg_bytes: &[u8]) -> Result<egui::ColorImage, String> {
 #[cfg(feature = "svg")]
 pub fn load_svg_bytes_with_size(
     svg_bytes: &[u8],
-    size_hint: Option<SizeHint>,
+    size_hint: SizeHint,
+    options: &resvg::usvg::Options<'_>,
 ) -> Result<egui::ColorImage, String> {
-    use resvg::tiny_skia::{IntSize, Pixmap};
-    use resvg::usvg::{Options, Tree, TreeParsing};
+    use egui::Vec2;
+    use resvg::{
+        tiny_skia::Pixmap,
+        usvg::{Transform, Tree},
+    };
 
     profiling::function_scope!();
 
-    let opt = Options::default();
+    let rtree = Tree::from_data(svg_bytes, options).map_err(|err| err.to_string())?;
 
-    let mut rtree = Tree::from_data(svg_bytes, &opt).map_err(|err| err.to_string())?;
+    let source_size = Vec2::new(rtree.size().width(), rtree.size().height());
 
-    let mut size = rtree.size.to_int_size();
-    match size_hint {
-        None => (),
-        Some(SizeHint::Size(w, h)) => {
-            size = size.scale_to(
-                IntSize::from_wh(w, h).ok_or_else(|| format!("Failed to scale SVG to {w}x{h}"))?,
-            );
-        }
-        Some(SizeHint::Height(h)) => {
-            size = size
-                .scale_to_height(h)
-                .ok_or_else(|| format!("Failed to scale SVG to height {h}"))?;
-        }
-        Some(SizeHint::Width(w)) => {
-            size = size
-                .scale_to_width(w)
-                .ok_or_else(|| format!("Failed to scale SVG to width {w}"))?;
-        }
-        Some(SizeHint::Scale(z)) => {
-            let z_inner = z.into_inner();
-            size = size
-                .scale_by(z_inner)
-                .ok_or_else(|| format!("Failed to scale SVG by {z_inner}"))?;
+    let scaled_size = match size_hint {
+        SizeHint::Size {
+            width,
+            height,
+            maintain_aspect_ratio,
+        } => {
+            if maintain_aspect_ratio {
+                // As large as possible, without exceeding the given size:
+                let mut size = source_size;
+                size *= width as f32 / source_size.x;
+                if size.y > height as f32 {
+                    size *= height as f32 / size.y;
+                }
+                size
+            } else {
+                Vec2::new(width as _, height as _)
+            }
         }
+        SizeHint::Height(h) => source_size * (h as f32 / source_size.y),
+        SizeHint::Width(w) => source_size * (w as f32 / source_size.x),
+        SizeHint::Scale(scale) => scale.into_inner() * source_size,
     };
-    let (w, h) = (size.width(), size.height());
+
+    let scaled_size = scaled_size.round();
+    let (w, h) = (scaled_size.x as u32, scaled_size.y as u32);
 
     let mut pixmap =
         Pixmap::new(w, h).ok_or_else(|| format!("Failed to create SVG Pixmap of size {w}x{h}"))?;
 
-    rtree.size = size.to_size();
-    resvg::Tree::from_usvg(&rtree).render(Default::default(), &mut pixmap.as_mut());
+    resvg::render(
+        &rtree,
+        Transform::from_scale(w as f32 / source_size.x, h as f32 / source_size.y),
+        &mut pixmap.as_mut(),
+    );
 
-    let image = egui::ColorImage::from_rgba_unmultiplied([w as _, h as _], pixmap.data());
+    let image = egui::ColorImage::from_rgba_premultiplied([w as _, h as _], pixmap.data())
+        .with_source_size(source_size);
 
     Ok(image)
 }
diff --git a/crates/egui_extras/src/layout.rs b/crates/egui_extras/src/layout.rs
index fb84169f3..594763daf 100644
--- a/crates/egui_extras/src/layout.rs
+++ b/crates/egui_extras/src/layout.rs
@@ -1,4 +1,4 @@
-use egui::{emath::GuiRounding, Id, Pos2, Rect, Response, Sense, Ui, UiBuilder};
+use egui::{Id, Pos2, Rect, Response, Sense, Ui, UiBuilder, emath::GuiRounding as _};
 
 #[derive(Clone, Copy)]
 pub(crate) enum CellSize {
@@ -33,8 +33,9 @@ pub(crate) struct StripLayoutFlags {
     pub(crate) striped: bool,
     pub(crate) hovered: bool,
     pub(crate) selected: bool,
+    pub(crate) overline: bool,
 
-    /// Used when we want to accruately measure the size of this cell.
+    /// Used when we want to accurately measure the size of this cell.
     pub(crate) sizing_pass: bool,
 }
 
@@ -161,7 +162,7 @@ impl<'l> StripLayout<'l> {
         } else if flags.clip {
             max_rect
         } else {
-            max_rect.union(used_rect)
+            max_rect | used_rect
         };
 
         self.set_pos(allocation_rect);
@@ -232,6 +233,14 @@ impl<'l> StripLayout<'l> {
             child_ui.style_mut().visuals.override_text_color = Some(stroke_color);
         }
 
+        if flags.overline {
+            child_ui.painter().hline(
+                max_rect.x_range(),
+                max_rect.top(),
+                child_ui.visuals().widgets.noninteractive.bg_stroke,
+            );
+        }
+
         add_cell_contents(&mut child_ui);
 
         child_ui
diff --git a/crates/egui_extras/src/lib.rs b/crates/egui_extras/src/lib.rs
index 6f3390102..16354c440 100644
--- a/crates/egui_extras/src/lib.rs
+++ b/crates/egui_extras/src/lib.rs
@@ -17,7 +17,7 @@ pub mod syntax_highlighting;
 #[doc(hidden)]
 pub mod image;
 mod layout;
-mod loaders;
+pub mod loaders;
 mod sizing;
 mod strip;
 mod table;
@@ -25,9 +25,6 @@ mod table;
 #[cfg(feature = "chrono")]
 pub use crate::datepicker::DatePickerButton;
 
-#[doc(hidden)]
-#[allow(deprecated)]
-pub use crate::image::RetainedImage;
 pub(crate) use crate::layout::StripLayout;
 pub use crate::sizing::Size;
 pub use crate::strip::*;
diff --git a/crates/egui_extras/src/loaders.rs b/crates/egui_extras/src/loaders.rs
index 03b1abfc9..f73604896 100644
--- a/crates/egui_extras/src/loaders.rs
+++ b/crates/egui_extras/src/loaders.rs
@@ -63,9 +63,9 @@ pub fn install_image_loaders(ctx: &egui::Context) {
     }
 
     #[cfg(feature = "http")]
-    if !ctx.is_loader_installed(self::ehttp_loader::EhttpLoader::ID) {
+    if !ctx.is_loader_installed(self::http_loader::EhttpLoader::ID) {
         ctx.add_bytes_loader(std::sync::Arc::new(
-            self::ehttp_loader::EhttpLoader::default(),
+            self::http_loader::EhttpLoader::default(),
         ));
         log::trace!("installed EhttpLoader");
     }
@@ -108,16 +108,16 @@ pub fn install_image_loaders(ctx: &egui::Context) {
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-mod file_loader;
+pub mod file_loader;
 
 #[cfg(feature = "http")]
-mod ehttp_loader;
+pub mod http_loader;
 
 #[cfg(feature = "gif")]
-mod gif_loader;
+pub mod gif_loader;
 #[cfg(feature = "image")]
-mod image_loader;
+pub mod image_loader;
 #[cfg(feature = "svg")]
-mod svg_loader;
+pub mod svg_loader;
 #[cfg(feature = "webp")]
-mod webp_loader;
+pub mod webp_loader;
diff --git a/crates/egui_extras/src/loaders/file_loader.rs b/crates/egui_extras/src/loaders/file_loader.rs
index 5d1b45fb4..13fd7ca69 100644
--- a/crates/egui_extras/src/loaders/file_loader.rs
+++ b/crates/egui_extras/src/loaders/file_loader.rs
@@ -95,10 +95,23 @@ impl BytesLoader for FileLoader {
                             }
                             Err(err) => Err(err.to_string()),
                         };
-                        let prev = cache.lock().insert(uri.clone(), Poll::Ready(result));
-                        assert!(matches!(prev, Some(Poll::Pending)));
-                        ctx.request_repaint();
-                        log::trace!("finished loading {uri:?}");
+                        let repaint = {
+                            let mut cache = cache.lock();
+                            if let std::collections::hash_map::Entry::Occupied(mut entry) = cache.entry(uri.clone()) {
+                                let entry = entry.get_mut();
+                                *entry = Poll::Ready(result);
+                                log::trace!("Finished loading {uri:?}");
+                                true
+                            } else {
+                                log::trace!("Canceled loading {uri:?}\nNote: This can happen if `forget_image` is called while the image is still loading.");
+                                false
+                            }
+                        };
+                        // We may not lock Context while the cache lock is held (see ImageLoader::load
+                        // for details).
+                        if repaint {
+                            ctx.request_repaint();
+                        }
                     }
                 })
                 .expect("failed to spawn thread");
@@ -128,4 +141,8 @@ impl BytesLoader for FileLoader {
             })
             .sum()
     }
+
+    fn has_pending(&self) -> bool {
+        self.cache.lock().values().any(|entry| entry.is_pending())
+    }
 }
diff --git a/crates/egui_extras/src/loaders/gif_loader.rs b/crates/egui_extras/src/loaders/gif_loader.rs
index a92cbc33e..9f0786cfb 100644
--- a/crates/egui_extras/src/loaders/gif_loader.rs
+++ b/crates/egui_extras/src/loaders/gif_loader.rs
@@ -1,9 +1,8 @@
 use ahash::HashMap;
 use egui::{
-    decode_animated_image_uri, has_gif_magic_header,
+    ColorImage, FrameDurations, Id, decode_animated_image_uri, has_gif_magic_header,
     load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
     mutex::Mutex,
-    ColorImage, FrameDurations, Id,
 };
 use image::AnimationDecoder as _;
 use std::{io::Cursor, mem::size_of, sync::Arc, time::Duration};
diff --git a/crates/egui_extras/src/loaders/ehttp_loader.rs b/crates/egui_extras/src/loaders/http_loader.rs
similarity index 75%
rename from crates/egui_extras/src/loaders/ehttp_loader.rs
rename to crates/egui_extras/src/loaders/http_loader.rs
index 79c776948..d1cc68df9 100644
--- a/crates/egui_extras/src/loaders/ehttp_loader.rs
+++ b/crates/egui_extras/src/loaders/http_loader.rs
@@ -19,13 +19,13 @@ impl File {
                     return Err(format!(
                         "failed to load {uri:?}: {} {} {response_text}",
                         response.status, response.status_text
-                    ))
+                    ));
                 }
                 None => {
                     return Err(format!(
                         "failed to load {uri:?}: {} {}",
                         response.status, response.status_text
-                    ))
+                    ));
                 }
             }
         }
@@ -94,9 +94,27 @@ impl BytesLoader for EhttpLoader {
                             Err(format!("Failed to load {uri:?}"))
                         }
                     };
-                    log::trace!("finished loading {uri:?}");
-                    cache.lock().insert(uri, Poll::Ready(result));
-                    ctx.request_repaint();
+                    let repaint = {
+                        let mut cache = cache.lock();
+                        if let std::collections::hash_map::Entry::Occupied(mut entry) =
+                            cache.entry(uri.clone())
+                        {
+                            let entry = entry.get_mut();
+                            *entry = Poll::Ready(result);
+                            log::trace!("Finished loading {uri:?}");
+                            true
+                        } else {
+                            log::trace!(
+                                "Canceled loading {uri:?}\nNote: This can happen if `forget_image` is called while the image is still loading."
+                            );
+                            false
+                        }
+                    };
+                    // We may not lock Context while the cache lock is held (see ImageLoader::load
+                    // for details).
+                    if repaint {
+                        ctx.request_repaint();
+                    }
                 }
             });
 
@@ -125,4 +143,8 @@ impl BytesLoader for EhttpLoader {
             })
             .sum()
     }
+
+    fn has_pending(&self) -> bool {
+        self.cache.lock().values().any(|entry| entry.is_pending())
+    }
 }
diff --git a/crates/egui_extras/src/loaders/image_loader.rs b/crates/egui_extras/src/loaders/image_loader.rs
index 171e56170..6d735f688 100644
--- a/crates/egui_extras/src/loaders/image_loader.rs
+++ b/crates/egui_extras/src/loaders/image_loader.rs
@@ -1,17 +1,20 @@
 use ahash::HashMap;
 use egui::{
-    load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
+    ColorImage, decode_animated_image_uri,
+    load::{Bytes, BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
     mutex::Mutex,
-    ColorImage,
 };
 use image::ImageFormat;
-use std::{mem::size_of, path::Path, sync::Arc};
+use std::{mem::size_of, path::Path, sync::Arc, task::Poll};
 
-type Entry = Result<Arc<ColorImage>, LoadError>;
+#[cfg(not(target_arch = "wasm32"))]
+use std::thread;
+
+type Entry = Poll<Result<Arc<ColorImage>, String>>;
 
 #[derive(Default)]
 pub struct ImageCrateLoader {
-    cache: Mutex<HashMap<String, Entry>>,
+    cache: Arc<Mutex<HashMap<String, Entry>>>,
 }
 
 impl ImageCrateLoader {
@@ -28,23 +31,27 @@ fn is_supported_uri(uri: &str) -> bool {
     };
 
     // Uses only the enabled image crate features
-    ImageFormat::all()
-        .filter(ImageFormat::reading_enabled)
-        .flat_map(ImageFormat::extensions_str)
-        .any(|format_ext| ext == *format_ext)
+    ImageFormat::from_extension(ext).is_some_and(|format| format.reading_enabled())
 }
 
 fn is_supported_mime(mime: &str) -> bool {
-    // This is the default mime type for binary files, so this might actually be a valid image,
-    // let's relay on image's format guessing
-    if mime == "application/octet-stream" {
-        return true;
+    // some mime types e.g. reflect binary files or mark the content as a download, which
+    // may be a valid image or not, in this case, defer the decision on the format guessing
+    // or the image crate and return true here
+    let mimes_to_defer = [
+        "application/octet-stream",
+        "application/x-msdownload",
+        "application/force-download",
+    ];
+    for m in &mimes_to_defer {
+        // use contains instead of direct equality, as e.g. encoding info might be appended
+        if mime.contains(m) {
+            return true;
+        }
     }
+
     // Uses only the enabled image crate features
-    ImageFormat::all()
-        .filter(ImageFormat::reading_enabled)
-        .map(|fmt| fmt.to_mime_type())
-        .any(|format_mime| mime == format_mime)
+    ImageFormat::from_mime_type(mime).is_some_and(|format| format.reading_enabled())
 }
 
 impl ImageLoader for ImageCrateLoader {
@@ -58,41 +65,110 @@ impl ImageLoader for ImageCrateLoader {
         // 2. Mime from `BytesPoll::Ready`
         // 3. image::guess_format (used internally by image::load_from_memory)
 
+        // TODO(lucasmerlin): Egui currently changes all URIs for webp and gif files to include
+        // the frame index (#0), which breaks if the animated image loader is disabled.
+        // We work around this by removing the frame index from the URI here
+        let uri = decode_animated_image_uri(uri).map_or(uri, |(uri, _frame_index)| uri);
+
         // (1)
         if uri.starts_with("file://") && !is_supported_uri(uri) {
             return Err(LoadError::NotSupported);
         }
 
-        let mut cache = self.cache.lock();
-        if let Some(entry) = cache.get(uri).cloned() {
-            match entry {
+        #[cfg(not(target_arch = "wasm32"))]
+        #[expect(clippy::unnecessary_wraps)] // needed here to match other return types
+        fn load_image(
+            ctx: &egui::Context,
+            uri: &str,
+            cache: &Arc<Mutex<HashMap<String, Entry>>>,
+            bytes: &Bytes,
+        ) -> ImageLoadResult {
+            let uri = uri.to_owned();
+            cache.lock().insert(uri.clone(), Poll::Pending);
+
+            // Do the image parsing on a bg thread
+            thread::Builder::new()
+                .name(format!("egui_extras::ImageLoader::load({uri:?})"))
+                .spawn({
+                    let ctx = ctx.clone();
+                    let cache = cache.clone();
+
+                    let uri = uri.clone();
+                    let bytes = bytes.clone();
+                    move || {
+                        log::trace!("ImageLoader - started loading {uri:?}");
+                        let result = crate::image::load_image_bytes(&bytes)
+                            .map(Arc::new)
+                            .map_err(|err| err.to_string());
+                        let repaint = {
+                            let mut cache = cache.lock();
+
+                            if let std::collections::hash_map::Entry::Occupied(mut entry) = cache.entry(uri.clone()) {
+                                let entry = entry.get_mut();
+                                *entry = Poll::Ready(result);
+                                log::trace!("ImageLoader - finished loading {uri:?}");
+                                true
+                            } else {
+                                log::trace!("ImageLoader - canceled loading {uri:?}\nNote: This can happen if `forget_image` is called while the image is still loading.");
+                                false
+                            }
+                        };
+                        // We may not lock Context while the cache lock is held, since this can
+                        // deadlock.
+                        // Example deadlock scenario:
+                        // - loader thread: lock cache
+                        // - main thread: lock ctx (e.g. in `Context::has_pending_images`)
+                        // - loader thread: try to lock ctx (in `request_repaint`)
+                        // - main thread: try to lock cache (from `Self::has_pending`)
+                        if repaint {
+                            ctx.request_repaint();
+                        }
+                    }
+                })
+                .expect("failed to spawn thread");
+
+            Ok(ImagePoll::Pending { size: None })
+        }
+
+        #[cfg(target_arch = "wasm32")]
+        fn load_image(
+            _ctx: &egui::Context,
+            uri: &str,
+            cache: &Arc<Mutex<HashMap<String, Entry>>>,
+            bytes: &Bytes,
+        ) -> ImageLoadResult {
+            let mut cache_lock = cache.lock();
+            log::trace!("started loading {uri:?}");
+            let result = crate::image::load_image_bytes(bytes)
+                .map(Arc::new)
+                .map_err(|err| err.to_string());
+            log::trace!("finished loading {uri:?}");
+            cache_lock.insert(uri.into(), std::task::Poll::Ready(result.clone()));
+            match result {
                 Ok(image) => Ok(ImagePoll::Ready { image }),
-                Err(err) => Err(err),
+                Err(err) => Err(LoadError::Loading(err)),
+            }
+        }
+
+        let entry = self.cache.lock().get(uri).cloned();
+        if let Some(entry) = entry {
+            match entry {
+                Poll::Ready(Ok(image)) => Ok(ImagePoll::Ready { image }),
+                Poll::Ready(Err(err)) => Err(LoadError::Loading(err)),
+                Poll::Pending => Ok(ImagePoll::Pending { size: None }),
             }
         } else {
             match ctx.try_load_bytes(uri) {
                 Ok(BytesPoll::Ready { bytes, mime, .. }) => {
                     // (2)
-                    if let Some(mime) = mime {
-                        if !is_supported_mime(&mime) {
-                            return Err(LoadError::FormatNotSupported {
-                                detected_format: Some(mime),
-                            });
-                        }
-                    }
-
-                    if bytes.starts_with(b"version https://git-lfs") {
+                    if let Some(mime) = mime
+                        && !is_supported_mime(&mime)
+                    {
                         return Err(LoadError::FormatNotSupported {
-                            detected_format: Some("git-lfs".to_owned()),
+                            detected_format: Some(mime),
                         });
                     }
-
-                    // (3)
-                    log::trace!("started loading {uri:?}");
-                    let result = crate::image::load_image_bytes(&bytes).map(Arc::new);
-                    log::trace!("finished loading {uri:?}");
-                    cache.insert(uri.into(), result.clone());
-                    result.map(|image| ImagePoll::Ready { image })
+                    load_image(ctx, uri, &self.cache, &bytes)
                 }
                 Ok(BytesPoll::Pending { size }) => Ok(ImagePoll::Pending { size }),
                 Err(err) => Err(err),
@@ -113,11 +189,16 @@ impl ImageLoader for ImageCrateLoader {
             .lock()
             .values()
             .map(|result| match result {
-                Ok(image) => image.pixels.len() * size_of::<egui::Color32>(),
-                Err(err) => err.byte_size(),
+                Poll::Ready(Ok(image)) => image.pixels.len() * size_of::<egui::Color32>(),
+                Poll::Ready(Err(err)) => err.len(),
+                Poll::Pending => 0,
             })
             .sum()
     }
+
+    fn has_pending(&self) -> bool {
+        self.cache.lock().values().any(|result| result.is_pending())
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/egui_extras/src/loaders/svg_loader.rs b/crates/egui_extras/src/loaders/svg_loader.rs
index 2a3f15569..4b778ff9e 100644
--- a/crates/egui_extras/src/loaders/svg_loader.rs
+++ b/crates/egui_extras/src/loaders/svg_loader.rs
@@ -1,18 +1,28 @@
-use std::{borrow::Cow, mem::size_of, path::Path, sync::Arc};
+use std::{
+    mem::size_of,
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering::Relaxed},
+    },
+};
 
 use ahash::HashMap;
 
 use egui::{
+    ColorImage,
     load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
     mutex::Mutex,
-    ColorImage,
 };
 
-type Entry = Result<Arc<ColorImage>, String>;
+struct Entry {
+    last_used: AtomicU64,
+    result: Result<Arc<ColorImage>, String>,
+}
 
-#[derive(Default)]
 pub struct SvgLoader {
-    cache: Mutex<HashMap<(Cow<'static, str>, SizeHint), Entry>>,
+    pass_index: AtomicU64,
+    cache: Mutex<HashMap<String, HashMap<SizeHint, Entry>>>,
+    options: resvg::usvg::Options<'static>,
 }
 
 impl SvgLoader {
@@ -20,11 +30,24 @@ impl SvgLoader {
 }
 
 fn is_supported(uri: &str) -> bool {
-    let Some(ext) = Path::new(uri).extension().and_then(|ext| ext.to_str()) else {
-        return false;
-    };
+    uri.ends_with(".svg")
+}
 
-    ext == "svg"
+impl Default for SvgLoader {
+    fn default() -> Self {
+        // opt is mutated when `svg_text` feature flag is enabled
+        #[allow(unused_mut, clippy::allow_attributes)]
+        let mut options = resvg::usvg::Options::default();
+
+        #[cfg(feature = "svg_text")]
+        options.fontdb_mut().load_system_fonts();
+
+        Self {
+            pass_index: AtomicU64::new(0),
+            cache: Mutex::new(HashMap::default()),
+            options,
+        }
+    }
 }
 
 impl ImageLoader for SvgLoader {
@@ -38,20 +61,32 @@ impl ImageLoader for SvgLoader {
         }
 
         let mut cache = self.cache.lock();
-        // We can't avoid the `uri` clone here without unsafe code.
-        if let Some(entry) = cache.get(&(Cow::Borrowed(uri), size_hint)).cloned() {
-            match entry {
+        let bucket = cache.entry(uri.to_owned()).or_default();
+
+        if let Some(entry) = bucket.get(&size_hint) {
+            entry
+                .last_used
+                .store(self.pass_index.load(Relaxed), Relaxed);
+            match entry.result.clone() {
                 Ok(image) => Ok(ImagePoll::Ready { image }),
                 Err(err) => Err(LoadError::Loading(err)),
             }
         } else {
             match ctx.try_load_bytes(uri) {
                 Ok(BytesPoll::Ready { bytes, .. }) => {
-                    log::trace!("started loading {uri:?}");
-                    let result = crate::image::load_svg_bytes_with_size(&bytes, Some(size_hint))
-                        .map(Arc::new);
-                    log::trace!("finished loading {uri:?}");
-                    cache.insert((Cow::Owned(uri.to_owned()), size_hint), result.clone());
+                    log::trace!("Started loading {uri:?}");
+                    let result =
+                        crate::image::load_svg_bytes_with_size(&bytes, size_hint, &self.options)
+                            .map(Arc::new);
+
+                    log::trace!("Finished loading {uri:?}");
+                    bucket.insert(
+                        size_hint,
+                        Entry {
+                            last_used: AtomicU64::new(self.pass_index.load(Relaxed)),
+                            result: result.clone(),
+                        },
+                    );
                     match result {
                         Ok(image) => Ok(ImagePoll::Ready { image }),
                         Err(err) => Err(LoadError::Loading(err)),
@@ -64,7 +99,7 @@ impl ImageLoader for SvgLoader {
     }
 
     fn forget(&self, uri: &str) {
-        self.cache.lock().retain(|(u, _), _| u != uri);
+        self.cache.lock().retain(|key, _| key != uri);
     }
 
     fn forget_all(&self) {
@@ -75,12 +110,28 @@ impl ImageLoader for SvgLoader {
         self.cache
             .lock()
             .values()
-            .map(|result| match result {
+            .flat_map(|bucket| bucket.values())
+            .map(|entry| match &entry.result {
                 Ok(image) => image.pixels.len() * size_of::<egui::Color32>(),
                 Err(err) => err.len(),
             })
             .sum()
     }
+
+    fn end_pass(&self, pass_index: u64) {
+        self.pass_index.store(pass_index, Relaxed);
+        let mut cache = self.cache.lock();
+        cache.retain(|_key, bucket| {
+            if 2 <= bucket.len() {
+                // There are multiple images of the same URI (e.g. SVGs of different scales).
+                // This could be because someone has an SVG in a resizable container,
+                // and so we get a lot of different sizes of it.
+                // This could wast RAM, so we remove the ones that are not used in this frame.
+                bucket.retain(|_, texture| pass_index <= texture.last_used.load(Relaxed) + 1);
+            }
+            !bucket.is_empty()
+        });
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/egui_extras/src/loaders/webp_loader.rs b/crates/egui_extras/src/loaders/webp_loader.rs
index 528c449a7..f0dc32ae4 100644
--- a/crates/egui_extras/src/loaders/webp_loader.rs
+++ b/crates/egui_extras/src/loaders/webp_loader.rs
@@ -1,11 +1,10 @@
 use ahash::HashMap;
 use egui::{
-    decode_animated_image_uri, has_webp_header,
+    ColorImage, FrameDurations, Id, decode_animated_image_uri, has_webp_header,
     load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
     mutex::Mutex,
-    ColorImage, FrameDurations, Id,
 };
-use image::{codecs::webp::WebPDecoder, AnimationDecoder as _, ColorType, ImageDecoder, Rgba};
+use image::{AnimationDecoder as _, ColorType, ImageDecoder as _, Rgba, codecs::webp::WebPDecoder};
 use std::{io::Cursor, mem::size_of, sync::Arc, time::Duration};
 
 #[derive(Clone)]
@@ -55,7 +54,7 @@ impl WebP {
                 unreachable => {
                     return Err(format!(
                         "Unreachable WebP color type, expected Rgb8/Rgba8, got {unreachable:?}"
-                    ))
+                    ));
                 }
             };
 
diff --git a/crates/egui_extras/src/sizing.rs b/crates/egui_extras/src/sizing.rs
index 770306770..71fd3b1c3 100644
--- a/crates/egui_extras/src/sizing.rs
+++ b/crates/egui_extras/src/sizing.rs
@@ -32,7 +32,10 @@ impl Size {
 
     /// Relative size relative to all available space. Values must be in range `0.0..=1.0`.
     pub fn relative(fraction: f32) -> Self {
-        debug_assert!(0.0 <= fraction && fraction <= 1.0);
+        debug_assert!(
+            0.0 <= fraction && fraction <= 1.0,
+            "fraction should be in the range [0, 1], but was {fraction}"
+        );
         Self::Relative {
             fraction,
             range: Rangef::new(0.0, f32::INFINITY),
@@ -121,7 +124,10 @@ impl Sizing {
             .map(|&size| match size {
                 Size::Absolute { initial, .. } => initial,
                 Size::Relative { fraction, range } => {
-                    assert!(0.0 <= fraction && fraction <= 1.0);
+                    assert!(
+                        0.0 <= fraction && fraction <= 1.0,
+                        "fraction should be in the range [0, 1], but was {fraction}"
+                    );
                     range.clamp(length * fraction)
                 }
                 Size::Remainder { .. } => {
@@ -138,11 +144,11 @@ impl Sizing {
             let mut remainder_length = length - sum_non_remainder;
             let avg_remainder_length = 0.0f32.max(remainder_length / num_remainders as f32).floor();
             for &size in &self.sizes {
-                if let Size::Remainder { range } = size {
-                    if avg_remainder_length < range.min {
-                        remainder_length -= range.min;
-                        num_remainders -= 1;
-                    }
+                if let Size::Remainder { range } = size
+                    && avg_remainder_length < range.min
+                {
+                    remainder_length -= range.min;
+                    num_remainders -= 1;
                 }
             }
             if num_remainders > 0 {
diff --git a/crates/egui_extras/src/strip.rs b/crates/egui_extras/src/strip.rs
index 00fc65774..da64b4f9e 100644
--- a/crates/egui_extras/src/strip.rs
+++ b/crates/egui_extras/src/strip.rs
@@ -1,7 +1,7 @@
 use crate::{
+    Size,
     layout::{CellDirection, CellSize, StripLayout, StripLayoutFlags},
     sizing::Sizing,
-    Size,
 };
 use egui::{Response, Ui};
 
diff --git a/crates/egui_extras/src/syntax_highlighting.rs b/crates/egui_extras/src/syntax_highlighting.rs
index 027ba5ee9..2a5fd39fc 100644
--- a/crates/egui_extras/src/syntax_highlighting.rs
+++ b/crates/egui_extras/src/syntax_highlighting.rs
@@ -5,8 +5,8 @@
 
 #![allow(clippy::mem_forget)] // False positive from enum_map macro
 
-use egui::text::LayoutJob;
 use egui::TextStyle;
+use egui::text::LayoutJob;
 
 /// View some code with syntax highlighting and selection.
 pub fn code_view_ui(
@@ -28,17 +28,65 @@ pub fn highlight(
     theme: &CodeTheme,
     code: &str,
     language: &str,
+) -> LayoutJob {
+    highlight_inner(ctx, style, theme, code, language, None)
+}
+
+/// Add syntax highlighting to a code string, with custom `syntect` settings
+///
+/// The results are memoized, so you can call this every frame without performance penalty.
+///
+/// The `syntect` settings are memoized by *address*, so a stable reference should
+/// be used to avoid unnecessary recomputation.
+#[cfg(feature = "syntect")]
+pub fn highlight_with(
+    ctx: &egui::Context,
+    style: &egui::Style,
+    theme: &CodeTheme,
+    code: &str,
+    language: &str,
+    settings: &SyntectSettings,
+) -> LayoutJob {
+    highlight_inner(
+        ctx,
+        style,
+        theme,
+        code,
+        language,
+        Some(HighlightSettings(settings)),
+    )
+}
+
+fn highlight_inner(
+    ctx: &egui::Context,
+    style: &egui::Style,
+    theme: &CodeTheme,
+    code: &str,
+    language: &str,
+    settings: Option<HighlightSettings<'_>>,
 ) -> LayoutJob {
     // We take in both context and style so that in situations where ui is not available such as when
     // performing it at a separate thread (ctx, ctx.style()) can be used and when ui is available
     // (ui.ctx(), ui.style()) can be used
 
-    impl egui::cache::ComputerMut<(&egui::FontId, &CodeTheme, &str, &str), LayoutJob> for Highlighter {
+    #[expect(non_local_definitions)]
+    impl
+        egui::cache::ComputerMut<
+            (&egui::FontId, &CodeTheme, &str, &str, HighlightSettings<'_>),
+            LayoutJob,
+        > for Highlighter
+    {
         fn compute(
             &mut self,
-            (font_id, theme, code, lang): (&egui::FontId, &CodeTheme, &str, &str),
+            (font_id, theme, code, lang, settings): (
+                &egui::FontId,
+                &CodeTheme,
+                &str,
+                &str,
+                HighlightSettings<'_>,
+            ),
         ) -> LayoutJob {
-            self.highlight(font_id.clone(), theme, code, lang)
+            Self::highlight(font_id.clone(), theme, code, lang, settings)
         }
     }
 
@@ -49,10 +97,27 @@ pub fn highlight(
         .clone()
         .unwrap_or_else(|| TextStyle::Monospace.resolve(style));
 
+    // Private type, so that users can't interfere with it in the `IdTypeMap`
+    #[cfg(feature = "syntect")]
+    #[derive(Clone, Default)]
+    struct PrivateSettings(std::sync::Arc<SyntectSettings>);
+
+    // Dummy private settings, to minimize code changes without `syntect`
+    #[cfg(not(feature = "syntect"))]
+    #[derive(Clone, Default)]
+    struct PrivateSettings(std::sync::Arc<()>);
+
     ctx.memory_mut(|mem| {
+        let settings = settings.unwrap_or_else(|| {
+            HighlightSettings(
+                &mem.data
+                    .get_temp_mut_or_default::<PrivateSettings>(egui::Id::NULL)
+                    .0,
+            )
+        });
         mem.caches
             .cache::<HighlightCache>()
-            .get((&font_id, theme, code, language))
+            .get((&font_id, theme, code, language, settings))
     })
 }
 
@@ -268,9 +333,19 @@ impl CodeTheme {
         }
     }
 
+    pub fn is_dark(&self) -> bool {
+        self.dark_mode
+    }
+
     /// Show UI for changing the color theme.
     pub fn ui(&mut self, ui: &mut egui::Ui) {
-        egui::widgets::global_theme_preference_buttons(ui);
+        ui.horizontal(|ui| {
+            ui.selectable_value(&mut self.dark_mode, true, "🌙 Dark theme")
+                .on_hover_text("Use the dark mode theme");
+
+            ui.selectable_value(&mut self.dark_mode, false, "☀ Light theme")
+                .on_hover_text("Use the light mode theme");
+        });
 
         for theme in SyntectTheme::all() {
             if theme.is_dark() == self.dark_mode {
@@ -284,7 +359,7 @@ impl CodeTheme {
 impl CodeTheme {
     // The syntect version takes it by value. This could be avoided by specializing the from_style
     // function, but at the cost of more code duplication.
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     fn dark_with_font_id(font_id: egui::FontId) -> Self {
         use egui::{Color32, TextFormat};
         Self {
@@ -301,7 +376,7 @@ impl CodeTheme {
     }
 
     // The syntect version takes it by value
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     fn light_with_font_id(font_id: egui::FontId) -> Self {
         use egui::{Color32, TextFormat};
         Self {
@@ -395,13 +470,14 @@ impl CodeTheme {
 // ----------------------------------------------------------------------------
 
 #[cfg(feature = "syntect")]
-struct Highlighter {
-    ps: syntect::parsing::SyntaxSet,
-    ts: syntect::highlighting::ThemeSet,
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct SyntectSettings {
+    pub ps: syntect::parsing::SyntaxSet,
+    pub ts: syntect::highlighting::ThemeSet,
 }
 
 #[cfg(feature = "syntect")]
-impl Default for Highlighter {
+impl Default for SyntectSettings {
     fn default() -> Self {
         profiling::function_scope!();
         Self {
@@ -411,16 +487,33 @@ impl Default for Highlighter {
     }
 }
 
+/// Highlight settings are memoized by reference address, rather than value
+#[cfg(feature = "syntect")]
+#[derive(Copy, Clone)]
+struct HighlightSettings<'a>(&'a SyntectSettings);
+
+#[cfg(not(feature = "syntect"))]
+#[derive(Copy, Clone)]
+struct HighlightSettings<'a>(&'a ());
+
+impl std::hash::Hash for HighlightSettings<'_> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        std::ptr::hash(self.0, state);
+    }
+}
+
+#[derive(Default)]
+struct Highlighter;
+
 impl Highlighter {
-    #[allow(clippy::unused_self, clippy::unnecessary_wraps)]
     fn highlight(
-        &self,
         font_id: egui::FontId,
         theme: &CodeTheme,
         code: &str,
         lang: &str,
+        settings: HighlightSettings<'_>,
     ) -> LayoutJob {
-        self.highlight_impl(theme, code, lang).unwrap_or_else(|| {
+        Self::highlight_impl(theme, code, lang, settings).unwrap_or_else(|| {
             // Fallback:
             LayoutJob::simple(
                 code.into(),
@@ -436,19 +529,25 @@ impl Highlighter {
     }
 
     #[cfg(feature = "syntect")]
-    fn highlight_impl(&self, theme: &CodeTheme, text: &str, language: &str) -> Option<LayoutJob> {
+    fn highlight_impl(
+        theme: &CodeTheme,
+        text: &str,
+        language: &str,
+        highlighter: HighlightSettings<'_>,
+    ) -> Option<LayoutJob> {
         profiling::function_scope!();
         use syntect::easy::HighlightLines;
         use syntect::highlighting::FontStyle;
         use syntect::util::LinesWithEndings;
 
-        let syntax = self
+        let syntax = highlighter
+            .0
             .ps
             .find_syntax_by_name(language)
-            .or_else(|| self.ps.find_syntax_by_extension(language))?;
+            .or_else(|| highlighter.0.ps.find_syntax_by_extension(language))?;
 
         let syn_theme = theme.syntect_theme.syntect_key_name();
-        let mut h = HighlightLines::new(syntax, &self.ts.themes[syn_theme]);
+        let mut h = HighlightLines::new(syntax, &highlighter.0.ts.themes[syn_theme]);
 
         use egui::text::{LayoutSection, TextFormat};
 
@@ -458,7 +557,7 @@ impl Highlighter {
         };
 
         for line in LinesWithEndings::from(text) {
-            for (style, range) in h.highlight_line(line, &self.ps).ok()? {
+            for (style, range) in h.highlight_line(line, &highlighter.0.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);
@@ -490,26 +589,28 @@ impl Highlighter {
 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());
+    assert!(
+        whole_start <= range_start,
+        "range must be within whole, but was {range}"
+    );
+    assert!(
+        range_start + range.len() <= whole_start + whole.len(),
+        "range_start + range length must be smaller than whole_start + whole length, but was {}",
+        range_start + range.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_impl(
-        &self,
         theme: &CodeTheme,
         mut text: &str,
         language: &str,
+        _settings: HighlightSettings<'_>,
     ) -> Option<LayoutJob> {
         profiling::function_scope!();
 
diff --git a/crates/egui_extras/src/table.rs b/crates/egui_extras/src/table.rs
index 0a6fe690e..a984226ae 100644
--- a/crates/egui_extras/src/table.rs
+++ b/crates/egui_extras/src/table.rs
@@ -4,13 +4,13 @@
 //! Takes all available height, so if you want something below the table, put it in a strip.
 
 use egui::{
-    scroll_area::{ScrollAreaOutput, ScrollBarVisibility},
     Align, Id, NumExt as _, Rangef, Rect, Response, ScrollArea, Ui, Vec2, Vec2b,
+    scroll_area::{ScrollAreaOutput, ScrollBarVisibility, ScrollSource},
 };
 
 use crate::{
-    layout::{CellDirection, CellSize, StripLayoutFlags},
     StripLayout,
+    layout::{CellDirection, CellSize, StripLayoutFlags},
 };
 
 // -----------------------------------------------------------------=----------
@@ -39,7 +39,7 @@ pub struct Column {
 
     resizable: Option<bool>,
 
-    /// If set, we should acurately measure the size of this column this frame
+    /// If set, we should accurately measure the size of this column this frame
     /// so that we can correctly auto-size it. This is done as a `sizing_pass`.
     auto_size_this_frame: bool,
 }
@@ -472,10 +472,10 @@ impl<'a> TableBuilder<'a> {
 
         for (i, column) in columns.iter_mut().enumerate() {
             let column_resize_id = ui.id().with("resize_column").with(i);
-            if let Some(response) = ui.ctx().read_response(column_resize_id) {
-                if response.double_clicked() {
-                    column.auto_size_this_frame = true;
-                }
+            if let Some(response) = ui.ctx().read_response(column_resize_id)
+                && response.double_clicked()
+            {
+                column.auto_size_this_frame = true;
             }
         }
 
@@ -507,6 +507,7 @@ impl<'a> TableBuilder<'a> {
                 striped: false,
                 hovered: false,
                 selected: false,
+                overline: false,
                 response: &mut response,
             });
             layout.allocate_rect();
@@ -744,7 +745,10 @@ impl Table<'_> {
 
         let mut scroll_area = ScrollArea::new([false, vscroll])
             .id_salt(state_id.with("__scroll_area"))
-            .drag_to_scroll(drag_to_scroll)
+            .scroll_source(ScrollSource {
+                drag: drag_to_scroll,
+                ..Default::default()
+            })
             .stick_to_bottom(stick_to_bottom)
             .min_scrolled_height(min_scrolled_height)
             .max_height(max_scroll_height)
@@ -847,7 +851,7 @@ impl Table<'_> {
             if column.is_auto() && (is_sizing_pass || !column_is_resizable) {
                 *column_width = width_range.clamp(max_used_widths[i]);
             } else if column_is_resizable {
-                let column_resize_id = ui.id().with("resize_column").with(i);
+                let column_resize_id = state_id.with("resize_column").with(i);
 
                 let mut p0 = egui::pos2(x, table_top);
                 let mut p1 = egui::pos2(x, bottom);
@@ -860,27 +864,27 @@ impl Table<'_> {
                 if column.auto_size_this_frame {
                     // Auto-size: resize to what is needed.
                     *column_width = width_range.clamp(max_used_widths[i]);
-                } 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 = width_range.clamp(new_width);
-
-                        let x = x - *column_width + new_width;
-                        (p0.x, p1.x) = (x, x);
-
-                        *column_width = new_width;
+                } else if resize_response.dragged()
+                    && 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 = width_range.clamp(new_width);
+
+                    let x = x - *column_width + new_width;
+                    (p0.x, p1.x) = (x, x);
+
+                    *column_width = new_width;
                 }
 
                 let dragging_something_else =
@@ -987,9 +991,10 @@ impl<'a> TableBody<'a> {
             row_index: self.row_index,
             col_index: 0,
             height,
-            striped: self.striped && self.row_index % 2 == 0,
+            striped: self.striped && self.row_index.is_multiple_of(2),
             hovered: self.hovered_row_index == Some(self.row_index),
             selected: false,
+            overline: false,
             response: &mut response,
         });
         self.capture_hover_state(&response, self.row_index);
@@ -1068,9 +1073,10 @@ impl<'a> TableBody<'a> {
                 row_index,
                 col_index: 0,
                 height: row_height_sans_spacing,
-                striped: self.striped && (row_index + self.row_index) % 2 == 0,
+                striped: self.striped && (row_index + self.row_index).is_multiple_of(2),
                 hovered: self.hovered_row_index == Some(row_index),
                 selected: false,
+                overline: false,
                 response: &mut response,
             });
             self.capture_hover_state(&response, row_index);
@@ -1149,9 +1155,10 @@ impl<'a> TableBody<'a> {
                     row_index,
                     col_index: 0,
                     height: row_height,
-                    striped: self.striped && (row_index + self.row_index) % 2 == 0,
+                    striped: self.striped && (row_index + self.row_index).is_multiple_of(2),
                     hovered: self.hovered_row_index == Some(row_index),
                     selected: false,
+                    overline: false,
                     response: &mut response,
                 });
                 self.capture_hover_state(&response, row_index);
@@ -1171,8 +1178,9 @@ impl<'a> TableBody<'a> {
                 row_index,
                 col_index: 0,
                 height: row_height,
-                striped: self.striped && (row_index + self.row_index) % 2 == 0,
+                striped: self.striped && (row_index + self.row_index).is_multiple_of(2),
                 hovered: self.hovered_row_index == Some(row_index),
+                overline: false,
                 selected: false,
                 response: &mut response,
             });
@@ -1260,6 +1268,7 @@ pub struct TableRow<'a, 'b> {
     striped: bool,
     hovered: bool,
     selected: bool,
+    overline: bool,
 
     response: &'b mut Option<Response>,
 }
@@ -1297,6 +1306,7 @@ impl TableRow<'_, '_> {
             striped: self.striped,
             hovered: self.hovered,
             selected: self.selected,
+            overline: self.overline,
             sizing_pass: auto_size_this_frame || self.layout.ui.is_sizing_pass(),
         };
 
@@ -1333,6 +1343,13 @@ impl TableRow<'_, '_> {
         self.hovered = hovered;
     }
 
+    /// Set the overline state for this row. The overline is a line above the row,
+    /// usable for e.g. visually grouping rows.
+    #[inline]
+    pub fn set_overline(&mut self, overline: bool) {
+        self.overline = overline;
+    }
+
     /// Returns a union of the [`Response`]s of the cells added to the row up to this point.
     ///
     /// You need to add at least one row to the table before calling this function.
diff --git a/crates/egui_glow/CHANGELOG.md b/crates/egui_glow/CHANGELOG.md
index abdfa240e..4dd90a359 100644
--- a/crates/egui_glow/CHANGELOG.md
+++ b/crates/egui_glow/CHANGELOG.md
@@ -6,6 +6,35 @@ Changes since the last release can be found at <https://github.com/emilk/egui/co
 
 
 
+## 0.33.2 - 2025-11-13
+Nothing new
+
+
+## 0.33.0 - 2025-10-09
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+Nothing new
+
+
+## 0.32.1 - 2025-08-15
+Nothing new
+
+
+## 0.32.0 - 2025-07-10
+* Fix text distortion on mobile devices/browsers with `glow` backend [#6893](https://github.com/emilk/egui/pull/6893) by [@wareya](https://github.com/wareya)
+* Improve texture filtering by doing it in gamma space [#7311](https://github.com/emilk/egui/pull/7311) by [@emilk](https://github.com/emilk)
+
+
+## 0.31.1 - 2025-03-05
+Nothing new
+
+
 ## 0.31.0 - 2025-02-04
 Nothing new
 
diff --git a/crates/egui_glow/Cargo.toml b/crates/egui_glow/Cargo.toml
index 7a402d406..4a083611b 100644
--- a/crates/egui_glow/Cargo.toml
+++ b/crates/egui_glow/Cargo.toml
@@ -5,19 +5,13 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Bindings for using egui natively using the glow library"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/egui_glow"
+homepage = "https://github.com/emilk/egui/tree/main/crates/egui_glow"
 license.workspace = true
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/egui_glow"
+repository = "https://github.com/emilk/egui/tree/main/crates/egui_glow"
 categories = ["gui", "game-development"]
 keywords = ["glow", "egui", "gui", "gamedev"]
-include = [
-  "../LICENSE-APACHE",
-  "../LICENSE-MIT",
-  "**/*.rs",
-  "Cargo.toml",
-  "src/shader/*.glsl",
-]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml", "src/shader/*.glsl"]
 
 [lints]
 workspace = true
@@ -53,11 +47,10 @@ x11 = ["winit?/x11"]
 egui = { workspace = true, default-features = false, features = ["bytemuck"] }
 egui-winit = { workspace = true, optional = true, default-features = false }
 
-ahash.workspace = true
 bytemuck.workspace = true
 glow.workspace = true
 log.workspace = true
-memoffset = "0.9"
+memoffset.workspace = true
 profiling.workspace = true
 
 #! ### Optional dependencies
@@ -74,7 +67,7 @@ wasm-bindgen.workspace = true
 
 
 [dev-dependencies]
-glutin = { workspace = true, default-features = true }       # examples/pure_glow
+glutin = { workspace = true, default-features = true } # examples/pure_glow
 glutin-winit = { workspace = true, default-features = true }
 
 [[example]]
diff --git a/crates/egui_glow/README.md b/crates/egui_glow/README.md
index 2aee02f0e..3fcd7db5a 100644
--- a/crates/egui_glow/README.md
+++ b/crates/egui_glow/README.md
@@ -9,7 +9,7 @@ This crates provides bindings between [`egui`](https://github.com/emilk/egui) an
 * 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 write web apps using `glow` you can use [`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe) (which uses `egui_glow` for rendering).
 
 To use on Linux, first run:
 
@@ -17,7 +17,7 @@ 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).
+This crate optionally depends on [`egui-winit`](https://github.com/emilk/egui/tree/main/crates/egui-winit).
 
 Test the example with:
 
diff --git a/crates/egui_glow/examples/pure_glow.rs b/crates/egui_glow/examples/pure_glow.rs
index ce3560544..3671c8d79 100644
--- a/crates/egui_glow/examples/pure_glow.rs
+++ b/crates/egui_glow/examples/pure_glow.rs
@@ -9,7 +9,7 @@ use std::num::NonZeroU32;
 use std::sync::Arc;
 
 use egui_winit::winit;
-use winit::raw_window_handle::HasWindowHandle;
+use winit::raw_window_handle::HasWindowHandle as _;
 
 /// The majority of `GlutinWindowContext` is taken from `eframe`
 struct GlutinWindowContext {
@@ -22,12 +22,12 @@ struct GlutinWindowContext {
 impl GlutinWindowContext {
     // refactor this function to use `glutin-winit` crate eventually.
     // preferably add android support at the same time.
-    #[allow(unsafe_code)]
+    #[expect(unsafe_code)]
     unsafe fn new(event_loop: &winit::event_loop::ActiveEventLoop) -> Self {
-        use glutin::context::NotCurrentGlContext;
-        use glutin::display::GetGlDisplay;
-        use glutin::display::GlDisplay;
-        use glutin::prelude::GlSurface;
+        use glutin::context::NotCurrentGlContext as _;
+        use glutin::display::GetGlDisplay as _;
+        use glutin::display::GlDisplay as _;
+        use glutin::prelude::GlSurface as _;
         let winit_window_builder = winit::window::WindowAttributes::default()
             .with_resizable(true)
             .with_inner_size(winit::dpi::LogicalSize {
@@ -66,7 +66,7 @@ impl GlutinWindowContext {
                 .expect("failed to get window handle")
                 .as_raw()
         });
-        log::debug!("raw window handle: {:?}", raw_window_handle);
+        log::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
@@ -138,7 +138,7 @@ impl GlutinWindowContext {
     }
 
     fn resize(&self, physical_size: winit::dpi::PhysicalSize<u32>) {
-        use glutin::surface::GlSurface;
+        use glutin::surface::GlSurface as _;
         self.gl_surface.resize(
             &self.gl_context,
             physical_size.width.try_into().unwrap(),
@@ -147,12 +147,12 @@ impl GlutinWindowContext {
     }
 
     fn swap_buffers(&self) -> glutin::error::Result<()> {
-        use glutin::surface::GlSurface;
+        use glutin::surface::GlSurface as _;
         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;
+        use glutin::display::GlDisplay as _;
         self.gl_display.get_proc_address(addr)
     }
 }
diff --git a/crates/egui_glow/src/lib.rs b/crates/egui_glow/src/lib.rs
index 430f1287e..0b815417f 100644
--- a/crates/egui_glow/src/lib.rs
+++ b/crates/egui_glow/src/lib.rs
@@ -62,18 +62,14 @@ macro_rules! check_for_gl_error {
 /// ```
 #[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)
-    }};
+    ($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)]
+    #[expect(unsafe_code)]
     let error_code = unsafe { gl.get_error() };
     if error_code != glow::NO_ERROR {
         let error_str = match error_code {
@@ -92,20 +88,11 @@ pub fn check_for_gl_error_impl(gl: &glow::Context, file: &str, line: u32, contex
 
         if context.is_empty() {
             log::error!(
-                "GL error, at {}:{}: {} (0x{:X}). Please file a bug at https://github.com/emilk/egui/issues",
-                file,
-                line,
-                error_str,
-                error_code,
+                "GL error, at {file}:{line}: {error_str} (0x{error_code:X}). Please file a bug at https://github.com/emilk/egui/issues"
             );
         } else {
             log::error!(
-                "GL error, at {}:{} ({}): {} (0x{:X}). Please file a bug at https://github.com/emilk/egui/issues",
-                file,
-                line,
-                context,
-                error_str,
-                error_code,
+                "GL error, at {file}:{line} ({context}): {error_str} (0x{error_code:X}). Please file a bug at https://github.com/emilk/egui/issues"
             );
         }
     }
diff --git a/crates/egui_glow/src/painter.rs b/crates/egui_glow/src/painter.rs
index bec46cf08..5071f1a0c 100644
--- a/crates/egui_glow/src/painter.rs
+++ b/crates/egui_glow/src/painter.rs
@@ -113,7 +113,7 @@ pub struct Painter {
 ///
 /// # 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.
+/// See the [`custom3d_glow`](https://github.com/emilk/egui/blob/main/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>,
 }
@@ -168,23 +168,18 @@ impl Painter {
         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();
-        log::debug!("Shader header: {:?}.", shader_version_declaration);
+        log::debug!("Shader header: {shader_version_declaration:?}.");
 
         let supported_extensions = gl.supported_extensions();
         log::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")
-            });
-        log::debug!("SRGB texture Support: {:?}", srgb_textures);
+        let srgb_textures = false; // egui wants normal sRGB-unaware textures
 
         let supports_srgb_framebuffer = !cfg!(target_arch = "wasm32")
             && supported_extensions.iter().any(|extension| {
                 // {GL,GLX,WGL}_ARB_framebuffer_sRGB, …
                 extension.ends_with("ARB_framebuffer_sRGB")
             });
-        log::debug!("SRGB framebuffer Support: {:?}", supports_srgb_framebuffer);
+        log::debug!("SRGB framebuffer Support: {supports_srgb_framebuffer}");
 
         unsafe {
             let vert = compile_shader(
@@ -202,11 +197,10 @@ impl Painter {
                 &gl,
                 glow::FRAGMENT_SHADER,
                 &format!(
-                    "{}\n#define NEW_SHADER_INTERFACE {}\n#define DITHERING {}\n#define SRGB_TEXTURES {}\n{}\n{}",
+                    "{}\n#define NEW_SHADER_INTERFACE {}\n#define DITHERING {}\n{}\n{}",
                     shader_version_declaration,
                     shader_version.is_new_shader_interface() as i32,
                     dithering as i32,
-                    srgb_textures as i32,
                     shader_prefix,
                     FRAG_SRC
                 ),
@@ -296,7 +290,7 @@ impl Painter {
     /// 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)]
+    #[expect(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.
@@ -445,7 +439,9 @@ impl Painter {
                         if let Some(callback) = callback.callback.downcast_ref::<CallbackFn>() {
                             (callback.f)(info, self);
                         } else {
-                            log::warn!("Warning: Unsupported render callback. Expected egui_glow::CallbackFn");
+                            log::warn!(
+                                "Warning: Unsupported render callback. Expected egui_glow::CallbackFn"
+                            );
                         }
 
                         check_for_gl_error!(&self.gl, "callback");
@@ -469,7 +465,7 @@ impl Painter {
 
     #[inline(never)] // Easier profiling
     fn paint_mesh(&mut self, mesh: &Mesh) {
-        debug_assert!(mesh.is_valid());
+        debug_assert!(mesh.is_valid(), "Mesh is not valid");
         if let Some(texture) = self.texture(mesh.texture_id) {
             unsafe {
                 self.gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vbo));
@@ -532,24 +528,7 @@ impl Painter {
 
                 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> = {
-                    profiling::scope!("font -> sRGBA");
-                    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(
@@ -560,7 +539,12 @@ impl Painter {
         data: &[u8],
     ) {
         profiling::function_scope!();
-        assert_eq!(data.len(), w * h * 4);
+        assert_eq!(
+            data.len(),
+            w * h * 4,
+            "Mismatch between texture size and texel count, by {}",
+            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 {}",
@@ -658,7 +642,6 @@ impl Painter {
         self.textures.get(&texture_id).copied()
     }
 
-    #[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);
@@ -667,7 +650,6 @@ impl Painter {
         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);
@@ -693,10 +675,7 @@ impl Painter {
         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,
-        }
+        egui::ColorImage::new([w as usize, h as usize], flipped)
     }
 
     pub fn read_screen_rgb(&self, [w, h]: [u32; 2]) -> Vec<u8> {
@@ -719,6 +698,7 @@ impl Painter {
     unsafe fn destroy_gl(&self) {
         unsafe {
             self.gl.delete_program(self.program);
+            #[expect(clippy::iter_over_hash_type)]
             for tex in self.textures.values() {
                 self.gl.delete_texture(*tex);
             }
diff --git a/crates/egui_glow/src/shader/fragment.glsl b/crates/egui_glow/src/shader/fragment.glsl
index 30da2809e..07a931b53 100644
--- a/crates/egui_glow/src/shader/fragment.glsl
+++ b/crates/egui_glow/src/shader/fragment.glsl
@@ -1,5 +1,11 @@
 #ifdef GL_ES
-    precision mediump float;
+    // To avoid weird distortion issues when rendering text etc, we want highp if possible.
+    // But apparently some devices don't support it, so we have to check first.
+    #if defined(GL_FRAGMENT_PRECISION_HIGH) && GL_FRAGMENT_PRECISION_HIGH == 1
+        precision highp float;
+    #else
+        precision mediump float;
+    #endif
 #endif
 
 uniform sampler2D u_sampler;
@@ -37,25 +43,8 @@ vec3 dither_interleaved(vec3 rgb, float levels) {
     return rgb + noise / (levels - 1.0);
 }
 
-// 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.
     vec4 frag_color_gamma = v_rgba_in_gamma * texture_in_gamma;
diff --git a/crates/egui_glow/src/shader/vertex.glsl b/crates/egui_glow/src/shader/vertex.glsl
index fff31463c..0c6e9d231 100644
--- a/crates/egui_glow/src/shader/vertex.glsl
+++ b/crates/egui_glow/src/shader/vertex.glsl
@@ -9,7 +9,13 @@
 #endif
 
 #ifdef GL_ES
-    precision mediump float;
+    // To avoid weird distortion issues when rendering text etc, we want highp if possible.
+    // But apparently some devices don't support it, so we have to check first.
+    #if defined(GL_FRAGMENT_PRECISION_HIGH) && GL_FRAGMENT_PRECISION_HIGH == 1
+        precision highp float;
+    #else
+        precision mediump float;
+    #endif
 #endif
 
 uniform vec2 u_screen_size;
diff --git a/crates/egui_glow/src/shader_version.rs b/crates/egui_glow/src/shader_version.rs
index 77c1e63ce..3b2ec5347 100644
--- a/crates/egui_glow/src/shader_version.rs
+++ b/crates/egui_glow/src/shader_version.rs
@@ -1,11 +1,10 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use std::convert::TryInto;
+use std::convert::TryInto as _;
 
 /// Helper for parsing and interpreting the OpenGL shader version.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[allow(dead_code)]
 pub enum ShaderVersion {
     Gl120,
 
@@ -25,11 +24,7 @@ impl ShaderVersion {
         let shading_lang_string =
             unsafe { gl.get_parameter_string(glow::SHADING_LANGUAGE_VERSION) };
         let shader_version = Self::parse(&shading_lang_string);
-        log::debug!(
-            "Shader version: {:?} ({:?}).",
-            shader_version,
-            shading_lang_string
-        );
+        log::debug!("Shader version: {shader_version:?} ({shading_lang_string:?}).");
         shader_version
     }
 
@@ -48,11 +43,7 @@ impl ShaderVersion {
             .try_into()
             .unwrap();
         if es {
-            if maj >= 3 {
-                Self::Es300
-            } else {
-                Self::Es100
-            }
+            if maj >= 3 { Self::Es300 } else { Self::Es100 }
         } else if maj > 1 || (maj == 1 && min >= 40) {
             Self::Gl140
         } else {
diff --git a/crates/egui_glow/src/vao.rs b/crates/egui_glow/src/vao.rs
index 6759a829d..736daf2f7 100644
--- a/crates/egui_glow/src/vao.rs
+++ b/crates/egui_glow/src/vao.rs
@@ -27,7 +27,6 @@ pub(crate) struct VertexArrayObject {
 }
 
 impl VertexArrayObject {
-    #[allow(clippy::needless_pass_by_value)] // false positive
     pub(crate) unsafe fn new(
         gl: &glow::Context,
         vbo: glow::Buffer,
@@ -119,7 +118,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
     const OPENGL_ES_PREFIX: &str = "OpenGL ES ";
 
     let version_string = unsafe { gl.get_parameter_string(glow::VERSION) };
-    log::debug!("GL version: {:?}.", version_string);
+    log::debug!("GL version: {version_string:?}.");
 
     // Examples:
     // * "WebGL 2.0 (OpenGL ES 3.0 Chromium)"
@@ -130,7 +129,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
         if version_str.contains("1.0") {
             // need to test OES_vertex_array_object .
             let supported_extensions = gl.supported_extensions();
-            log::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            log::debug!("Supported OpenGL extensions: {supported_extensions:?}");
             supported_extensions.contains("OES_vertex_array_object")
                 || supported_extensions.contains("GL_OES_vertex_array_object")
         } else {
@@ -141,7 +140,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
         if version_string.contains("2.0") {
             // need to test OES_vertex_array_object .
             let supported_extensions = gl.supported_extensions();
-            log::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            log::debug!("Supported OpenGL extensions: {supported_extensions:?}");
             supported_extensions.contains("OES_vertex_array_object")
                 || supported_extensions.contains("GL_OES_vertex_array_object")
         } else {
@@ -153,7 +152,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
             // 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();
-            log::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            log::debug!("Supported OpenGL extensions: {supported_extensions:?}");
             supported_extensions.contains("ARB_vertex_array_object")
                 || supported_extensions.contains("GL_ARB_vertex_array_object")
         } else {
diff --git a/crates/egui_glow/src/winit.rs b/crates/egui_glow/src/winit.rs
index c4569015a..49f43cb11 100644
--- a/crates/egui_glow/src/winit.rs
+++ b/crates/egui_glow/src/winit.rs
@@ -1,8 +1,7 @@
-use ahash::HashSet;
+pub use egui_winit::{self, EventResponse};
+
 use egui::{ViewportId, ViewportOutput};
-pub use egui_winit;
 use egui_winit::winit;
-pub use egui_winit::EventResponse;
 
 use crate::shader_version::ShaderVersion;
 
@@ -81,7 +80,7 @@ impl EguiGlow {
             log::warn!("Multiple viewports not yet supported by EguiGlow");
         }
         for (_, ViewportOutput { commands, .. }) in viewport_output {
-            let mut actions_requested: HashSet<egui_winit::ActionRequested> = Default::default();
+            let mut actions_requested = Default::default();
             egui_winit::process_viewport_commands(
                 &self.egui_ctx,
                 &mut self.viewport_info,
@@ -90,7 +89,7 @@ impl EguiGlow {
                 &mut actions_requested,
             );
             for action in actions_requested {
-                log::warn!("{:?} not yet supported by EguiGlow", action);
+                log::warn!("{action:?} not yet supported by EguiGlow");
             }
         }
 
diff --git a/crates/egui_kittest/CHANGELOG.md b/crates/egui_kittest/CHANGELOG.md
index a32272ec3..09fe5c4f1 100644
--- a/crates/egui_kittest/CHANGELOG.md
+++ b/crates/egui_kittest/CHANGELOG.md
@@ -6,6 +6,64 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+Nothing new
+
+
+## 0.33.1 - 2025-10-15
+* Add `egui_kittest::HarnessBuilder::with_options` [#7638](https://github.com/emilk/egui/pull/7638) by [@emilk](https://github.com/emilk)
+
+
+## 0.33.0 - 2025-10-09
+### ⭐ Added
+* Kittest: Add `UPDATE_SNAPSHOTS=force` [#7508](https://github.com/emilk/egui/pull/7508) by [@emilk](https://github.com/emilk)
+* Add `egui_kittest::HarnessBuilder::with_os` and set the default to `Nix` [#7493](https://github.com/emilk/egui/pull/7493) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `Harness::debug_open_snapshot` helper [#7590](https://github.com/emilk/egui/pull/7590) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🔧 Changed
+* Include popups and tooltips in `Harness::fit_contents` [#7556](https://github.com/emilk/egui/pull/7556) by [@oxkitsune](https://github.com/oxkitsune)
+* Adjust when we write .diff and .new snapshot images [#7571](https://github.com/emilk/egui/pull/7571) by [@emilk](https://github.com/emilk)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+* `Harness`: Add `remove_cursor`,  `event` and `event_modifiers` [#7607](https://github.com/emilk/egui/pull/7607) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Use software texture filtering in kittest [#7602](https://github.com/emilk/egui/pull/7602) by [@emilk](https://github.com/emilk)
+* Write .new.png file if snapshot is missing [#7610](https://github.com/emilk/egui/pull/7610) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🔥 Removed
+* Remove deprecated `Harness::wgpu_snapshot` and related fns [#7504](https://github.com/emilk/egui/pull/7504) by [@bircni](https://github.com/bircni)
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+* Allow masking widgets in kittest snapshots [#7467](https://github.com/emilk/egui/pull/7467) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.32.1 - 2025-08-15
+* Fix `UPDATE_SNAPSHOTS`: only update if we didn't pass the test [#7455](https://github.com/emilk/egui/pull/7455) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.0 - 2025-07-10
+### ⭐ Added
+* Add `ImageLoader::has_pending` and `wait_for_pending_images` [#7030](https://github.com/emilk/egui/pull/7030) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Create custom `egui_kittest::Node` [#7138](https://github.com/emilk/egui/pull/7138) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `HarnessBuilder::theme` [#7289](https://github.com/emilk/egui/pull/7289) by [@emilk](https://github.com/emilk)
+* Add support for scrolling via accesskit / kittest [#7286](https://github.com/emilk/egui/pull/7286) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add `failed_pixel_count_threshold` [#7092](https://github.com/emilk/egui/pull/7092) by [@bircni](https://github.com/bircni)
+
+### 🔧 Changed
+* More ergonomic functions taking `Impl Into<String>` [#7307](https://github.com/emilk/egui/pull/7307) by [@emlik](https://github.com/emilk)
+* Update kittest to 0.2 [#7332](https://github.com/emilk/egui/pull/7332) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+
+## 0.31.1 - 2025-03-05
+* Fix modifiers not working in kittest [#5693](https://github.com/emilk/egui/pull/5693) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Enable all features for egui_kittest docs [#5711](https://github.com/emilk/egui/pull/5711) by [@YgorSouza](https://github.com/YgorSouza)
+* Run a frame per queued event in egui_kittest [#5704](https://github.com/emilk/egui/pull/5704) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Add guidelines for image comparison tests [#5714](https://github.com/emilk/egui/pull/5714) by [@Wumpf](https://github.com/Wumpf)
+
+
 ## 0.31.0 - 2025-02-04
 ### ⭐ Added
 * Add `Harness::new_eframe` and `TestRenderer` trait [#5539](https://github.com/emilk/egui/pull/5539) by [@lucasmerlin](https://github.com/lucasmerlin)
diff --git a/crates/egui_kittest/Cargo.toml b/crates/egui_kittest/Cargo.toml
index 1e4af19e6..1de8ce7ac 100644
--- a/crates/egui_kittest/Cargo.toml
+++ b/crates/egui_kittest/Cargo.toml
@@ -1,10 +1,7 @@
 [package]
 name = "egui_kittest"
 version.workspace = true
-authors = [
-    "Lucas Meurer <lucasmeurer96@gmail.com>",
-    "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>",
-]
+authors = ["Lucas Meurer <lucasmeurer96@gmail.com>", "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Testing library for egui based on kittest and AccessKit"
 edition.workspace = true
 rust-version.workspace = true
@@ -18,26 +15,27 @@ include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--generate-link-to-definition"]
+
 [features]
-# Adds a wgpu-based test renderer.
-wgpu = [
-    "dep:egui-wgpu",
-    "dep:pollster",
-    "dep:image",
-    "dep:wgpu",
-    "eframe?/wgpu",
-]
+## Adds a wgpu-based test renderer.
+wgpu = ["dep:egui-wgpu", "dep:pollster", "dep:image", "dep:wgpu", "eframe?/wgpu"]
 
-# Adds a dify-based image snapshot utility.
-snapshot = ["dep:dify", "dep:image", "image/png"]
+## Adds a dify-based image snapshot utility.
+snapshot = ["dep:dify", "dep:image", "dep:open", "dep:tempfile", "image/png"]
 
-# Allows testing eframe::App
+## Allows testing eframe::App
 eframe = ["dep:eframe", "eframe/accesskit"]
 
+# This is just so it compiles with `--all-features` on Linux
+x11 = ["eframe?/x11"]
+
 
 [dependencies]
 kittest.workspace = true
-egui = { workspace = true, features = ["accesskit"] }
+egui.workspace = true
 eframe = { workspace = true, optional = true }
 
 # wgpu dependencies
@@ -45,17 +43,23 @@ egui-wgpu = { workspace = true, optional = true }
 pollster = { workspace = true, optional = true }
 image = { workspace = true, optional = true }
 # Enable DX12 because it always comes with a software rasterizer.
-wgpu = { workspace = true, features = ["metal", "dx12"], optional = true }
+wgpu = { workspace = true, features = ["metal", "dx12", "vulkan", "gles"], optional = true }
 
 # snapshot dependencies
 dify = { workspace = true, optional = true }
 
-## Enable this when generating docs.
+# Enable this when generating docs.
 document-features = { workspace = true, optional = true }
 
+# Native dependencies:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+open = { workspace = true, optional = true }
+tempfile = { workspace = true, optional = true }
+
 [dev-dependencies]
 egui = { workspace = true, features = ["default_fonts"] }
 image = { workspace = true, features = ["png"] }
+egui_extras = { workspace = true, features = ["image", "http"] }
 
 [lints]
 workspace = true
diff --git a/crates/egui_kittest/README.md b/crates/egui_kittest/README.md
index a9c1286bf..b774572f6 100644
--- a/crates/egui_kittest/README.md
+++ b/crates/egui_kittest/README.md
@@ -1,11 +1,16 @@
 # egui_kittest
 
+[![Latest version](https://img.shields.io/crates/v/egui_kittest.svg)](https://crates.io/crates/egui_kittest)
+[![Documentation](https://docs.rs/egui_kittest/badge.svg)](https://docs.rs/egui_kittest)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
+
 Ui testing library for egui, based on [kittest](https://github.com/rerun-io/kittest) (an [AccessKit](https://github.com/AccessKit/accesskit) based testing library).
 
 ## Example usage
 ```rust
 use egui::accesskit::Toggled;
-use egui_kittest::{Harness, kittest::Queryable};
+use egui_kittest::{Harness, kittest::{Queryable, NodeT}};
 
 fn main() {
     let mut checked = false;
@@ -16,13 +21,13 @@ fn main() {
     let mut harness = Harness::new_ui(app);
 
     let checkbox = harness.get_by_label("Check me!");
-    assert_eq!(checkbox.toggled(), Some(Toggled::False));
+    assert_eq!(checkbox.accesskit_node().toggled(), Some(Toggled::False));
     checkbox.click();
 
     harness.run();
 
     let checkbox = harness.get_by_label("Check me!");
-    assert_eq!(checkbox.toggled(), Some(Toggled::True));
+    assert_eq!(checkbox.accesskit_node().toggled(), Some(Toggled::True));
 
     // Shrink the window size to the smallest size possible
     harness.fit_contents();
@@ -39,10 +44,14 @@ Once enabled, you can call `Harness::snapshot` to render the ui and save the ima
 
 To update the snapshots, run your tests with `UPDATE_SNAPSHOTS=true`, so e.g. `UPDATE_SNAPSHOTS=true cargo test`.
 Running with `UPDATE_SNAPSHOTS=true` will cause the tests to succeed.
-This is so that you can set `UPDATE_SNAPSHOTS=true` and update _all_ tests, without `cargo test` failing on the first failing crate.
+This is so that you can set `UPDATE_SNAPSHOTS=true` and update all tests, without `cargo test` failing on the first failing crate.
 
-If you want to have multiple snapshots in the same test, it makes sense to collect the results in a `Vec`
-([look here](https://github.com/emilk/egui/blob/70a01138b77f9c5724a35a6ef750b9ae1ab9f2dc/crates/egui_demo_lib/src/demo/demo_app_windows.rs#L388-L427) for an example).
+`UPDATE_SNAPSHOTS=true` will only update the images of _failing_ tests.
+If you want to update all snapshot images, even those that are within error margins,
+run with `UPDATE_SNAPSHOTS=force`.
+
+If you want to have multiple snapshots in the same test, it makes sense to collect the results in a `SnapshotResults`
+([look here](https://github.com/emilk/egui/blob/d1fcd740ded5d69016c993a502b52e67f5d492d7/crates/egui_demo_lib/src/demo/demo_app_windows.rs#L387-L420) for an example).
 This way they can all be updated at the same time.
 
 You should add the following to your `.gitignore`:
@@ -50,3 +59,62 @@ You should add the following to your `.gitignore`:
 **/tests/snapshots/**/*.diff.png
 **/tests/snapshots/**/*.new.png
 ```
+
+### Guidelines for writing snapshot tests
+
+* Whenever **possible** prefer regular Rust tests or `insta` snapshot tests over image comparison tests because…
+  * …compared to regular Rust tests, they can be relatively slow to run
+  * …they are brittle since unrelated side effects (like a change in color) can cause the test to fail
+  * …images take up repo space
+* images should…
+  * …be checked in or otherwise be available (egui uses [git LFS](https://git-lfs.com/) files for this purpose)
+  * …depict exactly what's tested and nothing else
+  * …have a low resolution to avoid growth in repo size
+  * …have a low comparison threshold to avoid the test passing despite unwanted differences (the default threshold should be fine for most usecases!)
+
+### What do do when CI / another computer produces a different image?
+
+The default tolerance settings should be fine for almost all gui comparison tests.
+However, especially when you're using custom rendering, you may observe images difference with different setups leading to unexpected test failures.
+
+First check whether the difference is due to a change in enabled rendering features, potentially due to difference in hardware (/software renderer) capabilitites.
+Generally you should carefully enforcing the same set of features for all test runs, but this may happen nonetheless.
+
+Once you validated that the differences are miniscule and hard to avoid, you can try to _carefully_ adjust the comparison tolerance setting (`SnapshotOptions::threshold`, TODO([#5683](https://github.com/emilk/egui/issues/5683)): as well as number of pixels allowed to differ) for the specific test.
+
+⚠️ **WARNING** ⚠️
+Picking too high tolerances may mean that you are missing actual test failures.
+It is recommended to manually verify that the tests still break under the right circumstances as expected after adjusting the tolerances.
+
+---
+
+In order to avoid image differences, it can be useful to form an understanding of how they occur in the first place.
+
+Discrepancies can be caused by a variety of implementation details that depend on the concrete GPU, OS, rendering backend (Metal/Vulkan/DX12 etc.) or graphics driver (even between different versions of the same driver).
+
+Common issues include:
+* multi-sample anti-aliasing
+  * sample placement and sample resolve steps are implementation defined
+  * alpha-to-coverage algorithm/pattern can wary wildly between implementations
+* texture filtering
+  * different implementations may apply different optimizations *even* for simple linear texture filtering
+* out of bounds texture access (via `textureLoad`)
+  * implementations are free to return indeterminate values instead of clamping
+* floating point evaluation, for details see [WGSL spec § 15.7. Floating Point Evaluation](https://www.w3.org/TR/WGSL/#floating-point-evaluation). Notably:
+  * rounding mode may be inconsistent
+  * floating point math "optimizations" may occur
+    * depending on output shading language, different arithmetic optimizations may be performed upon floating point operations even if they change the result
+  * floating point denormal flush
+    * even on modern implementations, denormal float values may be flushed to zero
+  * `NaN`/`Inf` handling
+    * whenever the result of a function should yield `NaN`/`Inf`, implementations may free to yield an indeterminate value instead
+  * builtin-function function precision & error handling (trigonometric functions and others)
+* [partial derivatives (dpdx/dpdx)](https://www.w3.org/TR/WGSL/#dpdx-builtin)
+  * implementations are free to use either `dpdxFine` or `dpdxCoarse`
+* [...]
+
+From this follow a few simple recommendations (these may or may not apply as they may impose unwanted restrictions on your rendering setup):
+* avoid enabling mult-sample anti-aliasing whenever it's not explicitly tested or needed
+* do not rely on NaN, Inf and denormal float values
+* consider dedicated test paths for texture sampling
+* prefer explicit partial derivative functions
diff --git a/crates/egui_kittest/src/builder.rs b/crates/egui_kittest/src/builder.rs
index 4010b4584..09b91d26d 100644
--- a/crates/egui_kittest/src/builder.rs
+++ b/crates/egui_kittest/src/builder.rs
@@ -4,13 +4,20 @@ use egui::{Pos2, Rect, Vec2};
 use std::marker::PhantomData;
 
 /// Builder for [`Harness`].
+#[must_use]
 pub struct HarnessBuilder<State = ()> {
     pub(crate) screen_rect: Rect,
     pub(crate) pixels_per_point: f32,
+    pub(crate) theme: egui::Theme,
+    pub(crate) os: egui::os::OperatingSystem,
     pub(crate) max_steps: u64,
     pub(crate) step_dt: f32,
     pub(crate) state: PhantomData<State>,
     pub(crate) renderer: Box<dyn TestRenderer>,
+    pub(crate) wait_for_pending_images: bool,
+
+    #[cfg(feature = "snapshot")]
+    pub(crate) default_snapshot_options: crate::SnapshotOptions,
 }
 
 impl<State> Default for HarnessBuilder<State> {
@@ -18,10 +25,16 @@ impl<State> Default for HarnessBuilder<State> {
         Self {
             screen_rect: Rect::from_min_size(Pos2::ZERO, Vec2::new(800.0, 600.0)),
             pixels_per_point: 1.0,
+            theme: egui::Theme::Dark,
             state: PhantomData,
             renderer: Box::new(LazyRenderer::default()),
             max_steps: 4,
             step_dt: 1.0 / 4.0,
+            wait_for_pending_images: true,
+            os: egui::os::OperatingSystem::Nix,
+
+            #[cfg(feature = "snapshot")]
+            default_snapshot_options: crate::SnapshotOptions::default(),
         }
     }
 }
@@ -43,6 +56,36 @@ impl<State> HarnessBuilder<State> {
         self
     }
 
+    /// Set the desired theme (dark or light).
+    #[inline]
+    pub fn with_theme(mut self, theme: egui::Theme) -> Self {
+        self.theme = theme;
+        self
+    }
+
+    /// Set the default options used for snapshot tests on this harness.
+    #[cfg(feature = "snapshot")]
+    #[inline]
+    pub fn with_options(mut self, options: crate::SnapshotOptions) -> Self {
+        self.default_snapshot_options = options;
+        self
+    }
+
+    /// Override the [`egui::os::OperatingSystem`] reported to egui.
+    ///
+    /// This affects e.g. the way shortcuts are displayed. So for snapshot tests,
+    /// it makes sense to set this to a specific OS, so snapshots don't change when running
+    /// the same tests on different OSes.
+    ///
+    /// Default is [`egui::os::OperatingSystem::Nix`].
+    /// Use [`egui::os::OperatingSystem::from_target_os()`] to use the current OS (this restores
+    /// eguis default behavior).
+    #[inline]
+    pub fn with_os(mut self, os: egui::os::OperatingSystem) -> Self {
+        self.os = os;
+        self
+    }
+
     /// Set the maximum number of steps to run when calling [`Harness::run`].
     ///
     /// Default is 4.
@@ -63,6 +106,19 @@ impl<State> HarnessBuilder<State> {
         self
     }
 
+    /// Should we wait for pending images?
+    ///
+    /// If `true`, [`Harness::run`] and related methods will check if there are pending images
+    /// (via [`egui::Context::has_pending_images`]) and sleep for [`Self::with_step_dt`] up to
+    /// [`Self::with_max_steps`] times.
+    ///
+    /// Default: `true`
+    #[inline]
+    pub fn with_wait_for_pending_images(mut self, wait_for_pending_images: bool) -> Self {
+        self.wait_for_pending_images = wait_for_pending_images;
+        self
+    }
+
     /// Set the [`TestRenderer`] to use for rendering.
     ///
     /// By default, a [`LazyRenderer`] is used.
@@ -190,6 +246,7 @@ impl HarnessBuilder {
     ///         });
     ///     });
     /// ```
+    #[must_use]
     pub fn build<'a>(self, app: impl FnMut(&egui::Context) + 'a) -> Harness<'a> {
         Harness::from_builder(self, AppKind::Context(Box::new(app)), (), None)
     }
@@ -209,6 +266,7 @@ impl HarnessBuilder {
     ///         ui.label("Hello, world!");
     ///     });
     /// ```
+    #[must_use]
     pub fn build_ui<'a>(self, app: impl FnMut(&mut egui::Ui) + 'a) -> Harness<'a> {
         Harness::from_builder(self, AppKind::Ui(Box::new(app)), (), None)
     }
diff --git a/crates/egui_kittest/src/event.rs b/crates/egui_kittest/src/event.rs
deleted file mode 100644
index 5ac07488d..000000000
--- a/crates/egui_kittest/src/event.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-use egui::Event::PointerButton;
-use egui::{Event, Modifiers, Pos2};
-use kittest::{ElementState, MouseButton, SimulatedEvent};
-
-#[derive(Default)]
-pub(crate) struct EventState {
-    modifiers: Modifiers,
-    last_mouse_pos: Pos2,
-}
-
-impl EventState {
-    pub fn kittest_event_to_egui(&mut self, event: kittest::Event) -> Option<egui::Event> {
-        match event {
-            kittest::Event::ActionRequest(e) => Some(Event::AccessKitActionRequest(e)),
-            kittest::Event::Simulated(e) => match e {
-                SimulatedEvent::CursorMoved { position } => {
-                    self.last_mouse_pos = Pos2::new(position.x as f32, position.y as f32);
-                    Some(Event::PointerMoved(Pos2::new(
-                        position.x as f32,
-                        position.y as f32,
-                    )))
-                }
-                SimulatedEvent::MouseInput { state, button } => {
-                    pointer_button_to_egui(button).map(|button| PointerButton {
-                        button,
-                        modifiers: self.modifiers,
-                        pos: self.last_mouse_pos,
-                        pressed: matches!(state, ElementState::Pressed),
-                    })
-                }
-                SimulatedEvent::Ime(text) => Some(Event::Text(text)),
-                SimulatedEvent::KeyInput { state, key } => {
-                    match key {
-                        kittest::Key::Alt => {
-                            self.modifiers.alt = matches!(state, ElementState::Pressed);
-                        }
-                        kittest::Key::Command => {
-                            self.modifiers.command = matches!(state, ElementState::Pressed);
-                        }
-                        kittest::Key::Control => {
-                            self.modifiers.ctrl = matches!(state, ElementState::Pressed);
-                        }
-                        kittest::Key::Shift => {
-                            self.modifiers.shift = matches!(state, ElementState::Pressed);
-                        }
-                        _ => {}
-                    }
-                    kittest_key_to_egui(key).map(|key| Event::Key {
-                        key,
-                        modifiers: self.modifiers,
-                        pressed: matches!(state, ElementState::Pressed),
-                        repeat: false,
-                        physical_key: None,
-                    })
-                }
-            },
-        }
-    }
-}
-
-pub fn kittest_key_to_egui(value: kittest::Key) -> Option<egui::Key> {
-    use egui::Key as EKey;
-    use kittest::Key;
-    match value {
-        Key::ArrowDown => Some(EKey::ArrowDown),
-        Key::ArrowLeft => Some(EKey::ArrowLeft),
-        Key::ArrowRight => Some(EKey::ArrowRight),
-        Key::ArrowUp => Some(EKey::ArrowUp),
-        Key::Escape => Some(EKey::Escape),
-        Key::Tab => Some(EKey::Tab),
-        Key::Backspace => Some(EKey::Backspace),
-        Key::Enter => Some(EKey::Enter),
-        Key::Space => Some(EKey::Space),
-        Key::Insert => Some(EKey::Insert),
-        Key::Delete => Some(EKey::Delete),
-        Key::Home => Some(EKey::Home),
-        Key::End => Some(EKey::End),
-        Key::PageUp => Some(EKey::PageUp),
-        Key::PageDown => Some(EKey::PageDown),
-        Key::Copy => Some(EKey::Copy),
-        Key::Cut => Some(EKey::Cut),
-        Key::Paste => Some(EKey::Paste),
-        Key::Colon => Some(EKey::Colon),
-        Key::Comma => Some(EKey::Comma),
-        Key::Backslash => Some(EKey::Backslash),
-        Key::Slash => Some(EKey::Slash),
-        Key::Pipe => Some(EKey::Pipe),
-        Key::Questionmark => Some(EKey::Questionmark),
-        Key::OpenBracket => Some(EKey::OpenBracket),
-        Key::CloseBracket => Some(EKey::CloseBracket),
-        Key::Backtick => Some(EKey::Backtick),
-        Key::Minus => Some(EKey::Minus),
-        Key::Period => Some(EKey::Period),
-        Key::Plus => Some(EKey::Plus),
-        Key::Equals => Some(EKey::Equals),
-        Key::Semicolon => Some(EKey::Semicolon),
-        Key::Quote => Some(EKey::Quote),
-        Key::Num0 => Some(EKey::Num0),
-        Key::Num1 => Some(EKey::Num1),
-        Key::Num2 => Some(EKey::Num2),
-        Key::Num3 => Some(EKey::Num3),
-        Key::Num4 => Some(EKey::Num4),
-        Key::Num5 => Some(EKey::Num5),
-        Key::Num6 => Some(EKey::Num6),
-        Key::Num7 => Some(EKey::Num7),
-        Key::Num8 => Some(EKey::Num8),
-        Key::Num9 => Some(EKey::Num9),
-        Key::A => Some(EKey::A),
-        Key::B => Some(EKey::B),
-        Key::C => Some(EKey::C),
-        Key::D => Some(EKey::D),
-        Key::E => Some(EKey::E),
-        Key::F => Some(EKey::F),
-        Key::G => Some(EKey::G),
-        Key::H => Some(EKey::H),
-        Key::I => Some(EKey::I),
-        Key::J => Some(EKey::J),
-        Key::K => Some(EKey::K),
-        Key::L => Some(EKey::L),
-        Key::M => Some(EKey::M),
-        Key::N => Some(EKey::N),
-        Key::O => Some(EKey::O),
-        Key::P => Some(EKey::P),
-        Key::Q => Some(EKey::Q),
-        Key::R => Some(EKey::R),
-        Key::S => Some(EKey::S),
-        Key::T => Some(EKey::T),
-        Key::U => Some(EKey::U),
-        Key::V => Some(EKey::V),
-        Key::W => Some(EKey::W),
-        Key::X => Some(EKey::X),
-        Key::Y => Some(EKey::Y),
-        Key::Z => Some(EKey::Z),
-        Key::F1 => Some(EKey::F1),
-        Key::F2 => Some(EKey::F2),
-        Key::F3 => Some(EKey::F3),
-        Key::F4 => Some(EKey::F4),
-        Key::F5 => Some(EKey::F5),
-        Key::F6 => Some(EKey::F6),
-        Key::F7 => Some(EKey::F7),
-        Key::F8 => Some(EKey::F8),
-        Key::F9 => Some(EKey::F9),
-        Key::F10 => Some(EKey::F10),
-        Key::F11 => Some(EKey::F11),
-        Key::F12 => Some(EKey::F12),
-        Key::F13 => Some(EKey::F13),
-        Key::F14 => Some(EKey::F14),
-        Key::F15 => Some(EKey::F15),
-        Key::F16 => Some(EKey::F16),
-        Key::F17 => Some(EKey::F17),
-        Key::F18 => Some(EKey::F18),
-        Key::F19 => Some(EKey::F19),
-        Key::F20 => Some(EKey::F20),
-        Key::F21 => Some(EKey::F21),
-        Key::F22 => Some(EKey::F22),
-        Key::F23 => Some(EKey::F23),
-        Key::F24 => Some(EKey::F24),
-        Key::F25 => Some(EKey::F25),
-        Key::F26 => Some(EKey::F26),
-        Key::F27 => Some(EKey::F27),
-        Key::F28 => Some(EKey::F28),
-        Key::F29 => Some(EKey::F29),
-        Key::F30 => Some(EKey::F30),
-        Key::F31 => Some(EKey::F31),
-        Key::F32 => Some(EKey::F32),
-        Key::F33 => Some(EKey::F33),
-        Key::F34 => Some(EKey::F34),
-        Key::F35 => Some(EKey::F35),
-        _ => None,
-    }
-}
-
-pub fn pointer_button_to_egui(value: MouseButton) -> Option<egui::PointerButton> {
-    match value {
-        MouseButton::Left => Some(egui::PointerButton::Primary),
-        MouseButton::Right => Some(egui::PointerButton::Secondary),
-        MouseButton::Middle => Some(egui::PointerButton::Middle),
-        MouseButton::Back => Some(egui::PointerButton::Extra1),
-        MouseButton::Forward => Some(egui::PointerButton::Extra2),
-        MouseButton::Other(_) => None,
-    }
-}
diff --git a/crates/egui_kittest/src/lib.rs b/crates/egui_kittest/src/lib.rs
index 661cb92c3..33a188ea4 100644
--- a/crates/egui_kittest/src/lib.rs
+++ b/crates/egui_kittest/src/lib.rs
@@ -4,33 +4,41 @@
 #![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
 
 mod builder;
-mod event;
 #[cfg(feature = "snapshot")]
 mod snapshot;
 
 #[cfg(feature = "snapshot")]
-pub use snapshot::*;
-use std::fmt::{Debug, Display, Formatter};
-use std::time::Duration;
+pub use crate::snapshot::*;
 
 mod app_kind;
+mod node;
 mod renderer;
 #[cfg(feature = "wgpu")]
 mod texture_to_image;
 #[cfg(feature = "wgpu")]
 pub mod wgpu;
 
-pub use kittest;
+// re-exports:
+pub use {
+    self::{builder::*, node::*, renderer::*},
+    kittest,
+};
+
+use std::{
+    fmt::{Debug, Display, Formatter},
+    time::Duration,
+};
+
+use egui::{
+    Color32, Key, Modifiers, PointerButton, Pos2, Rect, RepaintCause, Shape, Vec2, ViewportId,
+    epaint::{ClippedShape, RectShape},
+    style::ScrollAnimation,
+};
+use kittest::Queryable;
 
 use crate::app_kind::AppKind;
-use crate::event::EventState;
-
-pub use builder::*;
-pub use renderer::*;
-
-use egui::{Modifiers, Pos2, Rect, RepaintCause, Vec2, ViewportId};
-use kittest::{Node, Queryable};
 
+#[derive(Debug, Clone)]
 pub struct ExceededMaxStepsError {
     pub max_steps: u64,
     pub repaint_causes: Vec<RepaintCause>,
@@ -49,23 +57,32 @@ impl Display for ExceededMaxStepsError {
 }
 
 /// The test Harness. This contains everything needed to run the test.
+///
 /// Create a new Harness using [`Harness::new`] or [`Harness::builder`].
 ///
 /// The [Harness] has a optional generic state that can be used to pass data to the app / ui closure.
 /// In _most cases_ it should be fine to just store the state in the closure itself.
 /// The state functions are useful if you need to access the state after the harness has been created.
+///
+/// Some egui style options are changed from the defaults:
+/// - The cursor blinking is disabled
+/// - The scroll animation is disabled
 pub struct Harness<'a, State = ()> {
     pub ctx: egui::Context,
     input: egui::RawInput,
     kittest: kittest::State,
     output: egui::FullOutput,
     app: AppKind<'a, State>,
-    event_state: EventState,
     response: Option<egui::Response>,
     state: State,
     renderer: Box<dyn TestRenderer>,
     max_steps: u64,
     step_dt: f32,
+    wait_for_pending_images: bool,
+    queued_events: EventQueue,
+
+    #[cfg(feature = "snapshot")]
+    default_snapshot_options: SnapshotOptions,
 }
 
 impl<State> Debug for Harness<'_, State> {
@@ -84,15 +101,27 @@ impl<'a, State> Harness<'a, State> {
         let HarnessBuilder {
             screen_rect,
             pixels_per_point,
+            theme,
+            os,
             max_steps,
             step_dt,
             state: _,
             mut renderer,
+            wait_for_pending_images,
+
+            #[cfg(feature = "snapshot")]
+            default_snapshot_options,
         } = builder;
         let ctx = ctx.unwrap_or_default();
+        ctx.set_theme(theme);
+        ctx.set_os(os);
         ctx.enable_accesskit();
-        // Disable cursor blinking so it doesn't interfere with snapshots
-        ctx.all_styles_mut(|style| style.visuals.text_cursor.blink = false);
+        ctx.all_styles_mut(|style| {
+            // Disable cursor blinking so it doesn't interfere with snapshots
+            style.visuals.text_cursor.blink = false;
+            style.scroll_animation = ScrollAnimation::none();
+            style.animation_time = 0.0;
+        });
         let mut input = egui::RawInput {
             screen_rect: Some(screen_rect),
             ..Default::default()
@@ -123,11 +152,15 @@ impl<'a, State> Harness<'a, State> {
             ),
             output,
             response,
-            event_state: EventState::default(),
             state,
             renderer,
             max_steps,
             step_dt,
+            wait_for_pending_images,
+            queued_events: Default::default(),
+
+            #[cfg(feature = "snapshot")]
+            default_snapshot_options,
         };
         // Run the harness until it is stable, ensuring that all Areas are shown and animations are done
         harness.run_ok();
@@ -219,20 +252,29 @@ impl<'a, State> Harness<'a, State> {
         self
     }
 
-    /// Run a frame.
-    /// This will call the app closure with the queued events and current context and
+    /// Run a frame for each queued event (or a single frame if there are no events).
+    /// This will call the app closure with each queued event and
     /// update the Harness.
     pub fn step(&mut self) {
-        self._step(false);
+        let events = std::mem::take(&mut *self.queued_events.lock());
+        if events.is_empty() {
+            self._step(false);
+        }
+        for event in events {
+            match event {
+                EventType::Event(event) => {
+                    self.input.events.push(event);
+                }
+                EventType::Modifiers(modifiers) => {
+                    self.input.modifiers = modifiers;
+                }
+            }
+            self._step(false);
+        }
     }
 
+    /// Run a single step. This will not process any events.
     fn _step(&mut self, sizing_pass: bool) {
-        for event in self.kittest.take_events() {
-            if let Some(event) = self.event_state.kittest_event_to_egui(event) {
-                self.input.events.push(event);
-            }
-        }
-
         self.input.predicted_dt = self.step_dt;
 
         let mut output = self.ctx.run(self.input.take(), |ctx| {
@@ -249,14 +291,39 @@ impl<'a, State> Harness<'a, State> {
         self.output = output;
     }
 
+    /// Calculate the rect that includes all popups and tooltips.
+    fn compute_total_rect_with_popups(&self) -> Option<Rect> {
+        // Start with the standard response rect
+        let mut used = if let Some(response) = self.response.as_ref() {
+            response.rect
+        } else {
+            return None;
+        };
+
+        // Add all visible areas from other orders (popups, tooltips, etc.)
+        self.ctx.memory(|mem| {
+            mem.areas()
+                .visible_layer_ids()
+                .into_iter()
+                .filter(|layer_id| layer_id.order != egui::Order::Background)
+                .filter_map(|layer_id| mem.area_rect(layer_id.id))
+                .for_each(|area_rect| used |= area_rect);
+        });
+
+        Some(used)
+    }
+
     /// Resize the test harness to fit the contents. This only works when creating the Harness via
     /// [`Harness::new_ui`] / [`Harness::new_ui_state`] or
     /// [`HarnessBuilder::build_ui`] / [`HarnessBuilder::build_ui_state`].
     pub fn fit_contents(&mut self) {
         self._step(true);
-        if let Some(response) = &self.response {
-            self.set_size(response.rect.size());
+
+        // Calculate size including all content (main UI + popups + tooltips)
+        if let Some(rect) = self.compute_total_rect_with_popups() {
+            self.set_size(rect.size());
         }
+
         self.run_ok();
     }
 
@@ -272,6 +339,7 @@ impl<'a, State> Harness<'a, State> {
     ///
     /// See also:
     /// - [`Harness::try_run`].
+    /// - [`Harness::try_run_realtime`].
     /// - [`Harness::run_ok`].
     /// - [`Harness::step`].
     /// - [`Harness::run_steps`].
@@ -285,6 +353,30 @@ impl<'a, State> Harness<'a, State> {
         }
     }
 
+    fn _try_run(&mut self, sleep: bool) -> Result<u64, ExceededMaxStepsError> {
+        let mut steps = 0;
+        loop {
+            steps += 1;
+            self.step();
+
+            let wait_for_images = self.wait_for_pending_images && self.ctx.has_pending_images();
+
+            // We only care about immediate repaints
+            if self.root_viewport_output().repaint_delay != Duration::ZERO && !wait_for_images {
+                break;
+            } else if sleep || wait_for_images {
+                std::thread::sleep(Duration::from_secs_f32(self.step_dt));
+            }
+            if steps > self.max_steps {
+                return Err(ExceededMaxStepsError {
+                    max_steps: self.max_steps,
+                    repaint_causes: self.ctx.repaint_causes(),
+                });
+            }
+        }
+        Ok(steps)
+    }
+
     /// Run until
     /// - all animations are done
     /// - no more repaints are requested
@@ -300,23 +392,9 @@ impl<'a, State> Harness<'a, State> {
     /// - [`Harness::run_ok`].
     /// - [`Harness::step`].
     /// - [`Harness::run_steps`].
+    /// - [`Harness::try_run_realtime`].
     pub fn try_run(&mut self) -> Result<u64, ExceededMaxStepsError> {
-        let mut steps = 0;
-        loop {
-            steps += 1;
-            self.step();
-            // We only care about immediate repaints
-            if self.root_viewport_output().repaint_delay != Duration::ZERO {
-                break;
-            }
-            if steps > self.max_steps {
-                return Err(ExceededMaxStepsError {
-                    max_steps: self.max_steps,
-                    repaint_causes: self.ctx.repaint_causes(),
-                });
-            }
-        }
-        Ok(steps)
+        self._try_run(false)
     }
 
     /// Run until
@@ -331,10 +409,34 @@ impl<'a, State> Harness<'a, State> {
     /// - [`Harness::try_run`].
     /// - [`Harness::step`].
     /// - [`Harness::run_steps`].
+    /// - [`Harness::try_run_realtime`].
     pub fn run_ok(&mut self) -> Option<u64> {
         self.try_run().ok()
     }
 
+    /// Run multiple frames, sleeping for [`HarnessBuilder::with_step_dt`] between frames.
+    ///
+    /// This is useful to e.g. wait for an async operation to complete (e.g. loading of images).
+    /// Runs until
+    /// - all animations are done
+    /// - no more repaints are requested
+    /// - the maximum number of steps is reached (See [`HarnessBuilder::with_max_steps`])
+    ///
+    /// Returns the number of steps that were run.
+    ///
+    /// # Errors
+    /// Returns an error if the maximum number of steps is exceeded.
+    ///
+    /// See also:
+    /// - [`Harness::run`].
+    /// - [`Harness::run_ok`].
+    /// - [`Harness::step`].
+    /// - [`Harness::run_steps`].
+    /// - [`Harness::try_run`].
+    pub fn try_run_realtime(&mut self) -> Result<u64, ExceededMaxStepsError> {
+        self._try_run(true)
+    }
+
     /// Run a number of steps.
     /// Equivalent to calling [`Harness::step`] x times.
     pub fn run_steps(&mut self, steps: usize) {
@@ -373,31 +475,182 @@ impl<'a, State> Harness<'a, State> {
         &mut self.state
     }
 
-    /// Press a key.
-    /// This will create a key down event and a key up event.
-    pub fn press_key(&mut self, key: egui::Key) {
-        self.press_key_modifiers(Modifiers::default(), key);
+    /// Queue an event to be processed in the next frame.
+    pub fn event(&self, event: egui::Event) {
+        self.queued_events.lock().push(EventType::Event(event));
     }
 
-    /// Press a key with modifiers.
-    /// This will create a key down event and a key up event.
-    pub fn press_key_modifiers(&mut self, modifiers: Modifiers, key: egui::Key) {
-        self.input.events.push(egui::Event::Key {
+    /// Queue an event with modifiers.
+    ///
+    /// Queues the modifiers to be pressed, then the event, then the modifiers to be released.
+    pub fn event_modifiers(&self, event: egui::Event, modifiers: Modifiers) {
+        let mut queue = self.queued_events.lock();
+        queue.push(EventType::Modifiers(modifiers));
+        queue.push(EventType::Event(event));
+        queue.push(EventType::Modifiers(Modifiers::default()));
+    }
+
+    fn modifiers(&self, modifiers: Modifiers) {
+        self.queued_events
+            .lock()
+            .push(EventType::Modifiers(modifiers));
+    }
+
+    pub fn key_down(&self, key: egui::Key) {
+        self.event(egui::Event::Key {
             key,
             pressed: true,
-            modifiers,
+            modifiers: Modifiers::default(),
             repeat: false,
             physical_key: None,
         });
-        self.input.events.push(egui::Event::Key {
+    }
+
+    pub fn key_down_modifiers(&self, modifiers: Modifiers, key: egui::Key) {
+        self.event_modifiers(
+            egui::Event::Key {
+                key,
+                pressed: true,
+                modifiers,
+                repeat: false,
+                physical_key: None,
+            },
+            modifiers,
+        );
+    }
+
+    pub fn key_up(&self, key: egui::Key) {
+        self.event(egui::Event::Key {
             key,
             pressed: false,
-            modifiers,
+            modifiers: Modifiers::default(),
             repeat: false,
             physical_key: None,
         });
     }
 
+    pub fn key_up_modifiers(&self, modifiers: Modifiers, key: egui::Key) {
+        self.event_modifiers(
+            egui::Event::Key {
+                key,
+                pressed: false,
+                modifiers,
+                repeat: false,
+                physical_key: None,
+            },
+            modifiers,
+        );
+    }
+
+    /// Press the given keys in combination.
+    ///
+    /// For e.g. [`Key::A`] + [`Key::B`] this would generate:
+    /// - Press [`Key::A`]
+    /// - Press [`Key::B`]
+    /// - Release [`Key::B`]
+    /// - Release [`Key::A`]
+    pub fn key_combination(&self, keys: &[Key]) {
+        for key in keys {
+            self.key_down(*key);
+        }
+        for key in keys.iter().rev() {
+            self.key_up(*key);
+        }
+    }
+
+    /// Press the given keys in combination, with modifiers.
+    ///
+    /// For e.g. [`Modifiers::COMMAND`] + [`Key::A`] + [`Key::B`] this would generate:
+    /// - Press [`Modifiers::COMMAND`]
+    /// - Press [`Key::A`]
+    /// - Press [`Key::B`]
+    /// - Release [`Key::B`]
+    /// - Release [`Key::A`]
+    /// - Release [`Modifiers::COMMAND`]
+    pub fn key_combination_modifiers(&self, modifiers: Modifiers, keys: &[Key]) {
+        self.modifiers(modifiers);
+
+        for pressed in [true, false] {
+            for key in keys {
+                self.event(egui::Event::Key {
+                    key: *key,
+                    pressed,
+                    modifiers,
+                    repeat: false,
+                    physical_key: None,
+                });
+            }
+        }
+
+        self.modifiers(Modifiers::default());
+    }
+
+    /// Press a key.
+    ///
+    /// This will create a key down event and a key up event.
+    pub fn key_press(&self, key: egui::Key) {
+        self.key_combination(&[key]);
+    }
+
+    /// Press a key with modifiers.
+    ///
+    /// This will
+    /// - set the modifiers
+    /// - create a key down event
+    /// - create a key up event
+    /// - reset the modifiers
+    pub fn key_press_modifiers(&self, modifiers: Modifiers, key: egui::Key) {
+        self.key_combination_modifiers(modifiers, &[key]);
+    }
+
+    /// Move mouse cursor to this position.
+    pub fn hover_at(&self, pos: egui::Pos2) {
+        self.event(egui::Event::PointerMoved(pos));
+    }
+
+    /// Start dragging from a position.
+    pub fn drag_at(&self, pos: egui::Pos2) {
+        self.event(egui::Event::PointerButton {
+            pos,
+            button: PointerButton::Primary,
+            pressed: true,
+            modifiers: Modifiers::NONE,
+        });
+    }
+
+    /// Stop dragging and remove cursor.
+    pub fn drop_at(&self, pos: egui::Pos2) {
+        self.event(egui::Event::PointerButton {
+            pos,
+            button: PointerButton::Primary,
+            pressed: false,
+            modifiers: Modifiers::NONE,
+        });
+        self.remove_cursor();
+    }
+
+    /// Remove the cursor from the screen.
+    ///
+    /// Will fire a [`egui::Event::PointerGone`] event.
+    ///
+    /// If you click a button and then take a snapshot, the button will be shown as hovered.
+    /// If you don't want that, you can call this method after clicking.
+    pub fn remove_cursor(&self) {
+        self.event(egui::Event::PointerGone);
+    }
+
+    /// Mask something. Useful for snapshot tests.
+    ///
+    /// Call this _after_ [`Self::run`] and before [`Self::snapshot`].
+    /// This will add a [`RectShape`] to the output shapes, for the current frame.
+    /// Will be overwritten on the next call to [`Self::run`].
+    pub fn mask(&mut self, rect: Rect) {
+        self.output.shapes.push(ClippedShape {
+            clip_rect: Rect::EVERYTHING,
+            shape: Shape::Rect(RectShape::filled(rect, 0.0, Color32::MAGENTA)),
+        });
+    }
+
     /// Render the last output to an image.
     ///
     /// # Errors
@@ -414,6 +667,19 @@ impl<'a, State> Harness<'a, State> {
             .get(&ViewportId::ROOT)
             .expect("Missing root viewport")
     }
+
+    /// The root node of the test harness.
+    pub fn root(&self) -> Node<'_> {
+        Node {
+            accesskit_node: self.kittest.root(),
+            queue: &self.queued_events,
+        }
+    }
+
+    #[deprecated = "Use `Harness::root` instead."]
+    pub fn node(&self) -> Node<'_> {
+        self.root()
+    }
 }
 
 /// Utilities for stateless harnesses.
@@ -462,11 +728,11 @@ impl<'a> Harness<'a> {
     }
 }
 
-impl<'t, 'n, State> Queryable<'t, 'n> for Harness<'_, State>
+impl<'tree, 'node, State> Queryable<'tree, 'node, Node<'tree>> for Harness<'_, State>
 where
-    'n: 't,
+    'node: 'tree,
 {
-    fn node(&'n self) -> Node<'t> {
-        self.kittest_state().node()
+    fn queryable_node(&'node self) -> Node<'tree> {
+        self.root()
     }
 }
diff --git a/crates/egui_kittest/src/node.rs b/crates/egui_kittest/src/node.rs
new file mode 100644
index 000000000..94940ffff
--- /dev/null
+++ b/crates/egui_kittest/src/node.rs
@@ -0,0 +1,207 @@
+use egui::accesskit::ActionRequest;
+use egui::mutex::Mutex;
+use egui::{Modifiers, PointerButton, Pos2, accesskit};
+use kittest::{AccessKitNode, NodeT, debug_fmt_node};
+use std::fmt::{Debug, Formatter};
+
+pub(crate) enum EventType {
+    Event(egui::Event),
+    Modifiers(Modifiers),
+}
+
+pub(crate) type EventQueue = Mutex<Vec<EventType>>;
+
+#[derive(Clone, Copy)]
+pub struct Node<'tree> {
+    pub(crate) accesskit_node: AccessKitNode<'tree>,
+    pub(crate) queue: &'tree EventQueue,
+}
+
+impl Debug for Node<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        debug_fmt_node(self, f)
+    }
+}
+
+impl<'tree> NodeT<'tree> for Node<'tree> {
+    fn accesskit_node(&self) -> AccessKitNode<'tree> {
+        self.accesskit_node
+    }
+
+    fn new_related(&self, child_node: AccessKitNode<'tree>) -> Self {
+        Self {
+            queue: self.queue,
+            accesskit_node: child_node,
+        }
+    }
+}
+
+impl Node<'_> {
+    fn event(&self, event: egui::Event) {
+        self.queue.lock().push(EventType::Event(event));
+    }
+
+    fn modifiers(&self, modifiers: Modifiers) {
+        self.queue.lock().push(EventType::Modifiers(modifiers));
+    }
+
+    pub fn hover(&self) {
+        self.event(egui::Event::PointerMoved(self.rect().center()));
+    }
+
+    /// Click at the node center with the primary button.
+    pub fn click(&self) {
+        self.click_button(PointerButton::Primary);
+    }
+
+    #[deprecated = "Use `click()` instead."]
+    pub fn simulate_click(&self) {
+        self.click();
+    }
+
+    pub fn click_secondary(&self) {
+        self.click_button(PointerButton::Secondary);
+    }
+
+    pub fn click_button(&self, button: PointerButton) {
+        self.hover();
+        for pressed in [true, false] {
+            self.event(egui::Event::PointerButton {
+                pos: self.rect().center(),
+                button,
+                pressed,
+                modifiers: Modifiers::default(),
+            });
+        }
+    }
+
+    pub fn click_modifiers(&self, modifiers: Modifiers) {
+        self.click_button_modifiers(PointerButton::Primary, modifiers);
+    }
+
+    pub fn click_button_modifiers(&self, button: PointerButton, modifiers: Modifiers) {
+        self.hover();
+        self.modifiers(modifiers);
+        for pressed in [true, false] {
+            self.event(egui::Event::PointerButton {
+                pos: self.rect().center(),
+                button,
+                pressed,
+                modifiers,
+            });
+        }
+        self.modifiers(Modifiers::default());
+    }
+
+    /// Click the node via accesskit.
+    ///
+    /// This will trigger a [`accesskit::Action::Click`] action.
+    /// In contrast to `click()`, this can also click widgets that are not currently visible.
+    pub fn click_accesskit(&self) {
+        self.event(egui::Event::AccessKitActionRequest(
+            accesskit::ActionRequest {
+                target: self.accesskit_node.id(),
+                action: accesskit::Action::Click,
+                data: None,
+            },
+        ));
+    }
+
+    pub fn rect(&self) -> egui::Rect {
+        let rect = self
+            .accesskit_node
+            .bounding_box()
+            .expect("Every egui node should have a rect");
+        egui::Rect {
+            min: Pos2::new(rect.x0 as f32, rect.y0 as f32),
+            max: Pos2::new(rect.x1 as f32, rect.y1 as f32),
+        }
+    }
+
+    pub fn focus(&self) {
+        self.event(egui::Event::AccessKitActionRequest(ActionRequest {
+            action: accesskit::Action::Focus,
+            target: self.accesskit_node.id(),
+            data: None,
+        }));
+    }
+
+    #[deprecated = "Use `Harness::key_down` instead."]
+    pub fn key_down(&self, key: egui::Key) {
+        self.event(egui::Event::Key {
+            key,
+            pressed: true,
+            modifiers: Modifiers::default(),
+            repeat: false,
+            physical_key: None,
+        });
+    }
+
+    #[deprecated = "Use `Harness::key_up` instead."]
+    pub fn key_up(&self, key: egui::Key) {
+        self.event(egui::Event::Key {
+            key,
+            pressed: false,
+            modifiers: Modifiers::default(),
+            repeat: false,
+            physical_key: None,
+        });
+    }
+
+    pub fn type_text(&self, text: &str) {
+        self.event(egui::Event::Text(text.to_owned()));
+    }
+
+    pub fn value(&self) -> Option<String> {
+        self.accesskit_node.value()
+    }
+
+    pub fn is_focused(&self) -> bool {
+        self.accesskit_node.is_focused()
+    }
+
+    /// Scroll the node into view.
+    pub fn scroll_to_me(&self) {
+        self.event(egui::Event::AccessKitActionRequest(ActionRequest {
+            action: accesskit::Action::ScrollIntoView,
+            target: self.accesskit_node.id(),
+            data: None,
+        }));
+    }
+
+    /// Scroll the [`egui::ScrollArea`] containing this node down (100px).
+    pub fn scroll_down(&self) {
+        self.event(egui::Event::AccessKitActionRequest(ActionRequest {
+            action: accesskit::Action::ScrollDown,
+            target: self.accesskit_node.id(),
+            data: None,
+        }));
+    }
+
+    /// Scroll the [`egui::ScrollArea`] containing this node up (100px).
+    pub fn scroll_up(&self) {
+        self.event(egui::Event::AccessKitActionRequest(ActionRequest {
+            action: accesskit::Action::ScrollUp,
+            target: self.accesskit_node.id(),
+            data: None,
+        }));
+    }
+
+    /// Scroll the [`egui::ScrollArea`] containing this node left (100px).
+    pub fn scroll_left(&self) {
+        self.event(egui::Event::AccessKitActionRequest(ActionRequest {
+            action: accesskit::Action::ScrollLeft,
+            target: self.accesskit_node.id(),
+            data: None,
+        }));
+    }
+
+    /// Scroll the [`egui::ScrollArea`] containing this node right (100px).
+    pub fn scroll_right(&self) {
+        self.event(egui::Event::AccessKitActionRequest(ActionRequest {
+            action: accesskit::Action::ScrollRight,
+            target: self.accesskit_node.id(),
+            data: None,
+        }));
+    }
+}
diff --git a/crates/egui_kittest/src/snapshot.rs b/crates/egui_kittest/src/snapshot.rs
index 86ed053d2..f6511c451 100644
--- a/crates/egui_kittest/src/snapshot.rs
+++ b/crates/egui_kittest/src/snapshot.rs
@@ -7,22 +7,125 @@ use std::path::PathBuf;
 pub type SnapshotResult = Result<(), SnapshotError>;
 
 #[non_exhaustive]
+#[derive(Clone, Debug)]
 pub struct SnapshotOptions {
     /// The threshold for the image comparison.
     /// The default is `0.6` (which is enough for most egui tests to pass across different
     /// wgpu backends).
     pub threshold: f32,
 
+    /// The number of pixels that can differ before the snapshot is considered a failure.
+    /// Preferably, you should use `threshold` to control the sensitivity of the image comparison.
+    /// As a last resort, you can use this to allow a certain number of pixels to differ.
+    /// If `None`, the default is `0` (meaning no pixels can differ).
+    /// If `Some`, the value can be set per OS
+    pub failed_pixel_count_threshold: usize,
+
     /// The path where the snapshots will be saved.
     /// The default is `tests/snapshots`.
     pub output_path: PathBuf,
 }
 
+/// Helper struct to define the number of pixels that can differ before the snapshot is considered a failure.
+///
+/// This is useful if you want to set different thresholds for different operating systems.
+///
+/// The default values are 0 / 0.0
+///
+/// Example usage:
+/// ```no_run
+///  use egui_kittest::{OsThreshold, SnapshotOptions};
+///  let mut harness = egui_kittest::Harness::new_ui(|ui| {
+///      ui.label("Hi!");
+///  });
+///  harness.snapshot_options(
+///      "os_threshold_example",
+///      &SnapshotOptions::new()
+///          .threshold(OsThreshold::new(0.0).windows(10.0))
+///          .failed_pixel_count_threshold(OsThreshold::new(0).windows(10).macos(53)
+///  ))
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct OsThreshold<T> {
+    pub windows: T,
+    pub macos: T,
+    pub linux: T,
+    pub fallback: T,
+}
+
+impl From<usize> for OsThreshold<usize> {
+    fn from(value: usize) -> Self {
+        Self::new(value)
+    }
+}
+
+impl<T> OsThreshold<T>
+where
+    T: Copy,
+{
+    /// Use the same value for all
+    pub fn new(same: T) -> Self {
+        Self {
+            windows: same,
+            macos: same,
+            linux: same,
+            fallback: same,
+        }
+    }
+
+    /// Set the threshold for Windows.
+    #[inline]
+    pub fn windows(mut self, threshold: T) -> Self {
+        self.windows = threshold;
+        self
+    }
+
+    /// Set the threshold for macOS.
+    #[inline]
+    pub fn macos(mut self, threshold: T) -> Self {
+        self.macos = threshold;
+        self
+    }
+
+    /// Set the threshold for Linux.
+    #[inline]
+    pub fn linux(mut self, threshold: T) -> Self {
+        self.linux = threshold;
+        self
+    }
+
+    /// Get the threshold for the current operating system.
+    pub fn threshold(&self) -> T {
+        if cfg!(target_os = "windows") {
+            self.windows
+        } else if cfg!(target_os = "macos") {
+            self.macos
+        } else if cfg!(target_os = "linux") {
+            self.linux
+        } else {
+            self.fallback
+        }
+    }
+}
+
+impl From<OsThreshold<Self>> for usize {
+    fn from(threshold: OsThreshold<Self>) -> Self {
+        threshold.threshold()
+    }
+}
+
+impl From<OsThreshold<Self>> for f32 {
+    fn from(threshold: OsThreshold<Self>) -> Self {
+        threshold.threshold()
+    }
+}
+
 impl Default for SnapshotOptions {
     fn default() -> Self {
         Self {
             threshold: 0.6,
             output_path: PathBuf::from("tests/snapshots"),
+            failed_pixel_count_threshold: 0, // Default is 0, meaning no pixels can differ
         }
     }
 }
@@ -37,8 +140,8 @@ impl SnapshotOptions {
     /// The default is `0.6` (which is enough for most egui tests to pass across different
     /// wgpu backends).
     #[inline]
-    pub fn threshold(mut self, threshold: f32) -> Self {
-        self.threshold = threshold;
+    pub fn threshold(mut self, threshold: impl Into<f32>) -> Self {
+        self.threshold = threshold.into();
         self
     }
 
@@ -49,6 +152,20 @@ impl SnapshotOptions {
         self.output_path = output_path.into();
         self
     }
+
+    /// Change the number of pixels that can differ before the snapshot is considered a failure.
+    ///
+    /// Preferably, you should use [`Self::threshold`] to control the sensitivity of the image comparison.
+    /// As a last resort, you can use this to allow a certain number of pixels to differ.
+    #[inline]
+    pub fn failed_pixel_count_threshold(
+        mut self,
+        failed_pixel_count_threshold: impl Into<OsThreshold<usize>>,
+    ) -> Self {
+        let failed_pixel_count_threshold = failed_pixel_count_threshold.into().threshold();
+        self.failed_pixel_count_threshold = failed_pixel_count_threshold;
+        self
+    }
 }
 
 #[derive(Debug)]
@@ -58,7 +175,7 @@ pub enum SnapshotError {
         /// Name of the test
         name: String,
 
-        /// Count of pixels that were different
+        /// Count of pixels that were different (above the per-pixel threshold).
         diff: i32,
 
         /// Path where the diff image was saved
@@ -117,7 +234,8 @@ impl Display for SnapshotError {
                 let diff_path = std::path::absolute(diff_path).unwrap_or(diff_path.clone());
                 write!(
                     f,
-                    "'{name}' Image did not match snapshot. Diff: {diff}, {diff_path:?}. {HOW_TO_UPDATE_SCREENSHOTS}"
+                    "'{name}' Image did not match snapshot. Diff: {diff}, {}. {HOW_TO_UPDATE_SCREENSHOTS}",
+                    diff_path.display()
                 )
             }
             Self::OpenSnapshot { path, err } => {
@@ -125,14 +243,26 @@ impl Display for SnapshotError {
                 match err {
                     ImageError::IoError(io) => match io.kind() {
                         ErrorKind::NotFound => {
-                            write!(f, "Missing snapshot: {path:?}. {HOW_TO_UPDATE_SCREENSHOTS}")
+                            write!(
+                                f,
+                                "Missing snapshot: {}. {HOW_TO_UPDATE_SCREENSHOTS}",
+                                path.display()
+                            )
                         }
                         err => {
-                            write!(f, "Error reading snapshot: {err:?}\nAt: {path:?}. {HOW_TO_UPDATE_SCREENSHOTS}")
+                            write!(
+                                f,
+                                "Error reading snapshot: {err}\nAt: {}. {HOW_TO_UPDATE_SCREENSHOTS}",
+                                path.display()
+                            )
                         }
                     },
                     err => {
-                        write!(f, "Error decoding snapshot: {err:?}\nAt: {path:?}. Make sure git-lfs is setup correctly. Read the instructions here: https://github.com/emilk/egui/blob/master/CONTRIBUTING.md#making-a-pr")
+                        write!(
+                            f,
+                            "Error decoding snapshot: {err}\nAt: {}. Make sure git-lfs is setup correctly. Read the instructions here: https://github.com/emilk/egui/blob/main/CONTRIBUTING.md#making-a-pr",
+                            path.display()
+                        )
                     }
                 }
             }
@@ -148,23 +278,43 @@ impl Display for SnapshotError {
             }
             Self::WriteSnapshot { path, err } => {
                 let path = std::path::absolute(path).unwrap_or(path.clone());
-                write!(f, "Error writing snapshot: {err:?}\nAt: {path:?}")
+                write!(f, "Error writing snapshot: {err}\nAt: {}", path.display())
             }
             Self::RenderError { err } => {
-                write!(f, "Error rendering image: {err:?}")
+                write!(f, "Error rendering image: {err}")
             }
         }
     }
 }
 
-/// If this is set, we update the snapshots (if different),
-/// and _succeed_ the test.
-/// This is so that you can set `UPDATE_SNAPSHOTS=true` and update _all_ tests,
-/// without `cargo test` failing on the first failing crate.
-fn should_update_snapshots() -> bool {
-    match std::env::var("UPDATE_SNAPSHOTS") {
-        Ok(value) => !matches!(value.as_str(), "false" | "0" | "no" | "off"),
-        Err(_) => false,
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Mode {
+    Test,
+    UpdateFailing,
+    UpdateAll,
+}
+
+impl Mode {
+    fn from_env() -> Self {
+        let Ok(value) = std::env::var("UPDATE_SNAPSHOTS") else {
+            return Self::Test;
+        };
+
+        match value.as_str() {
+            "false" | "0" | "no" | "off" => Self::Test,
+            "true" | "1" | "yes" | "on" => Self::UpdateFailing,
+            "force" => Self::UpdateAll,
+            unknown => {
+                panic!("Unsupported value for UPDATE_SNAPSHOTS: {unknown:?}");
+            }
+        }
+    }
+
+    fn is_update(&self) -> bool {
+        match self {
+            Self::Test => false,
+            Self::UpdateFailing | Self::UpdateAll => true,
+        }
     }
 }
 
@@ -189,15 +339,28 @@ fn should_update_snapshots() -> bool {
 /// reading or writing the snapshot.
 pub fn try_image_snapshot_options(
     new: &image::RgbaImage,
-    name: &str,
+    name: impl Into<String>,
     options: &SnapshotOptions,
 ) -> SnapshotResult {
+    try_image_snapshot_options_impl(new, name.into(), options)
+}
+
+fn try_image_snapshot_options_impl(
+    new: &image::RgbaImage,
+    name: String,
+    options: &SnapshotOptions,
+) -> SnapshotResult {
+    #![expect(clippy::print_stdout)]
+
+    let mode = Mode::from_env();
+
     let SnapshotOptions {
         threshold,
         output_path,
+        failed_pixel_count_threshold,
     } = options;
 
-    let parent_path = if let Some(parent) = PathBuf::from(name).parent() {
+    let parent_path = if let Some(parent) = PathBuf::from(&name).parent() {
         output_path.join(parent)
     } else {
         output_path.clone()
@@ -231,25 +394,29 @@ pub fn try_image_snapshot_options(
         // No need for an explicit `.new` file:
         std::fs::remove_file(&new_path).ok();
 
-        println!("Updated snapshot: {snapshot_path:?}");
+        println!("Updated snapshot: {}", snapshot_path.display());
 
         Ok(())
     };
 
-    // Always write a `.new` file so the user can compare:
-    new.save(&new_path)
-        .map_err(|err| SnapshotError::WriteSnapshot {
-            err,
-            path: new_path.clone(),
-        })?;
+    let write_new_png = || {
+        new.save(&new_path)
+            .map_err(|err| SnapshotError::WriteSnapshot {
+                err,
+                path: new_path.clone(),
+            })?;
+        Ok(())
+    };
 
     let previous = match image::open(&snapshot_path) {
         Ok(image) => image.to_rgba8(),
         Err(err) => {
-            // No previous snapshot - probablye a new test.
-            if should_update_snapshots() {
+            // No previous snapshot - probably a new test.
+            if mode.is_update() {
                 return update_snapshot();
             } else {
+                write_new_png()?;
+
                 return Err(SnapshotError::OpenSnapshot {
                     path: snapshot_path.clone(),
                     err,
@@ -259,11 +426,13 @@ pub fn try_image_snapshot_options(
     };
 
     if previous.dimensions() != new.dimensions() {
-        if should_update_snapshots() {
+        if mode.is_update() {
             return update_snapshot();
         } else {
+            write_new_png()?;
+
             return Err(SnapshotError::SizeMismatch {
-                name: name.to_owned(),
+                name,
                 expected: previous.dimensions(),
                 actual: new.dimensions(),
             });
@@ -271,27 +440,52 @@ pub fn try_image_snapshot_options(
     }
 
     // Compare existing image to the new one:
-    let result =
-        dify::diff::get_results(previous, new.clone(), *threshold, true, None, &None, &None);
+    let threshold = if mode == Mode::UpdateAll {
+        0.0 // Produce diff for any error, however small
+    } else {
+        *threshold
+    };
 
-    if let Some((diff, result_image)) = result {
-        result_image
+    let result =
+        dify::diff::get_results(previous, new.clone(), threshold, true, None, &None, &None);
+
+    let Some((num_wrong_pixels, diff_image)) = result else {
+        return Ok(()); // Difference below threshold
+    };
+
+    let below_threshold = num_wrong_pixels as i64 <= *failed_pixel_count_threshold as i64;
+
+    if !below_threshold {
+        diff_image
             .save(diff_path.clone())
             .map_err(|err| SnapshotError::WriteSnapshot {
                 path: diff_path.clone(),
                 err,
             })?;
-        if should_update_snapshots() {
-            update_snapshot()
-        } else {
-            Err(SnapshotError::Diff {
-                name: name.to_owned(),
-                diff,
-                diff_path,
-            })
+    }
+
+    match mode {
+        Mode::Test => {
+            if below_threshold {
+                Ok(())
+            } else {
+                write_new_png()?;
+
+                Err(SnapshotError::Diff {
+                    name,
+                    diff: num_wrong_pixels,
+                    diff_path,
+                })
+            }
         }
-    } else {
-        Ok(())
+        Mode::UpdateFailing => {
+            if below_threshold {
+                Ok(())
+            } else {
+                update_snapshot()
+            }
+        }
+        Mode::UpdateAll => update_snapshot(),
     }
 }
 
@@ -308,7 +502,7 @@ pub fn try_image_snapshot_options(
 /// # Errors
 /// Returns a [`SnapshotError`] if the image does not match the snapshot or if there was an error
 /// reading or writing the snapshot.
-pub fn try_image_snapshot(current: &image::RgbaImage, name: &str) -> SnapshotResult {
+pub fn try_image_snapshot(current: &image::RgbaImage, name: impl Into<String>) -> SnapshotResult {
     try_image_snapshot_options(current, name, &SnapshotOptions::default())
 }
 
@@ -329,16 +523,21 @@ pub fn try_image_snapshot(current: &image::RgbaImage, name: &str) -> SnapshotRes
 /// Panics if the image does not match the snapshot or if there was an error reading or writing the
 /// snapshot.
 #[track_caller]
-pub fn image_snapshot_options(current: &image::RgbaImage, name: &str, options: &SnapshotOptions) {
+pub fn image_snapshot_options(
+    current: &image::RgbaImage,
+    name: impl Into<String>,
+    options: &SnapshotOptions,
+) {
     match try_image_snapshot_options(current, name, options) {
         Ok(_) => {}
         Err(err) => {
-            panic!("{}", err);
+            panic!("{err}");
         }
     }
 }
 
 /// Image snapshot test.
+///
 /// The snapshot will be saved under `tests/snapshots/{name}.png`.
 /// The new image from the last test run will be saved under `tests/snapshots/{name}.new.png`.
 /// If the new image didn't match the snapshot, a diff image will be saved under `tests/snapshots/{name}.diff.png`.
@@ -347,20 +546,28 @@ pub fn image_snapshot_options(current: &image::RgbaImage, name: &str, options: &
 /// Panics if the image does not match the snapshot or if there was an error reading or writing the
 /// snapshot.
 #[track_caller]
-pub fn image_snapshot(current: &image::RgbaImage, name: &str) {
+pub fn image_snapshot(current: &image::RgbaImage, name: impl Into<String>) {
     match try_image_snapshot(current, name) {
         Ok(_) => {}
         Err(err) => {
-            panic!("{}", err);
+            panic!("{err}");
         }
     }
 }
 
-#[cfg(feature = "wgpu")]
+#[cfg(any(feature = "wgpu", feature = "snapshot"))]
 impl<State> Harness<'_, State> {
+    /// The default options used for snapshot tests.
+    /// set by [`crate::HarnessBuilder::with_options`].
+    pub fn options(&self) -> &SnapshotOptions {
+        &self.default_snapshot_options
+    }
+
     /// Render an image using the setup [`crate::TestRenderer`] and compare it to the snapshot
     /// with custom options.
     ///
+    /// These options will override the ones set by [`crate::HarnessBuilder::with_options`].
+    ///
     /// If you want to change the default options for your whole project, you could create an
     /// [extension trait](http://xion.io/post/code/rust-extension-traits.html) to create a
     /// new `my_image_snapshot` function on the Harness that calls this function with the desired options.
@@ -378,16 +585,19 @@ impl<State> Harness<'_, State> {
     /// error reading or writing the snapshot, if the rendering fails or if no default renderer is available.
     pub fn try_snapshot_options(
         &mut self,
-        name: &str,
+        name: impl Into<String>,
         options: &SnapshotOptions,
     ) -> SnapshotResult {
         let image = self
             .render()
             .map_err(|err| SnapshotError::RenderError { err })?;
-        try_image_snapshot_options(&image, name, options)
+        try_image_snapshot_options(&image, name.into(), options)
     }
 
     /// Render an image using the setup [`crate::TestRenderer`] and compare it to the snapshot.
+    ///
+    /// This is like [`Self::try_snapshot_options`] but will use the options set by [`crate::HarnessBuilder::with_options`].
+    ///
     /// The snapshot will be saved under `tests/snapshots/{name}.png`.
     /// The new image from the last test run will be saved under `tests/snapshots/{name}.new.png`.
     /// If the new image didn't match the snapshot, a diff image will be saved under `tests/snapshots/{name}.diff.png`.
@@ -395,16 +605,18 @@ impl<State> Harness<'_, State> {
     /// # Errors
     /// Returns a [`SnapshotError`] if the image does not match the snapshot, if there was an
     /// error reading or writing the snapshot, if the rendering fails or if no default renderer is available.
-    pub fn try_snapshot(&mut self, name: &str) -> SnapshotResult {
+    pub fn try_snapshot(&mut self, name: impl Into<String>) -> SnapshotResult {
         let image = self
             .render()
             .map_err(|err| SnapshotError::RenderError { err })?;
-        try_image_snapshot(&image, name)
+        try_image_snapshot_options(&image, name.into(), &self.default_snapshot_options)
     }
 
     /// Render an image using the setup [`crate::TestRenderer`] and compare it to the snapshot
     /// with custom options.
     ///
+    /// These options will override the ones set by [`crate::HarnessBuilder::with_options`].
+    ///
     /// If you want to change the default options for your whole project, you could create an
     /// [extension trait](http://xion.io/post/code/rust-extension-traits.html) to create a
     /// new `my_image_snapshot` function on the Harness that calls this function with the desired options.
@@ -421,16 +633,19 @@ impl<State> Harness<'_, State> {
     /// Panics if the image does not match the snapshot, if there was an error reading or writing the
     /// snapshot, if the rendering fails or if no default renderer is available.
     #[track_caller]
-    pub fn snapshot_options(&mut self, name: &str, options: &SnapshotOptions) {
+    pub fn snapshot_options(&mut self, name: impl Into<String>, options: &SnapshotOptions) {
         match self.try_snapshot_options(name, options) {
             Ok(_) => {}
             Err(err) => {
-                panic!("{}", err);
+                panic!("{err}");
             }
         }
     }
 
     /// Render an image using the setup [`crate::TestRenderer`] and compare it to the snapshot.
+    ///
+    /// This is like [`Self::snapshot_options`] but will use the options set by [`crate::HarnessBuilder::with_options`].
+    ///
     /// The snapshot will be saved under `tests/snapshots/{name}.png`.
     /// The new image from the last test run will be saved under `tests/snapshots/{name}.new.png`.
     /// If the new image didn't match the snapshot, a diff image will be saved under `tests/snapshots/{name}.diff.png`.
@@ -439,55 +654,57 @@ impl<State> Harness<'_, State> {
     /// Panics if the image does not match the snapshot, if there was an error reading or writing the
     /// snapshot, if the rendering fails or if no default renderer is available.
     #[track_caller]
-    pub fn snapshot(&mut self, name: &str) {
+    pub fn snapshot(&mut self, name: impl Into<String>) {
         match self.try_snapshot(name) {
             Ok(_) => {}
             Err(err) => {
-                panic!("{}", err);
+                panic!("{err}");
             }
         }
     }
-}
 
-// Deprecated wgpu_snapshot functions
-// TODO(lucasmerlin): Remove in 0.32
-#[allow(clippy::missing_errors_doc)]
-#[cfg(feature = "wgpu")]
-impl<State> Harness<'_, State> {
-    #[deprecated(
-        since = "0.31.0",
-        note = "Use `try_snapshot_options` instead. This function will be removed in 0.32"
-    )]
-    pub fn try_wgpu_snapshot_options(
-        &mut self,
-        name: &str,
-        options: &SnapshotOptions,
-    ) -> SnapshotResult {
-        self.try_snapshot_options(name, options)
-    }
+    /// Render a snapshot, save it to a temp file and open it in the default image viewer.
+    ///
+    /// This method is marked as deprecated to trigger errors in CI (so that it's not accidentally
+    /// committed).
+    #[deprecated = "Only for debugging, don't commit this."]
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn debug_open_snapshot(&mut self) {
+        let image = self
+            .render()
+            .map_err(|err| SnapshotError::RenderError { err })
+            .unwrap();
+        let temp_file = tempfile::Builder::new()
+            .disable_cleanup(true) // we keep the file so it's accessible even after the test ends
+            .prefix("kittest-snapshot")
+            .suffix(".png")
+            .tempfile()
+            .expect("Failed to create temp file");
 
-    #[deprecated(
-        since = "0.31.0",
-        note = "Use `try_snapshot` instead. This function will be removed in 0.32"
-    )]
-    pub fn try_wgpu_snapshot(&mut self, name: &str) -> SnapshotResult {
-        self.try_snapshot(name)
-    }
+        let path = temp_file.path();
 
-    #[deprecated(
-        since = "0.31.0",
-        note = "Use `snapshot_options` instead. This function will be removed in 0.32"
-    )]
-    pub fn wgpu_snapshot_options(&mut self, name: &str, options: &SnapshotOptions) {
-        self.snapshot_options(name, options);
-    }
+        image
+            .save(temp_file.path())
+            .map_err(|err| SnapshotError::WriteSnapshot {
+                err,
+                path: path.to_path_buf(),
+            })
+            .unwrap();
 
-    #[deprecated(
-        since = "0.31.0",
-        note = "Use `snapshot` instead. This function will be removed in 0.32"
-    )]
-    pub fn wgpu_snapshot(&mut self, name: &str) {
-        self.snapshot(name);
+        #[expect(clippy::print_stdout)]
+        {
+            println!("Wrote debug snapshot to: {}", path.display());
+        }
+        let result = open::that(path);
+        if let Err(err) = result {
+            #[expect(clippy::print_stderr)]
+            {
+                eprintln!(
+                    "Failed to open image {} in default image viewer: {err}",
+                    path.display()
+                );
+            }
+        }
     }
 }
 
@@ -552,13 +769,9 @@ impl SnapshotResults {
     }
 
     /// Convert this into a `Result<(), Self>`.
-    #[allow(clippy::missing_errors_doc)]
+    #[expect(clippy::missing_errors_doc)]
     pub fn into_result(self) -> Result<(), Self> {
-        if self.has_errors() {
-            Err(self)
-        } else {
-            Ok(())
-        }
+        if self.has_errors() { Err(self) } else { Ok(()) }
     }
 
     pub fn into_inner(mut self) -> Vec<SnapshotError> {
@@ -566,7 +779,7 @@ impl SnapshotResults {
     }
 
     /// Panics if there are any errors, displaying each.
-    #[allow(clippy::unused_self)]
+    #[expect(clippy::unused_self)]
     #[track_caller]
     pub fn unwrap(self) {
         // Panic is handled in drop
@@ -586,7 +799,7 @@ impl Drop for SnapshotResults {
         if std::thread::panicking() {
             return;
         }
-        #[allow(clippy::manual_assert)]
+        #[expect(clippy::manual_assert)]
         if self.has_errors() {
             panic!("{}", self);
         }
diff --git a/crates/egui_kittest/src/texture_to_image.rs b/crates/egui_kittest/src/texture_to_image.rs
index 8f7cb72a5..5172555fe 100644
--- a/crates/egui_kittest/src/texture_to_image.rs
+++ b/crates/egui_kittest/src/texture_to_image.rs
@@ -5,6 +5,8 @@ use std::iter;
 use std::mem::size_of;
 use std::sync::mpsc::channel;
 
+use crate::wgpu::WAIT_TIMEOUT;
+
 pub(crate) fn texture_to_image(device: &Device, queue: &Queue, texture: &Texture) -> RgbaImage {
     let buffer_dimensions =
         BufferDimensions::new(texture.width() as usize, texture.height() as usize);
@@ -47,7 +49,12 @@ pub(crate) fn texture_to_image(device: &Device, queue: &Queue, texture: &Texture
     buffer_slice.map_async(wgpu::MapMode::Read, move |v| drop(sender.send(v)));
 
     // Poll the device in a blocking manner so that our future resolves.
-    device.poll(wgpu::Maintain::WaitForSubmissionIndex(submission_index));
+    device
+        .poll(wgpu::PollType::Wait {
+            submission_index: Some(submission_index),
+            timeout: Some(WAIT_TIMEOUT),
+        })
+        .expect("Failed to poll device");
 
     receiver.recv().unwrap().unwrap();
     let buffer_slice = output_buffer.slice(..);
diff --git a/crates/egui_kittest/src/wgpu.rs b/crates/egui_kittest/src/wgpu.rs
index e7734c958..ae773095d 100644
--- a/crates/egui_kittest/src/wgpu.rs
+++ b/crates/egui_kittest/src/wgpu.rs
@@ -1,12 +1,20 @@
-use std::iter::once;
 use std::sync::Arc;
+use std::{iter::once, time::Duration};
 
 use egui::TexturesDelta;
-use egui_wgpu::{wgpu, RenderState, ScreenDescriptor, WgpuSetup};
+use egui_wgpu::{RenderState, ScreenDescriptor, WgpuSetup, wgpu};
 use image::RgbaImage;
 
 use crate::texture_to_image::texture_to_image;
 
+/// Timeout for waiting on the GPU to finish rendering.
+///
+/// Windows will reset native drivers after 2 seconds of being stuck (known was TDR - timeout detection & recovery).
+/// However, software rasterizers like lavapipe may not do that and take longer if there's a lot of work in flight.
+/// In the end, what we really want to protect here against is undetected errors that lead to device loss
+/// and therefore infinite waits it happens occasionally on MacOS/Metal as of writing.
+pub(crate) const WAIT_TIMEOUT: Duration = Duration::from_secs(10);
+
 /// Default wgpu setup used for the wgpu renderer.
 pub fn default_wgpu_setup() -> egui_wgpu::WgpuSetup {
     let mut setup = egui_wgpu::WgpuSetupCreateNew::default();
@@ -28,7 +36,7 @@ pub fn default_wgpu_setup() -> egui_wgpu::WgpuSetup {
             wgpu::Backend::Dx12 => 2,
             wgpu::Backend::Gl => 4,
             wgpu::Backend::BrowserWebGpu => 6,
-            wgpu::Backend::Empty => 7,
+            wgpu::Backend::Noop => 7,
         });
 
         // Prefer CPU adapters, otherwise if we can't, prefer discrete GPU over integrated GPU.
@@ -59,9 +67,7 @@ pub fn create_render_state(setup: WgpuSetup) -> egui_wgpu::RenderState {
         },
         &instance,
         None,
-        None,
-        1,
-        false,
+        egui_wgpu::RendererOptions::PREDICTABLE,
     ))
     .expect("Failed to create render state")
 }
@@ -143,7 +149,7 @@ impl crate::TestRenderer for WgpuTestRenderer {
                     label: Some("Egui Command Encoder"),
                 });
 
-        let size = ctx.screen_rect().size() * ctx.pixels_per_point();
+        let size = ctx.content_rect().size() * ctx.pixels_per_point();
         let screen = ScreenDescriptor {
             pixels_per_point: ctx.pixels_per_point(),
             size_in_pixels: [size.x.round() as u32, size.y.round() as u32],
@@ -190,6 +196,7 @@ impl crate::TestRenderer for WgpuTestRenderer {
                             load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
                             store: wgpu::StoreOp::Store,
                         },
+                        depth_slice: None,
                     })],
                     ..Default::default()
                 })
@@ -202,7 +209,13 @@ impl crate::TestRenderer for WgpuTestRenderer {
             .queue
             .submit(user_buffers.into_iter().chain(once(encoder.finish())));
 
-        self.render_state.device.poll(wgpu::Maintain::Wait);
+        self.render_state
+            .device
+            .poll(wgpu::PollType::Wait {
+                submission_index: None,
+                timeout: Some(WAIT_TIMEOUT),
+            })
+            .map_err(|err| format!("PollError: {err}"))?;
 
         Ok(texture_to_image(
             &self.render_state.device,
diff --git a/crates/egui_kittest/tests/accesskit.rs b/crates/egui_kittest/tests/accesskit.rs
index 02afddefc..08a96bd7a 100644
--- a/crates/egui_kittest/tests/accesskit.rs
+++ b/crates/egui_kittest/tests/accesskit.rs
@@ -1,8 +1,8 @@
 //! Tests the accesskit accessibility output of egui.
 
 use egui::{
-    accesskit::{NodeId, Role, TreeUpdate},
     CentralPanel, Context, RawInput, Window,
+    accesskit::{NodeId, Role, TreeUpdate},
 };
 
 /// Baseline test that asserts there are no spurious nodes in the
@@ -18,9 +18,20 @@ fn empty_ui_should_return_tree_with_only_root_window() {
 
     assert_eq!(
         output.nodes.len(),
-        1,
-        "Empty ui should produce only the root window."
+        4,
+        "Expected the root node and two Uis and a Frame for the panel"
     );
+
+    assert_eq!(
+        output
+            .nodes
+            .iter()
+            .filter(|(_, n)| n.role() == Role::GenericContainer)
+            .count(),
+        3,
+        "Expected two Uis and one Frame as GenericContainer nodes.",
+    );
+
     let (id, root) = &output.nodes[0];
 
     assert_eq!(*id, output.tree.unwrap().root);
@@ -35,12 +46,6 @@ fn button_node() {
         CentralPanel::default().show(ctx, |ui| ui.button(button_text));
     });
 
-    assert_eq!(
-        output.nodes.len(),
-        2,
-        "Expected only the root node and the button."
-    );
-
     let (_, button) = output
         .nodes
         .iter()
@@ -61,12 +66,6 @@ fn disabled_button_node() {
         });
     });
 
-    assert_eq!(
-        output.nodes.len(),
-        2,
-        "Expected only the root node and the button."
-    );
-
     let (_, button) = output
         .nodes
         .iter()
@@ -86,12 +85,6 @@ fn toggle_button_node() {
         CentralPanel::default().show(ctx, |ui| ui.toggle_value(&mut selected, button_text));
     });
 
-    assert_eq!(
-        output.nodes.len(),
-        2,
-        "Expected only the root node and the button."
-    );
-
     let (_, toggle) = output
         .nodes
         .iter()
@@ -114,12 +107,6 @@ fn multiple_disabled_widgets() {
         });
     });
 
-    assert_eq!(
-        output.nodes.len(),
-        4,
-        "Expected the root node and all the child widgets."
-    );
-
     assert_eq!(
         output
             .nodes
@@ -194,15 +181,25 @@ fn assert_window_exists(tree: &TreeUpdate, title: &str, parent: NodeId) -> NodeI
 }
 
 #[track_caller]
-fn assert_parent_child(tree: &TreeUpdate, parent: NodeId, child: NodeId) {
+fn assert_parent_child(tree: &TreeUpdate, parent_id: NodeId, child: NodeId) {
+    assert!(
+        has_child_recursively(tree, parent_id, child),
+        "Node is not a child of the given parent."
+    );
+}
+
+fn has_child_recursively(tree: &TreeUpdate, parent: NodeId, child: NodeId) -> bool {
     let (_, parent) = tree
         .nodes
         .iter()
         .find(|(id, _)| id == &parent)
         .expect("Parent does not exist.");
 
-    assert!(
-        parent.children().contains(&child),
-        "Node is not a child of the given parent."
-    );
+    for &c in parent.children() {
+        if c == child || has_child_recursively(tree, c, child) {
+            return true;
+        }
+    }
+
+    false
 }
diff --git a/crates/egui_kittest/tests/menu.rs b/crates/egui_kittest/tests/menu.rs
new file mode 100644
index 000000000..a76001e46
--- /dev/null
+++ b/crates/egui_kittest/tests/menu.rs
@@ -0,0 +1,186 @@
+use egui::containers::menu::{MenuBar, MenuConfig, SubMenuButton};
+use egui::{PopupCloseBehavior, Ui, include_image};
+use egui_kittest::{Harness, SnapshotResults};
+use kittest::Queryable as _;
+
+struct TestMenu {
+    config: MenuConfig,
+    checked: bool,
+}
+
+impl TestMenu {
+    fn new(config: MenuConfig) -> Self {
+        Self {
+            config,
+            checked: false,
+        }
+    }
+
+    fn ui(&mut self, ui: &mut Ui) {
+        ui.vertical(|ui| {
+            MenuBar::new().config(self.config.clone()).ui(ui, |ui| {
+                egui::Sides::new().show(
+                    ui,
+                    |ui| {
+                        ui.menu_button("Menu A", |ui| {
+                            _ = ui.button("Button in Menu A");
+                            ui.menu_button("Submenu A", |ui| {
+                                for i in 0..4 {
+                                    _ = ui.button(format!("Button {i} in Submenu A"));
+                                }
+                            });
+                            ui.menu_image_text_button(
+                                include_image!("../../eframe/data/icon.png"),
+                                "Submenu B with icon",
+                                |ui| {
+                                    _ = ui.button("Button in Submenu B");
+                                },
+                            );
+                            SubMenuButton::new("Submenu C (CloseOnClickOutside)")
+                                .config(
+                                    MenuConfig::new()
+                                        .close_behavior(PopupCloseBehavior::CloseOnClickOutside),
+                                )
+                                .ui(ui, |ui| {
+                                    _ = ui.button("Button in Submenu C");
+                                    ui.checkbox(&mut self.checked, "Checkbox in Submenu C");
+                                    ui.menu_button("Submenu D", |ui| {
+                                        if ui
+                                            .button("Button in Submenu D (close on click)")
+                                            .clicked()
+                                        {
+                                            ui.close();
+                                        }
+                                    });
+                                });
+                        });
+                        ui.menu_image_text_button(
+                            include_image!("../../eframe/data/icon.png"),
+                            "Menu B with icon",
+                            |ui| {
+                                _ = ui.button("Button in Menu B");
+                            },
+                        );
+                        _ = ui.button("Menu Button");
+                        ui.menu_button("Menu C", |ui| {
+                            _ = ui.button("Button in Menu C");
+                        });
+                    },
+                    |ui| {
+                        ui.label("Some other label");
+                    },
+                );
+            });
+        });
+    }
+
+    fn into_harness(self) -> Harness<'static, Self> {
+        Harness::builder()
+            .with_size(egui::Vec2::new(500.0, 300.0))
+            .build_ui_state(
+                |ui, menu| {
+                    egui_extras::install_image_loaders(ui.ctx());
+                    menu.ui(ui);
+                },
+                self,
+            )
+    }
+}
+
+#[test]
+fn menu_close_on_click_outside() {
+    // We're intentionally setting CloseOnClick here so we can test if a submenu can override the
+    // close behavior. (Note how Submenu C has CloseOnClickOutside set)
+    let mut harness =
+        TestMenu::new(MenuConfig::new().close_behavior(PopupCloseBehavior::CloseOnClick))
+            .into_harness();
+
+    harness.get_by_label("Menu A").click();
+    harness.run();
+
+    harness
+        .get_by_label_contains("Submenu C (CloseOnClickOutside)")
+        .hover();
+    harness.run();
+
+    // We should be able to check the checkbox without closing the menu
+    // Click a couple of times, just in case
+    for expect_checked in [true, false, true, false] {
+        harness.get_by_label("Checkbox in Submenu C").click();
+        harness.run();
+        assert_eq!(expect_checked, harness.state().checked);
+    }
+
+    // Hovering outside should not close the menu
+    harness.get_by_label("Some other label").hover();
+    harness.run();
+    assert!(harness.query_by_label("Checkbox in Submenu C").is_some());
+
+    // Clicking outside should close the menu
+    harness.get_by_label("Some other label").click();
+    harness.run();
+    assert!(harness.query_by_label("Checkbox in Submenu C").is_none());
+}
+
+#[test]
+fn menu_close_on_click() {
+    let mut harness =
+        TestMenu::new(MenuConfig::new().close_behavior(PopupCloseBehavior::CloseOnClick))
+            .into_harness();
+
+    harness.get_by_label("Menu A").click();
+    harness.run();
+
+    harness.get_by_label_contains("Submenu B with icon").hover();
+    harness.run();
+
+    // Clicking the button should close the menu (even if ui.close() is not called by the button)
+    harness.get_by_label("Button in Submenu B").click();
+    harness.run();
+    assert!(harness.query_by_label("Button in Submenu B").is_none());
+}
+
+#[test]
+fn clicking_submenu_button_should_never_close_menu() {
+    // We test for this since otherwise the menu wouldn't work on touch devices
+    // The other tests use .hover to open submenus, but this test explicitly uses .click
+    let mut harness =
+        TestMenu::new(MenuConfig::new().close_behavior(PopupCloseBehavior::CloseOnClick))
+            .into_harness();
+
+    harness.get_by_label("Menu A").click();
+    harness.run();
+
+    // Clicking the submenu button should not close the menu
+    harness.get_by_label_contains("Submenu B with icon").click();
+    harness.run();
+
+    harness.get_by_label("Button in Submenu B").click();
+    harness.run();
+    assert!(harness.query_by_label("Button in Submenu B").is_none());
+}
+
+#[test]
+fn menu_snapshots() {
+    let mut harness = TestMenu::new(MenuConfig::new()).into_harness();
+
+    let mut results = SnapshotResults::new();
+
+    harness.get_by_label("Menu A").hover();
+    harness.run();
+    results.add(harness.try_snapshot("menu/closed_hovered"));
+
+    harness.get_by_label("Menu A").click();
+    harness.run();
+    results.add(harness.try_snapshot("menu/opened"));
+
+    harness
+        .get_by_label_contains("Submenu C (CloseOnClickOutside)")
+        .hover();
+    harness.run();
+    results.add(harness.try_snapshot("menu/submenu"));
+
+    harness.get_by_label_contains("Submenu D").hover();
+    harness.run();
+    results.add(harness.try_snapshot("menu/subsubmenu"));
+}
diff --git a/crates/egui_kittest/tests/popup.rs b/crates/egui_kittest/tests/popup.rs
new file mode 100644
index 000000000..a8d3bcc9d
--- /dev/null
+++ b/crates/egui_kittest/tests/popup.rs
@@ -0,0 +1,31 @@
+use kittest::Queryable as _;
+
+#[test]
+fn test_interactive_tooltip() {
+    struct State {
+        link_clicked: bool,
+    }
+
+    let mut harness = egui_kittest::Harness::new_ui_state(
+        |ui, state| {
+            ui.label("I have a tooltip").on_hover_ui(|ui| {
+                if ui.link("link").clicked() {
+                    state.link_clicked = true;
+                }
+            });
+        },
+        State {
+            link_clicked: false,
+        },
+    );
+
+    harness.get_by_label_contains("tooltip").hover();
+    harness.run();
+    harness.get_by_label("link").hover();
+    harness.run();
+    harness.get_by_label("link").click();
+
+    harness.run();
+
+    assert!(harness.state().link_clicked);
+}
diff --git a/crates/egui_kittest/tests/regression_tests.rs b/crates/egui_kittest/tests/regression_tests.rs
index e7186dcac..9b1a9a096 100644
--- a/crates/egui_kittest/tests/regression_tests.rs
+++ b/crates/egui_kittest/tests/regression_tests.rs
@@ -1,6 +1,8 @@
-use egui::accesskit::Role;
-use egui::{Button, ComboBox, Image, Vec2, Widget};
-use egui_kittest::{kittest::Queryable, Harness, SnapshotResults};
+use egui::accesskit::{self, Role};
+use egui::{Button, ComboBox, Image, Modifiers, Popup, Vec2, Widget as _};
+#[cfg(all(feature = "wgpu", feature = "snapshot"))]
+use egui_kittest::SnapshotResults;
+use egui_kittest::{Harness, kittest::Queryable as _};
 
 #[test]
 pub fn focus_should_skip_over_disabled_buttons() {
@@ -10,25 +12,50 @@ pub fn focus_should_skip_over_disabled_buttons() {
         ui.add(Button::new("Button 3"));
     });
 
-    harness.press_key(egui::Key::Tab);
+    harness.key_press(egui::Key::Tab);
     harness.run();
 
     let button_1 = harness.get_by_label("Button 1");
     assert!(button_1.is_focused());
 
-    harness.press_key(egui::Key::Tab);
+    harness.key_press(egui::Key::Tab);
     harness.run();
 
     let button_3 = harness.get_by_label("Button 3");
     assert!(button_3.is_focused());
 
-    harness.press_key(egui::Key::Tab);
+    harness.key_press(egui::Key::Tab);
     harness.run();
 
     let button_1 = harness.get_by_label("Button 1");
     assert!(button_1.is_focused());
 }
 
+#[test]
+pub fn focus_should_skip_over_disabled_drag_values() {
+    let mut value_1: u16 = 1;
+    let mut value_2: u16 = 2;
+    let mut value_3: u16 = 3;
+
+    let mut harness = Harness::new_ui(|ui| {
+        ui.add(egui::DragValue::new(&mut value_1));
+        ui.add_enabled(false, egui::DragValue::new(&mut value_2));
+        ui.add(egui::DragValue::new(&mut value_3));
+    });
+
+    harness.key_press(egui::Key::Tab);
+    harness.run();
+
+    let drag_value_1 = harness.get_by(|node| node.numeric_value() == Some(1.0));
+    assert!(drag_value_1.is_focused());
+
+    harness.key_press(egui::Key::Tab);
+    harness.run();
+
+    let drag_value_3 = harness.get_by(|node| node.numeric_value() == Some(3.0));
+    assert!(drag_value_3.is_focused());
+}
+
 #[test]
 fn image_failed() {
     let mut harness = Harness::new_ui(|ui| {
@@ -64,6 +91,7 @@ fn test_combobox() {
 
     harness.run();
 
+    #[cfg(all(feature = "wgpu", feature = "snapshot"))]
     let mut results = SnapshotResults::new();
 
     #[cfg(all(feature = "wgpu", feature = "snapshot"))]
@@ -78,8 +106,7 @@ fn test_combobox() {
     results.add(harness.try_snapshot("combobox_opened"));
 
     let item_2 = harness.get_by_role_and_label(Role::Button, "Item 2");
-    // Node::click doesn't close the popup, so we use simulate_click
-    item_2.simulate_click();
+    item_2.click();
 
     harness.run();
 
@@ -88,3 +115,150 @@ fn test_combobox() {
     // Popup should be closed now
     assert!(harness.query_by_label("Item 2").is_none());
 }
+
+/// `https://github.com/emilk/egui/issues/7065`
+#[test]
+pub fn slider_should_move_with_fixed_decimals() {
+    let mut value: f32 = 1.0;
+
+    let mut harness = Harness::new_ui(|ui| {
+        // Movement on arrow-key is relative to slider width; make the slider wide so the movement becomes small.
+        ui.spacing_mut().slider_width = 2000.0;
+        ui.add(egui::Slider::new(&mut value, 0.1..=10.0).fixed_decimals(2));
+    });
+
+    harness.key_press(egui::Key::Tab);
+    harness.run();
+
+    let actual_slider = harness.get_by_role(accesskit::Role::SpinButton);
+    assert_eq!(actual_slider.value(), Some("1.00".to_owned()));
+
+    harness.key_press(egui::Key::ArrowRight);
+    harness.run();
+
+    let actual_slider = harness.get_by_role(accesskit::Role::SpinButton);
+    assert_eq!(actual_slider.value(), Some("1.01".to_owned()));
+
+    harness.key_press(egui::Key::ArrowRight);
+    harness.run();
+
+    let actual_slider = harness.get_by_role(accesskit::Role::SpinButton);
+    assert_eq!(actual_slider.value(), Some("1.02".to_owned()));
+
+    harness.key_press(egui::Key::ArrowLeft);
+    harness.run();
+
+    let actual_slider = harness.get_by_role(accesskit::Role::SpinButton);
+    assert_eq!(actual_slider.value(), Some("1.01".to_owned()));
+
+    harness.key_press(egui::Key::ArrowLeft);
+    harness.run();
+
+    let actual_slider = harness.get_by_role(accesskit::Role::SpinButton);
+    assert_eq!(actual_slider.value(), Some("1.00".to_owned()));
+}
+
+#[test]
+pub fn override_text_color_affects_interactive_widgets() {
+    use egui::{Color32, RichText};
+
+    let mut harness = Harness::new_ui(|ui| {
+        _ = ui.button("normal");
+        _ = ui.checkbox(&mut true, "normal");
+        _ = ui.radio(true, "normal");
+        ui.visuals_mut().widgets.inactive.fg_stroke.color = Color32::RED;
+        _ = ui.button("red");
+        _ = ui.checkbox(&mut true, "red");
+        _ = ui.radio(true, "red");
+        // override_text_color takes precedence over `WidgetVisuals`, as it docstring claims
+        ui.visuals_mut().override_text_color = Some(Color32::GREEN);
+        _ = ui.button("green");
+        _ = ui.checkbox(&mut true, "green");
+        _ = ui.radio(true, "green");
+        // Setting the color explicitly with `RichText` overrides style
+        _ = ui.button(RichText::new("blue").color(Color32::BLUE));
+        _ = ui.checkbox(&mut true, RichText::new("blue").color(Color32::BLUE));
+        _ = ui.radio(true, RichText::new("blue").color(Color32::BLUE));
+    });
+
+    #[cfg(all(feature = "wgpu", feature = "snapshot"))]
+    let mut results = SnapshotResults::new();
+
+    #[cfg(all(feature = "wgpu", feature = "snapshot"))]
+    results.add(harness.try_snapshot("override_text_color_interactive"));
+}
+
+/// <https://github.com/rerun-io/rerun/issues/11301>
+#[test]
+pub fn menus_should_close_even_if_submenu_disappears() {
+    const OTHER_BUTTON: &str = "Other button";
+    const MENU_BUTTON: &str = "Menu";
+    const SUB_MENU_BUTTON: &str = "Always here";
+    const TOGGLABLE_SUB_MENU_BUTTON: &str = "Maybe here";
+    const INSIDE_SUB_MENU_BUTTON: &str = "Inside submenu";
+
+    for frame_delay in (0..3).rev() {
+        let mut harness = Harness::builder().build_ui_state(
+            |ui, state| {
+                let _ = ui.button(OTHER_BUTTON).clicked();
+                let response = ui.button(MENU_BUTTON);
+
+                Popup::menu(&response).show(|ui| {
+                    let _ = ui.button(SUB_MENU_BUTTON);
+                    if *state {
+                        ui.menu_button(TOGGLABLE_SUB_MENU_BUTTON, |ui| {
+                            let _ = ui.button(INSIDE_SUB_MENU_BUTTON);
+                        });
+                    }
+                });
+            },
+            true,
+        );
+
+        // Open the main menu
+        harness.get_by_label(MENU_BUTTON).click();
+        harness.run();
+
+        // Open the sub menu
+        harness
+            .get_by_label_contains(TOGGLABLE_SUB_MENU_BUTTON)
+            .hover();
+        harness.run();
+
+        // Have we opened the submenu successfully?
+        harness.get_by_label(INSIDE_SUB_MENU_BUTTON).hover();
+        harness.run();
+
+        // We click manually, since we want to precisely time that the sub menu disappears when the
+        // button is released
+        let center = harness.get_by_label(OTHER_BUTTON).rect().center();
+        harness.input_mut().events.push(egui::Event::PointerButton {
+            pos: center,
+            button: egui::PointerButton::Primary,
+            pressed: true,
+            modifiers: Modifiers::default(),
+        });
+        harness.step();
+
+        // Yank the sub menu from under the pointer
+        *harness.state_mut() = false;
+
+        // See if we handle it with or without a frame delay
+        harness.run_steps(frame_delay);
+
+        // Actually close the menu by clicking somewhere outside
+        harness.input_mut().events.push(egui::Event::PointerButton {
+            pos: center,
+            button: egui::PointerButton::Primary,
+            pressed: false,
+            modifiers: Modifiers::default(),
+        });
+
+        harness.run();
+
+        assert!(
+            harness.query_by_label_contains(SUB_MENU_BUTTON).is_none(),
+            "Menu failed to close. frame_delay = {frame_delay}"
+        );
+    }
+}
diff --git a/crates/egui_kittest/tests/snapshots/combobox_closed.png b/crates/egui_kittest/tests/snapshots/combobox_closed.png
index 18a9d0bc9..bb574d356 100644
--- a/crates/egui_kittest/tests/snapshots/combobox_closed.png
+++ b/crates/egui_kittest/tests/snapshots/combobox_closed.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:202091634d4483949cb1c5c4c5ec02faa23f4d19e7e833aba135887b77e3188d
-size 4485
+oid sha256:f297609dd69fd479377eaea7cd304b717e0523a650dbf76e19c6d1f1c5af1343
+size 4518
diff --git a/crates/egui_kittest/tests/snapshots/combobox_opened.png b/crates/egui_kittest/tests/snapshots/combobox_opened.png
index ef84c8a77..aaa7198ce 100644
--- a/crates/egui_kittest/tests/snapshots/combobox_opened.png
+++ b/crates/egui_kittest/tests/snapshots/combobox_opened.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f65efbf60e190d83d187ec51f3f7811eb55135ef4feb9586e931e8498bc05d64
-size 7430
+oid sha256:8f70ef032c241cd63675a246de07886c5c822e6fe21525b3a6d3fee106a589c9
+size 7501
diff --git a/crates/egui_kittest/tests/snapshots/image_snapshots.png b/crates/egui_kittest/tests/snapshots/image_snapshots.png
index c1b7d6cef..5036d662c 100644
--- a/crates/egui_kittest/tests/snapshots/image_snapshots.png
+++ b/crates/egui_kittest/tests/snapshots/image_snapshots.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:31faeb4e5f488b8bcee5e090accd326d7e43b264e81768ae7c1907e3b6d0f739
-size 2121
+oid sha256:de4a197f82befde31b6966f902567c35cef96c7d541fd65b4207c693ab12bace
+size 2036
diff --git a/crates/egui_kittest/tests/snapshots/menu/closed_hovered.png b/crates/egui_kittest/tests/snapshots/menu/closed_hovered.png
new file mode 100644
index 000000000..d2969adee
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/menu/closed_hovered.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd6e159a462dde10240c4ca51da5ca5badfb7fc170bad97a59106babb72f8ae3
+size 10795
diff --git a/crates/egui_kittest/tests/snapshots/menu/opened.png b/crates/egui_kittest/tests/snapshots/menu/opened.png
new file mode 100644
index 000000000..30f26b446
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/menu/opened.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f2a5873350f85457d599c1fd165ac756ed69758e7647e160c64f44d2f35c804
+size 21812
diff --git a/crates/egui_kittest/tests/snapshots/menu/submenu.png b/crates/egui_kittest/tests/snapshots/menu/submenu.png
new file mode 100644
index 000000000..96ffaf97c
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/menu/submenu.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:facc05c499745594ac286f15645e40447633a176058337cad9edcb850ad578c7
+size 29379
diff --git a/crates/egui_kittest/tests/snapshots/menu/subsubmenu.png b/crates/egui_kittest/tests/snapshots/menu/subsubmenu.png
new file mode 100644
index 000000000..d1d0b4cd3
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/menu/subsubmenu.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f23ff8c6782befdbe7bd5f076dcdda15c38555f8e505282369bf52e43938c1b
+size 34194
diff --git a/crates/egui_kittest/tests/snapshots/override_text_color_interactive.png b/crates/egui_kittest/tests/snapshots/override_text_color_interactive.png
new file mode 100644
index 000000000..6e92f9f03
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/override_text_color_interactive.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2fa5cb5b96232d729f89be8cc92263715fe7197e72343b71e57e53a359afe181
+size 19881
diff --git a/crates/egui_kittest/tests/snapshots/readme_example.png b/crates/egui_kittest/tests/snapshots/readme_example.png
index ef0774162..2c8565718 100644
--- a/crates/egui_kittest/tests/snapshots/readme_example.png
+++ b/crates/egui_kittest/tests/snapshots/readme_example.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:31bd906040fcc356c19dc36036fbfd2a28dfcef54c7a073f584f4a9abddbdb4c
-size 1699
+oid sha256:bb8d702361987803995c0f557ce94552a87b97dcd25bed5ee39af4c0e6090700
+size 1904
diff --git a/crates/egui_kittest/tests/snapshots/should_wait_for_images.png b/crates/egui_kittest/tests/snapshots/should_wait_for_images.png
new file mode 100644
index 000000000..7e33877fc
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/should_wait_for_images.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f038c7fdf31f35107ec6e29edc0895049160ccbe98d1577c16ae082605b58d52
+size 2207
diff --git a/crates/egui_kittest/tests/snapshots/test_masking.png b/crates/egui_kittest/tests/snapshots/test_masking.png
new file mode 100644
index 000000000..a5fb50908
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/test_masking.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d94d4c3300d406fd1d93ddd90a9a46f99eac81a98a84f4d97a20fe4ef492e5d
+size 5674
diff --git a/crates/egui_kittest/tests/snapshots/test_scroll_initial.png b/crates/egui_kittest/tests/snapshots/test_scroll_initial.png
new file mode 100644
index 000000000..586dc00b7
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/test_scroll_initial.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:460cb2e9c91d139334c797829fd82fa77d593e9e58531e57a6b649c7e8fad228
+size 7405
diff --git a/crates/egui_kittest/tests/snapshots/test_scroll_scrolled.png b/crates/egui_kittest/tests/snapshots/test_scroll_scrolled.png
new file mode 100644
index 000000000..64feb6323
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/test_scroll_scrolled.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:996985b155bd579cc4769d8cde5aa7e87c20ed909176da6b52dddeeb78a1cfba
+size 8290
diff --git a/crates/egui_kittest/tests/snapshots/test_shrink.png b/crates/egui_kittest/tests/snapshots/test_shrink.png
index a6e6b1f3a..c25ae0367 100644
--- a/crates/egui_kittest/tests/snapshots/test_shrink.png
+++ b/crates/egui_kittest/tests/snapshots/test_shrink.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b5aa7db1bb52481607069ee4a81209ece81b0c70801969b33bc2d1b2f7087de7
-size 2911
+oid sha256:025942c144891b8862bf931385824e0484e60f4e7766f5d4401511c72ff20756
+size 2975
diff --git a/crates/egui_kittest/tests/snapshots/test_tooltip_hidden.png b/crates/egui_kittest/tests/snapshots/test_tooltip_hidden.png
new file mode 100644
index 000000000..c25ae0367
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/test_tooltip_hidden.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:025942c144891b8862bf931385824e0484e60f4e7766f5d4401511c72ff20756
+size 2975
diff --git a/crates/egui_kittest/tests/snapshots/test_tooltip_shown.png b/crates/egui_kittest/tests/snapshots/test_tooltip_shown.png
new file mode 100644
index 000000000..8ff6bba67
--- /dev/null
+++ b/crates/egui_kittest/tests/snapshots/test_tooltip_shown.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c267530452adb4f1ed1440df476d576ef4c2d96e6c58068bb57fed4615f5e113
+size 4453
diff --git a/crates/egui_kittest/tests/tests.rs b/crates/egui_kittest/tests/tests.rs
index 29b4c7b11..81f861451 100644
--- a/crates/egui_kittest/tests/tests.rs
+++ b/crates/egui_kittest/tests/tests.rs
@@ -1,4 +1,6 @@
+use egui::{Modifiers, ScrollArea, Vec2, include_image};
 use egui_kittest::{Harness, SnapshotResults};
+use kittest::Queryable as _;
 
 #[test]
 fn test_shrink() {
@@ -10,8 +12,205 @@ fn test_shrink() {
 
     harness.fit_contents();
 
-    let mut results = SnapshotResults::new();
+    #[cfg(all(feature = "snapshot", feature = "wgpu"))]
+    harness.snapshot("test_shrink");
+}
+
+#[test]
+fn test_tooltip() {
+    let mut harness = Harness::new_ui(|ui| {
+        ui.label("Hello, world!");
+        ui.separator();
+        ui.label("This is a test")
+            .on_hover_text("This\nis\na\nvery\ntall\ntooltip!");
+    });
+
+    harness.fit_contents();
 
     #[cfg(all(feature = "snapshot", feature = "wgpu"))]
-    results.add(harness.try_snapshot("test_shrink"));
+    harness.snapshot("test_tooltip_hidden");
+
+    harness.get_by_label("This is a test").hover();
+    harness.run_ok();
+    harness.fit_contents();
+
+    #[cfg(all(feature = "snapshot", feature = "wgpu"))]
+    harness.snapshot("test_tooltip_shown");
+}
+
+#[test]
+fn test_modifiers() {
+    #[derive(Default)]
+    struct State {
+        cmd_clicked: bool,
+        cmd_z_pressed: bool,
+        cmd_y_pressed: bool,
+    }
+    let mut harness = Harness::new_ui_state(
+        |ui, state| {
+            if ui.button("Click me").clicked() && ui.input(|i| i.modifiers.command) {
+                state.cmd_clicked = true;
+            }
+            if ui.input(|i| i.modifiers.command && i.key_pressed(egui::Key::Z)) {
+                state.cmd_z_pressed = true;
+            }
+            if ui.input(|i| i.modifiers.command && i.key_pressed(egui::Key::Y)) {
+                state.cmd_y_pressed = true;
+            }
+        },
+        State::default(),
+    );
+
+    harness
+        .get_by_label("Click me")
+        .click_modifiers(Modifiers::COMMAND);
+    harness.run();
+
+    harness.key_press_modifiers(Modifiers::COMMAND, egui::Key::Z);
+    harness.run();
+
+    harness.key_combination_modifiers(Modifiers::COMMAND, &[egui::Key::Y]);
+    harness.run();
+
+    let state = harness.state();
+    assert!(state.cmd_clicked, "The button wasn't command-clicked");
+    assert!(state.cmd_z_pressed, "Cmd+Z wasn't pressed");
+    assert!(state.cmd_y_pressed, "Cmd+Y wasn't pressed");
+}
+
+#[test]
+fn should_wait_for_images() {
+    let mut harness = Harness::builder()
+        .with_size(Vec2::new(60.0, 120.0))
+        .build_ui(|ui| {
+            egui_extras::install_image_loaders(ui.ctx());
+            let size = Vec2::splat(30.0);
+            ui.label("Url:");
+            ui.add_sized(
+                size,
+                egui::Image::new(
+                    "https://raw.githubusercontent.com\
+                    /emilk/egui/refs/heads/main/crates/eframe/data/icon.png",
+                ),
+            );
+
+            ui.label("Include:");
+            ui.add_sized(
+                size,
+                egui::Image::new(include_image!("../../eframe/data/icon.png")),
+            );
+        });
+
+    harness.snapshot("should_wait_for_images");
+}
+
+fn test_scroll_harness() -> Harness<'static, bool> {
+    Harness::builder()
+        .with_size(Vec2::new(100.0, 200.0))
+        .build_ui_state(
+            |ui, state| {
+                ScrollArea::vertical().show(ui, |ui| {
+                    for i in 0..20 {
+                        ui.label(format!("Item {i}"));
+                    }
+                    if ui.button("Hidden Button").clicked() {
+                        *state = true;
+                    }
+                });
+            },
+            false,
+        )
+}
+
+#[test]
+fn test_scroll_to_me() {
+    let mut harness = test_scroll_harness();
+    let mut results = SnapshotResults::new();
+
+    results.add(harness.try_snapshot("test_scroll_initial"));
+
+    harness.get_by_label("Hidden Button").scroll_to_me();
+
+    harness.run();
+    results.add(harness.try_snapshot("test_scroll_scrolled"));
+
+    harness.get_by_label("Hidden Button").click();
+    harness.run();
+
+    assert!(
+        harness.state(),
+        "The button was not clicked after scrolling."
+    );
+}
+
+#[test]
+fn test_scroll_down() {
+    let mut harness = test_scroll_harness();
+
+    let button = harness.get_by_label("Hidden Button");
+    button.scroll_down();
+    button.scroll_down();
+    harness.run();
+
+    harness.get_by_label("Hidden Button").click();
+    harness.run();
+
+    assert!(
+        harness.state(),
+        "The button was not clicked after scrolling down. (Probably not scrolled enough / at all)"
+    );
+}
+
+#[test]
+fn test_masking() {
+    let mut harness = Harness::new_ui(|ui| {
+        let timestamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_millis();
+
+        ui.label("I should not be masked.");
+        ui.label(format!("Timestamp: {timestamp}"));
+        ui.label("I should also not be masked.");
+    });
+
+    harness.fit_contents();
+
+    let to_be_masked = harness.get_by_label_contains("Timestamp: ");
+    harness.mask(to_be_masked.rect());
+
+    harness.snapshot("test_masking");
+}
+
+#[test]
+fn test_remove_cursor() {
+    let hovered = false;
+    let mut harness = Harness::new_ui_state(
+        |ui, state| {
+            let response = ui.button("Click me");
+            *state = response.hovered();
+        },
+        hovered,
+    );
+
+    harness.fit_contents();
+
+    harness.get_by_label("Click me").click();
+    harness.run();
+
+    assert!(harness.state(), "The button should be hovered");
+    let hovered_button_snapshot = harness.render().expect("Failed to render");
+
+    harness.remove_cursor();
+    harness.run();
+    assert!(
+        !harness.state(),
+        "The button should not be hovered after removing cursor"
+    );
+
+    let non_hovered_button_snapshot = harness.render().expect("Failed to render");
+    assert_ne!(
+        hovered_button_snapshot, non_hovered_button_snapshot,
+        "The button appearance should change"
+    );
 }
diff --git a/crates/egui_web/README.md b/crates/egui_web/README.md
index feb862564..8e2610f51 100644
--- a/crates/egui_web/README.md
+++ b/crates/egui_web/README.md
@@ -1 +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).
+`egui_web` used to be a standalone crate, but has now been moved into [`eframe`](https://github.com/emilk/egui/tree/main/crates/eframe).
diff --git a/crates/emath/CHANGELOG.md b/crates/emath/CHANGELOG.md
new file mode 100644
index 000000000..334af345f
--- /dev/null
+++ b/crates/emath/CHANGELOG.md
@@ -0,0 +1,18 @@
+# Changelog for emath
+All notable changes to the `emath` crate will be noted in this file.
+
+
+This file is updated upon each release.
+Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
+
+
+## 0.33.2 - 2025-11-13
+* Fix edge cases in "smart aiming" in sliders [#7680](https://github.com/emilk/egui/pull/7680) by [@emilk](https://github.com/emilk)
+
+
+## 0.33.0 - 2025-10-09
+* Add `emath::fast_midpoint` [#7435](https://github.com/emilk/egui/pull/7435) by [@emilk](https://github.com/emilk)
+* Generate changelogs for emath [#7513](https://github.com/emilk/egui/pull/7513) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Improve `OrderedFloat` hash performance [#7512](https://github.com/emilk/egui/pull/7512) by [@valadaptive](https://github.com/valadaptive)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+
diff --git a/crates/emath/Cargo.toml b/crates/emath/Cargo.toml
index 6df0da9af..416d32750 100644
--- a/crates/emath/Cargo.toml
+++ b/crates/emath/Cargo.toml
@@ -5,10 +5,10 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Minimal 2D math library for GUI work"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/emath"
+homepage = "https://github.com/emilk/egui/tree/main/crates/emath"
 license.workspace = true
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/emath"
+repository = "https://github.com/emilk/egui/tree/main/crates/emath"
 categories = ["mathematics", "gui"]
 keywords = ["math", "gui"]
 include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
@@ -37,7 +37,7 @@ bytemuck = { workspace = true, optional = true, features = ["derive"] }
 document-features = { workspace = true, 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 }
+mint = { workspace = true, optional = true }
 
 ## Allow serialization using [`serde`](https://docs.rs/serde).
 serde = { workspace = true, optional = true }
diff --git a/crates/emath/src/align.rs b/crates/emath/src/align.rs
index 71f172441..395323d4f 100644
--- a/crates/emath/src/align.rs
+++ b/crates/emath/src/align.rs
@@ -1,6 +1,6 @@
 //! One- and two-dimensional alignment ([`Align::Center`], [`Align2::LEFT_TOP`] etc).
 
-use crate::{pos2, vec2, Pos2, Rangef, Rect, Vec2};
+use crate::{Pos2, Rangef, Rect, Vec2, pos2, vec2};
 
 /// left/center/right or top/center/bottom alignment for e.g. anchors and layouts.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
@@ -50,6 +50,16 @@ impl Align {
         }
     }
 
+    /// Returns the inverse alignment.
+    /// `Min` becomes `Max`, `Center` stays the same, `Max` becomes `Min`.
+    pub fn flip(self) -> Self {
+        match self {
+            Self::Min => Self::Max,
+            Self::Center => Self::Center,
+            Self::Max => Self::Min,
+        }
+    }
+
     /// Returns a range of given size within a specified range.
     ///
     /// If the requested `size` is bigger than the size of `range`, then the returned
@@ -124,7 +134,7 @@ impl Align {
                 if size == f32::INFINITY {
                     Rangef::new(f32::NEG_INFINITY, f32::INFINITY)
                 } else {
-                    let left = (min + max) / 2.0 - size / 2.0;
+                    let left = crate::fast_midpoint(min, max) - size / 2.0;
                     Rangef::new(left, left + size)
                 }
             }
@@ -136,7 +146,7 @@ impl Align {
 // ----------------------------------------------------------------------------
 
 /// Two-dimension alignment, e.g. [`Align2::LEFT_TOP`].
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Align2(pub [Align; 2]);
 
@@ -170,6 +180,24 @@ impl Align2 {
         vec2(self.x().to_sign(), self.y().to_sign())
     }
 
+    /// Flip on the x-axis
+    /// e.g. `TOP_LEFT` -> `TOP_RIGHT`
+    pub fn flip_x(self) -> Self {
+        Self([self.x().flip(), self.y()])
+    }
+
+    /// Flip on the y-axis
+    /// e.g. `TOP_LEFT` -> `BOTTOM_LEFT`
+    pub fn flip_y(self) -> Self {
+        Self([self.x(), self.y().flip()])
+    }
+
+    /// Flip on both axes
+    /// e.g. `TOP_LEFT` -> `BOTTOM_RIGHT`
+    pub fn flip(self) -> Self {
+        Self([self.x().flip(), self.y().flip()])
+    }
+
     /// 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 {
@@ -270,3 +298,9 @@ impl std::ops::IndexMut<usize> for Align2 {
 pub fn center_size_in_rect(size: Vec2, frame: Rect) -> Rect {
     Align2::CENTER_CENTER.align_size_within_rect(size, frame)
 }
+
+impl std::fmt::Debug for Align2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Align2({:?}, {:?})", self.x(), self.y())
+    }
+}
diff --git a/crates/emath/src/easing.rs b/crates/emath/src/easing.rs
index 352c451c2..95fc7250d 100644
--- a/crates/emath/src/easing.rs
+++ b/crates/emath/src/easing.rs
@@ -137,11 +137,7 @@ pub fn exponential_in(t: f32) -> f32 {
 /// There is a small discontinuity at 1.
 #[inline]
 pub fn exponential_out(t: f32) -> f32 {
-    if t == 1. {
-        t
-    } else {
-        1. - powf(2.0, -10. * t)
-    }
+    if t == 1. { t } else { 1. - powf(2.0, -10. * t) }
 }
 
 /// <https://easings.net/#easeInOutExpo>
diff --git a/crates/emath/src/lib.rs b/crates/emath/src/lib.rs
index 05210fbb2..476b36d07 100644
--- a/crates/emath/src/lib.rs
+++ b/crates/emath/src/lib.rs
@@ -34,6 +34,7 @@ mod ordered_float;
 mod pos2;
 mod range;
 mod rect;
+mod rect_align;
 mod rect_transform;
 mod rot2;
 pub mod smart_aim;
@@ -43,13 +44,14 @@ mod vec2b;
 
 pub use self::{
     align::{Align, Align2},
-    gui_rounding::{GuiRounding, GUI_ROUNDING},
+    gui_rounding::{GUI_ROUNDING, GuiRounding},
     history::History,
     numeric::*,
     ordered_float::*,
     pos2::*,
     range::Rangef,
     rect::*,
+    rect_align::RectAlign,
     rect_transform::*,
     rot2::*,
     ts_transform::*,
@@ -110,6 +112,21 @@ where
     (T::ONE - t) * *range.start() + t * *range.end()
 }
 
+/// This is a faster version of [`f32::midpoint`] which doesn't handle overflow.
+///
+/// ```
+/// # use emath::fast_midpoint;
+/// assert_eq!(fast_midpoint(1.0, 5.0), 3.0);
+/// ```
+#[inline(always)]
+pub fn fast_midpoint<R>(a: R, b: R) -> R
+where
+    R: Copy + Add<R, Output = R> + Div<R, Output = R> + One,
+{
+    let two = R::ONE + R::ONE;
+    (a + b) / two
+}
+
 /// Where in the range is this value? Returns 0-1 if within the range.
 ///
 /// Returns <0 if before and >1 if after.
@@ -147,7 +164,10 @@ where
 {
     let from = from.into();
     let to = to.into();
-    debug_assert!(from.start() != from.end());
+    debug_assert!(
+        from.start() != from.end(),
+        "from.start() and from.end() should not be equal"
+    );
     let t = (x - *from.start()) / (*from.end() - *from.start());
     lerp(to, t)
 }
@@ -171,14 +191,13 @@ where
     } else if *from.end() <= x {
         *to.end()
     } else {
-        debug_assert!(from.start() != from.end());
+        debug_assert!(
+            from.start() != from.end(),
+            "from.start() and from.end() should not be equal"
+        );
         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)
-        }
+        if T::ONE <= t { *to.end() } else { lerp(to, t) }
     }
 }
 
@@ -198,8 +217,14 @@ pub fn format_with_minimum_decimals(value: f64, decimals: usize) -> String {
 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();
-    debug_assert!(min_decimals <= max_decimals);
-    debug_assert!(max_decimals < 100);
+    debug_assert!(
+        min_decimals <= max_decimals,
+        "min_decimals should be <= max_decimals, but got min_decimals: {min_decimals}, max_decimals: {max_decimals}"
+    );
+    debug_assert!(
+        max_decimals < 100,
+        "max_decimals should be < 100, but got {max_decimals}"
+    );
     let max_decimals = max_decimals.min(16);
     let min_decimals = min_decimals.min(max_decimals);
 
@@ -234,7 +259,7 @@ pub fn almost_equal(a: f32, b: f32, epsilon: f32) -> bool {
     }
 }
 
-#[allow(clippy::approx_constant)]
+#[expect(clippy::approx_constant)]
 #[test]
 fn test_format() {
     assert_eq!(format_with_minimum_decimals(1_234_567.0, 0), "1234567");
diff --git a/crates/emath/src/numeric.rs b/crates/emath/src/numeric.rs
index 9a7814b23..1fbddbc66 100644
--- a/crates/emath/src/numeric.rs
+++ b/crates/emath/src/numeric.rs
@@ -23,7 +23,7 @@ macro_rules! impl_numeric_float {
 
             #[inline(always)]
             fn to_f64(self) -> f64 {
-                #[allow(trivial_numeric_casts)]
+                #[allow(trivial_numeric_casts, clippy::allow_attributes)]
                 {
                     self as f64
                 }
@@ -31,7 +31,7 @@ macro_rules! impl_numeric_float {
 
             #[inline(always)]
             fn from_f64(num: f64) -> Self {
-                #[allow(trivial_numeric_casts)]
+                #[allow(trivial_numeric_casts, clippy::allow_attributes)]
                 {
                     num as Self
                 }
diff --git a/crates/emath/src/ordered_float.rs b/crates/emath/src/ordered_float.rs
index 0b8014d90..369541fed 100644
--- a/crates/emath/src/ordered_float.rs
+++ b/crates/emath/src/ordered_float.rs
@@ -21,6 +21,13 @@ impl<T: Float + Copy> OrderedFloat<T> {
     }
 }
 
+impl<T: std::fmt::Debug> std::fmt::Debug for OrderedFloat<T> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
 impl<T: Float> Eq for OrderedFloat<T> {}
 
 impl<T: Float> PartialEq<Self> for OrderedFloat<T> {
@@ -101,7 +108,7 @@ impl Float for f64 {
 
 // Keep this trait in private module, to avoid exposing its methods as extensions in user code
 mod private {
-    use super::{Hash, Hasher};
+    use super::{Hash as _, Hasher};
 
     pub trait FloatImpl {
         fn is_nan(&self) -> bool;
@@ -117,13 +124,15 @@ mod private {
 
         #[inline]
         fn hash<H: Hasher>(&self, state: &mut H) {
-            if *self == 0.0 {
-                state.write_u8(0);
-            } else if self.is_nan() {
-                state.write_u8(1);
+            let bits = if self.is_nan() {
+                // "Canonical" NaN.
+                0x7fc00000
             } else {
-                self.to_bits().hash(state);
-            }
+                // A trick taken from the `ordered-float` crate: -0.0 + 0.0 == +0.0.
+                // https://github.com/reem/rust-ordered-float/blob/1841f0541ea0e56779cbac03de2705149e020675/src/lib.rs#L2178-L2181
+                (self + 0.0).to_bits()
+            };
+            bits.hash(state);
         }
     }
 
@@ -135,13 +144,13 @@ mod private {
 
         #[inline]
         fn hash<H: Hasher>(&self, state: &mut H) {
-            if *self == 0.0 {
-                state.write_u8(0);
-            } else if self.is_nan() {
-                state.write_u8(1);
+            let bits = if self.is_nan() {
+                // "Canonical" NaN.
+                0x7ff8000000000000
             } else {
-                self.to_bits().hash(state);
-            }
+                (self + 0.0).to_bits()
+            };
+            bits.hash(state);
         }
     }
 }
diff --git a/crates/emath/src/pos2.rs b/crates/emath/src/pos2.rs
index 1f4bd8642..fc26686b3 100644
--- a/crates/emath/src/pos2.rs
+++ b/crates/emath/src/pos2.rs
@@ -1,7 +1,9 @@
-use std::fmt;
-use std::ops::{Add, AddAssign, Sub, SubAssign};
+use std::{
+    fmt,
+    ops::{Add, AddAssign, MulAssign, Sub, SubAssign},
+};
 
-use crate::{lerp, Div, Mul, Vec2};
+use crate::{Div, Mul, Vec2, lerp};
 
 /// A position on screen.
 ///
@@ -305,6 +307,14 @@ impl Mul<Pos2> for f32 {
     }
 }
 
+impl MulAssign<f32> for Pos2 {
+    #[inline(always)]
+    fn mul_assign(&mut self, rhs: f32) {
+        self.x *= rhs;
+        self.y *= rhs;
+    }
+}
+
 impl Div<f32> for Pos2 {
     type Output = Self;
 
diff --git a/crates/emath/src/rect.rs b/crates/emath/src/rect.rs
index 521b6f33f..81729713b 100644
--- a/crates/emath/src/rect.rs
+++ b/crates/emath/src/rect.rs
@@ -1,6 +1,7 @@
 use std::fmt;
 
-use crate::{lerp, pos2, vec2, Div, Mul, Pos2, Rangef, Rot2, Vec2};
+use crate::{Div, Mul, NumExt as _, Pos2, Rangef, Rot2, Vec2, fast_midpoint, lerp, pos2, vec2};
+use std::ops::{BitOr, BitOrAssign};
 
 /// A rectangular region of space.
 ///
@@ -330,8 +331,8 @@ impl Rect {
     #[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,
+            x: fast_midpoint(self.min.x, self.max.x),
+            y: fast_midpoint(self.min.y, self.max.y),
         }
     }
 
@@ -341,11 +342,13 @@ impl Rect {
         self.max - self.min
     }
 
+    /// Note: this can be negative.
     #[inline(always)]
     pub fn width(&self) -> f32 {
         self.max.x - self.min.x
     }
 
+    /// Note: this can be negative.
     #[inline(always)]
     pub fn height(&self) -> f32 {
         self.max.y - self.min.y
@@ -373,9 +376,10 @@ impl Rect {
         }
     }
 
+    /// This is never negative, and instead returns zero for negative rectangles.
     #[inline(always)]
     pub fn area(&self) -> f32 {
-        self.width() * self.height()
+        self.width().at_least(0.0) * self.height().at_least(0.0)
     }
 
     /// The distance from the rect to the position.
@@ -445,7 +449,8 @@ impl Rect {
     /// Linearly interpolate so that `[0, 0]` is [`Self::min`] and
     /// `[1, 1]` is [`Self::max`].
     #[inline]
-    pub fn lerp_inside(&self, t: Vec2) -> Pos2 {
+    pub fn lerp_inside(&self, t: impl Into<Vec2>) -> Pos2 {
+        let t = t.into();
         Pos2 {
             x: lerp(self.min.x..=self.max.x, t.x),
             y: lerp(self.min.y..=self.max.y, t.y),
@@ -651,7 +656,7 @@ impl Rect {
     pub fn intersects_ray(&self, o: Pos2, d: Vec2) -> bool {
         debug_assert!(
             d.is_normalized(),
-            "expected normalized direction, but `d` has length {}",
+            "Debug assert: expected normalized direction, but `d` has length {}",
             d.length()
         );
 
@@ -710,7 +715,11 @@ impl Rect {
 
 impl fmt::Debug for Rect {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "[{:?} - {:?}]", self.min, self.max)
+        if let Some(precision) = f.precision() {
+            write!(f, "[{1:.0$?} - {2:.0$?}]", precision, self.min, self.max)
+        } else {
+            write!(f, "[{:?} - {:?}]", self.min, self.max)
+        }
     }
 }
 
@@ -769,6 +778,22 @@ impl Div<f32> for Rect {
     }
 }
 
+impl BitOr for Rect {
+    type Output = Self;
+
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        self.union(other)
+    }
+}
+
+impl BitOrAssign for Rect {
+    #[inline]
+    fn bitor_assign(&mut self, other: Self) {
+        *self = self.union(other);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -806,6 +831,7 @@ mod tests {
         );
     }
 
+    #[expect(clippy::print_stdout)]
     #[test]
     fn test_ray_intersection() {
         let rect = Rect::from_min_max(pos2(1.0, 1.0), pos2(3.0, 3.0));
diff --git a/crates/emath/src/rect_align.rs b/crates/emath/src/rect_align.rs
new file mode 100644
index 000000000..84cf60ce0
--- /dev/null
+++ b/crates/emath/src/rect_align.rs
@@ -0,0 +1,268 @@
+use crate::{Align2, Pos2, Rect, Vec2};
+
+/// Position a child [`Rect`] relative to a parent [`Rect`].
+///
+/// The corner from [`RectAlign::child`] on the new rect will be aligned to
+/// the corner from [`RectAlign::parent`] on the original rect.
+///
+/// There are helper constants for the 12 common menu positions:
+/// ```text
+///              ┌───────────┐  ┌────────┐  ┌─────────┐
+///              │ TOP_START │  │  TOP   │  │ TOP_END │
+///              └───────────┘  └────────┘  └─────────┘
+/// ┌──────────┐ ┌────────────────────────────────────┐ ┌───────────┐
+/// │LEFT_START│ │                                    │ │RIGHT_START│
+/// └──────────┘ │                                    │ └───────────┘
+/// ┌──────────┐ │                                    │ ┌───────────┐
+/// │   LEFT   │ │             some_rect              │ │   RIGHT   │
+/// └──────────┘ │                                    │ └───────────┘
+/// ┌──────────┐ │                                    │ ┌───────────┐
+/// │ LEFT_END │ │                                    │ │ RIGHT_END │
+/// └──────────┘ └────────────────────────────────────┘ └───────────┘
+///              ┌────────────┐  ┌──────┐  ┌──────────┐
+///              │BOTTOM_START│  │BOTTOM│  │BOTTOM_END│
+///              └────────────┘  └──────┘  └──────────┘
+/// ```
+// There is no `new` function on purpose, since writing out `parent` and `child` is more
+// reasonable.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct RectAlign {
+    /// The alignment in the parent (original) rect.
+    pub parent: Align2,
+
+    /// The alignment in the child (new) rect.
+    pub child: Align2,
+}
+
+impl Default for RectAlign {
+    fn default() -> Self {
+        Self::BOTTOM_START
+    }
+}
+
+impl RectAlign {
+    /// Along the top edge, leftmost.
+    pub const TOP_START: Self = Self {
+        parent: Align2::LEFT_TOP,
+        child: Align2::LEFT_BOTTOM,
+    };
+
+    /// Along the top edge, centered.
+    pub const TOP: Self = Self {
+        parent: Align2::CENTER_TOP,
+        child: Align2::CENTER_BOTTOM,
+    };
+
+    /// Along the top edge, rightmost.
+    pub const TOP_END: Self = Self {
+        parent: Align2::RIGHT_TOP,
+        child: Align2::RIGHT_BOTTOM,
+    };
+
+    /// Along the right edge, topmost.
+    pub const RIGHT_START: Self = Self {
+        parent: Align2::RIGHT_TOP,
+        child: Align2::LEFT_TOP,
+    };
+
+    /// Along the right edge, centered.
+    pub const RIGHT: Self = Self {
+        parent: Align2::RIGHT_CENTER,
+        child: Align2::LEFT_CENTER,
+    };
+
+    /// Along the right edge, bottommost.
+    pub const RIGHT_END: Self = Self {
+        parent: Align2::RIGHT_BOTTOM,
+        child: Align2::LEFT_BOTTOM,
+    };
+
+    /// Along the bottom edge, rightmost.
+    pub const BOTTOM_END: Self = Self {
+        parent: Align2::RIGHT_BOTTOM,
+        child: Align2::RIGHT_TOP,
+    };
+
+    /// Along the bottom edge, centered.
+    pub const BOTTOM: Self = Self {
+        parent: Align2::CENTER_BOTTOM,
+        child: Align2::CENTER_TOP,
+    };
+
+    /// Along the bottom edge, leftmost.
+    pub const BOTTOM_START: Self = Self {
+        parent: Align2::LEFT_BOTTOM,
+        child: Align2::LEFT_TOP,
+    };
+
+    /// Along the left edge, bottommost.
+    pub const LEFT_END: Self = Self {
+        parent: Align2::LEFT_BOTTOM,
+        child: Align2::RIGHT_BOTTOM,
+    };
+
+    /// Along the left edge, centered.
+    pub const LEFT: Self = Self {
+        parent: Align2::LEFT_CENTER,
+        child: Align2::RIGHT_CENTER,
+    };
+
+    /// Along the left edge, topmost.
+    pub const LEFT_START: Self = Self {
+        parent: Align2::LEFT_TOP,
+        child: Align2::RIGHT_TOP,
+    };
+
+    /// The 12 most common menu positions as an array, for use with [`RectAlign::find_best_align`].
+    pub const MENU_ALIGNS: [Self; 12] = [
+        Self::BOTTOM_START,
+        Self::BOTTOM_END,
+        Self::TOP_START,
+        Self::TOP_END,
+        Self::RIGHT_END,
+        Self::RIGHT_START,
+        Self::LEFT_END,
+        Self::LEFT_START,
+        // These come last on purpose, we prefer the corner ones
+        Self::TOP,
+        Self::RIGHT,
+        Self::BOTTOM,
+        Self::LEFT,
+    ];
+
+    /// Align in the parent rect.
+    pub fn parent(&self) -> Align2 {
+        self.parent
+    }
+
+    /// Align in the child rect.
+    pub fn child(&self) -> Align2 {
+        self.child
+    }
+
+    /// Convert an [`Align2`] to an [`RectAlign`], positioning the child rect inside the parent.
+    pub fn from_align2(align: Align2) -> Self {
+        Self {
+            parent: align,
+            child: align,
+        }
+    }
+
+    /// The center of the child rect will be aligned to a corner of the parent rect.
+    pub fn over_corner(align: Align2) -> Self {
+        Self {
+            parent: align,
+            child: Align2::CENTER_CENTER,
+        }
+    }
+
+    /// Position the child rect outside the parent rect.
+    pub fn outside(align: Align2) -> Self {
+        Self {
+            parent: align,
+            child: align.flip(),
+        }
+    }
+
+    /// Calculate the child rect based on a size and some optional gap.
+    pub fn align_rect(&self, parent_rect: &Rect, size: Vec2, gap: f32) -> Rect {
+        let (pivot, anchor) = self.pivot_pos(parent_rect, gap);
+        pivot.anchor_size(anchor, size)
+    }
+
+    /// Returns a [`Align2`] and a [`Pos2`] that you can e.g. use with `Area::fixed_pos`
+    /// and `Area::pivot` to align an `Area` to some rect.
+    pub fn pivot_pos(&self, parent_rect: &Rect, gap: f32) -> (Align2, Pos2) {
+        (self.child(), self.anchor(parent_rect, gap))
+    }
+
+    /// Returns a sign vector (-1, 0 or 1 in each direction) that can be used as an offset to the
+    /// child rect, creating a gap between the rects while keeping the edges aligned.
+    pub fn gap_vector(&self) -> Vec2 {
+        let mut gap = -self.child.to_sign();
+
+        // Align the edges in these cases
+        match *self {
+            Self::TOP_START | Self::TOP_END | Self::BOTTOM_START | Self::BOTTOM_END => {
+                gap.x = 0.0;
+            }
+            Self::LEFT_START | Self::LEFT_END | Self::RIGHT_START | Self::RIGHT_END => {
+                gap.y = 0.0;
+            }
+            _ => {}
+        }
+
+        gap
+    }
+
+    /// Calculator the anchor point for the child rect, based on the parent rect and an optional gap.
+    pub fn anchor(&self, parent_rect: &Rect, gap: f32) -> Pos2 {
+        let pos = self.parent.pos_in_rect(parent_rect);
+
+        let offset = self.gap_vector() * gap;
+
+        pos + offset
+    }
+
+    /// Flip the alignment on the x-axis.
+    pub fn flip_x(self) -> Self {
+        Self {
+            parent: self.parent.flip_x(),
+            child: self.child.flip_x(),
+        }
+    }
+
+    /// Flip the alignment on the y-axis.
+    pub fn flip_y(self) -> Self {
+        Self {
+            parent: self.parent.flip_y(),
+            child: self.child.flip_y(),
+        }
+    }
+
+    /// Flip the alignment on both axes.
+    pub fn flip(self) -> Self {
+        Self {
+            parent: self.parent.flip(),
+            child: self.child.flip(),
+        }
+    }
+
+    /// Returns the 3 alternative [`RectAlign`]s that are flipped in various ways, for use
+    /// with [`RectAlign::find_best_align`].
+    pub fn symmetries(self) -> [Self; 3] {
+        [self.flip_x(), self.flip_y(), self.flip()]
+    }
+
+    /// Look for the first alternative [`RectAlign`] that allows the child rect to fit
+    /// inside the `content_rect`.
+    ///
+    /// If no alternative fits, the first is returned.
+    /// If no alternatives are given, `None` is returned.
+    ///
+    /// See also:
+    /// - [`RectAlign::symmetries`] to calculate alternatives
+    /// - [`RectAlign::MENU_ALIGNS`] for the 12 common menu positions
+    pub fn find_best_align(
+        values_to_try: impl Iterator<Item = Self>,
+        content_rect: Rect,
+        parent_rect: Rect,
+        gap: f32,
+        expected_size: Vec2,
+    ) -> Option<Self> {
+        let mut first_choice = None;
+
+        for align in values_to_try {
+            first_choice = first_choice.or(Some(align)); // Remember the first alternative
+
+            let suggested_popup_rect = align.align_rect(&parent_rect, expected_size, gap);
+
+            if content_rect.contains_rect(suggested_popup_rect) {
+                return Some(align);
+            }
+        }
+
+        first_choice
+    }
+}
diff --git a/crates/emath/src/rect_transform.rs b/crates/emath/src/rect_transform.rs
index da9382790..3539efe75 100644
--- a/crates/emath/src/rect_transform.rs
+++ b/crates/emath/src/rect_transform.rs
@@ -1,4 +1,4 @@
-use crate::{pos2, remap, remap_clamp, Pos2, Rect, Vec2};
+use crate::{Pos2, Rect, Vec2, pos2, remap, remap_clamp};
 
 /// Linearly transforms positions from one [`Rect`] to another.
 ///
diff --git a/crates/emath/src/rot2.rs b/crates/emath/src/rot2.rs
index 88c425a50..9af0103a0 100644
--- a/crates/emath/src/rot2.rs
+++ b/crates/emath/src/rot2.rs
@@ -84,7 +84,10 @@ impl Rot2 {
             c: self.c / l,
             s: self.s / l,
         };
-        debug_assert!(ret.is_finite());
+        debug_assert!(
+            ret.is_finite(),
+            "Rot2::normalized produced a non-finite result"
+        );
         ret
     }
 }
diff --git a/crates/emath/src/smart_aim.rs b/crates/emath/src/smart_aim.rs
index 720947069..c1b96ec7b 100644
--- a/crates/emath/src/smart_aim.rs
+++ b/crates/emath/src/smart_aim.rs
@@ -1,5 +1,7 @@
 //! Find "simple" numbers is some range. Used by sliders.
 
+use crate::fast_midpoint;
+
 const NUM_DECIMALS: usize = 15;
 
 /// Find the "simplest" number in a closed range [min, max], i.e. the one with the fewest decimal digits.
@@ -29,18 +31,24 @@ pub fn best_in_range_f64(min: f64, max: f64) -> f64 {
         return -best_in_range_f64(-max, -min);
     }
 
+    debug_assert!(0.0 < min && min < max, "Logic bug");
+
     // Prefer finite numbers:
     if !max.is_finite() {
         return min;
     }
-    debug_assert!(min.is_finite() && max.is_finite());
+    debug_assert!(
+        min.is_finite() && max.is_finite(),
+        "min: {min:?}, max: {max:?}"
+    );
 
     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;
+        // Different orders of magnitude.
+        // Pick the geometric center of the two:
+        let exponent = fast_midpoint(min_exponent, max_exponent);
         return 10.0_f64.powi(exponent.round() as i32);
     }
 
@@ -51,65 +59,88 @@ pub fn best_in_range_f64(min: f64, max: f64) -> f64 {
         return 10.0_f64.powf(max_exponent);
     }
 
-    let exp_factor = 10.0_f64.powi(max_exponent.floor() as i32);
+    // Find the proper scale, and then convert to integers:
 
-    let min_str = to_decimal_string(min / exp_factor);
-    let max_str = to_decimal_string(max / exp_factor);
+    let scale = NUM_DECIMALS as i32 - max_exponent.floor() as i32 - 1;
+    let scale_factor = 10.0_f64.powi(scale);
+
+    let min_str = to_decimal_string((min * scale_factor).round() as u64);
+    let max_str = to_decimal_string((max * scale_factor).round() as u64);
+
+    // We now have two positive integers of the same length.
+    // We want to find the first non-matching digit,
+    // which we will call the "deciding digit".
+    // Everything before it will be the same,
+    // everything after will be zero,
+    // and the deciding digit itself will be picked as a "smart average"
+    // min:    12345
+    // max:    12780
+    // output: 12500
 
     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;
+    for i in 0..NUM_DECIMALS {
+        if min_str[i] == max_str[i] {
+            ret_str[i] = min_str[i];
+        } else {
+            // Found the deciding digit at index `i`
+            let mut deciding_digit_min = min_str[i];
+            let deciding_digit_max = max_str[i];
+
+            debug_assert!(
+                deciding_digit_min < deciding_digit_max,
+                "Bug in smart aim code"
+            );
+
+            let rest_of_min_is_zeroes = min_str[i + 1..].iter().all(|&c| c == 0);
+
+            if !rest_of_min_is_zeroes {
+                // There are more digits coming after `deciding_digit_min`, so we cannot pick it.
+                // So the true min of what we can pick is one greater:
+                deciding_digit_min += 1;
+            }
+
+            let deciding_digit = if deciding_digit_min == 0 {
+                0
+            } else if deciding_digit_min <= 5 && 5 <= deciding_digit_max {
+                5 // 5 is the roundest number in the range
+            } else {
+                deciding_digit_min.midpoint(deciding_digit_max)
+            };
+
+            ret_str[i] = deciding_digit;
+
+            return from_decimal_string(ret_str) as f64 / scale_factor;
+        }
     }
 
-    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
+    min // All digits are the same. Already handled earlier, but better safe than sorry
 }
 
 fn is_integer(f: f64) -> bool {
     f.round() == f
 }
 
-fn to_decimal_string(v: f64) -> [i32; NUM_DECIMALS] {
-    debug_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));
+fn to_decimal_string(v: u64) -> [u8; NUM_DECIMALS] {
+    let mut ret = [0; NUM_DECIMALS];
+    let mut value = v;
+    for i in (0..NUM_DECIMALS).rev() {
+        ret[i] = (value % 10) as u8;
+        value /= 10;
     }
     ret
 }
 
-/// Find the simplest integer in the range [min, max]
-fn simplest_digit_closed_range(min: i32, max: i32) -> i32 {
-    debug_assert!(1 <= min && min <= max && max <= 9);
-    if min <= 5 && 5 <= max {
-        5
-    } else {
-        (min + max) / 2
+fn from_decimal_string(s: [u8; NUM_DECIMALS]) -> u64 {
+    let mut value = 0;
+    for &c in &s {
+        debug_assert!(c <= 9, "Bad number");
+        value = value * 10 + c as u64;
     }
+    value
 }
 
-#[allow(clippy::approx_constant)]
+#[expect(clippy::approx_constant)]
 #[test]
 fn test_aim() {
     assert_eq!(best_in_range_f64(-0.2, 0.0), 0.0, "Prefer zero");
@@ -153,4 +184,53 @@ fn test_aim() {
     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);
+
+    #[track_caller]
+    fn test_f64((min, max): (f64, f64), expected: f64) {
+        let aimed = best_in_range_f64(min, max);
+        assert!(
+            aimed == expected,
+            "smart_aim({min} – {max}) => {aimed}, but expected {expected}"
+        );
+    }
+    #[track_caller]
+    fn test_i64((min, max): (i64, i64), expected: i64) {
+        let aimed = best_in_range_f64(min as _, max as _);
+        assert!(
+            aimed == expected as f64,
+            "smart_aim({min} – {max}) => {aimed}, but expected {expected}"
+        );
+    }
+
+    test_i64((99, 300), 100);
+    test_i64((300, 99), 100);
+    test_i64((-99, -300), -100);
+    test_i64((-99, 123), 0); // Prefer zero
+    test_i64((4, 9), 5); // Prefer ending on 5
+    test_i64((14, 19), 15); // Prefer ending on 5
+    test_i64((12, 65), 50); // Prefer leading 5
+    test_i64((493, 879), 500); // Prefer leading 5
+    test_i64((37, 48), 40);
+    test_i64((100, 123), 100);
+    test_i64((101, 1000), 1000);
+    test_i64((999, 1000), 1000);
+    test_i64((123, 500), 500);
+    test_i64((500, 777), 500);
+    test_i64((500, 999), 500);
+    test_i64((12345, 12780), 12500);
+    test_i64((12371, 12376), 12375);
+    test_i64((12371, 12376), 12375);
+
+    test_f64((7.5, 16.3), 10.0);
+    test_f64((7.5, 76.3), 10.0);
+    test_f64((7.5, 763.3), 100.0);
+    test_f64((7.5, 1_345.0), 100.0); // Geometric mean
+    test_f64((7.5, 123_456.0), 1_000.0); // Geometric mean
+    test_f64((-0.2, 0.0), 0.0); // Prefer zero
+    test_f64((-10_004.23, 4.14), 0.0); // Prefer zero
+    test_f64((-0.2, 100.0), 0.0); // Prefer zero
+    test_f64((0.2, 0.0), 0.0); // Prefer zero
+    test_f64((7.8, 17.8), 10.0);
+    test_f64((14.1, 19.1), 15.0); // Prefer ending on 5
+    test_f64((12.3, 65.9), 50.0); // Prefer leading 5
 }
diff --git a/crates/emath/src/ts_transform.rs b/crates/emath/src/ts_transform.rs
index 46c7e2a8e..515f5ecd7 100644
--- a/crates/emath/src/ts_transform.rs
+++ b/crates/emath/src/ts_transform.rs
@@ -36,8 +36,8 @@ impl TSTransform {
     /// `(0, 0)`, then translates them.
     pub fn new(translation: Vec2, scaling: f32) -> Self {
         Self {
-            translation,
             scaling,
+            translation,
         }
     }
 
diff --git a/crates/emath/src/vec2.rs b/crates/emath/src/vec2.rs
index 9a173348b..f79359df9 100644
--- a/crates/emath/src/vec2.rs
+++ b/crates/emath/src/vec2.rs
@@ -140,6 +140,7 @@ impl Vec2 {
     pub const DOWN: Self = Self { x: 0.0, y: 1.0 };
 
     pub const ZERO: Self = Self { x: 0.0, y: 0.0 };
+    pub const ONE: Self = Self { x: 1.0, y: 1.0 };
     pub const INFINITY: Self = Self::splat(f32::INFINITY);
     pub const NAN: Self = Self::splat(f32::NAN);
 
@@ -169,11 +170,7 @@ impl Vec2 {
     #[inline(always)]
     pub fn normalized(self) -> Self {
         let len = self.length();
-        if len <= 0.0 {
-            self
-        } else {
-            self / len
-        }
+        if len <= 0.0 { self } else { self / len }
     }
 
     /// Checks if `self` has length `1.0` up to a precision of `1e-6`.
diff --git a/crates/epaint/CHANGELOG.md b/crates/epaint/CHANGELOG.md
index cee374ce6..b23c454b4 100644
--- a/crates/epaint/CHANGELOG.md
+++ b/crates/epaint/CHANGELOG.md
@@ -5,6 +5,62 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+Nothing new
+
+
+## 0.33.0 - 2025-10-09
+* Remove the `deadlock_detection` feature [#7497](https://github.com/emilk/egui/pull/7497) by [@lucasmerlin](https://github.com/lucasmerlin)
+* More even text kerning [#7431](https://github.com/emilk/egui/pull/7431) by [@valadaptive](https://github.com/valadaptive)
+* Return `0.0` if font not found in `glyph_width` instead of panic [#7559](https://github.com/emilk/egui/pull/7559) by [@lucasmerlin](https://github.com/lucasmerlin)
+* Update MSRV from 1.86 to 1.88 [#7579](https://github.com/emilk/egui/pull/7579) by [@Wumpf](https://github.com/Wumpf)
+* Remove `log` feature [#7583](https://github.com/emilk/egui/pull/7583) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.3 - 2025-09-12
+* Optimize `Mesh::add_rect_with_uv` [#7511](https://github.com/emilk/egui/pull/7511) by [@valadaptive](https://github.com/valadaptive)
+
+
+## 0.32.2 - 2025-09-04
+* Panic mutexes that can't lock for 30 seconds, in debug builds [#7468](https://github.com/emilk/egui/pull/7468) by [@emilk](https://github.com/emilk)
+* Skip zero-length layout job sections [#7430](https://github.com/emilk/egui/pull/7430) by [@HactarCE](https://github.com/HactarCE)
+
+
+## 0.32.1 - 2025-08-15
+* Fix multi-line `TextShape` rotation [#7404](https://github.com/emilk/egui/pull/7404) by [@afishhh](https://github.com/afishhh)
+* Fix glyph rendering: clamp coverage to [0, 1] [#7415](https://github.com/emilk/egui/pull/7415) by [@emilk](https://github.com/emilk)
+
+
+## 0.32.0 - 2025-07-10
+### ⭐ Added
+* Impl AsRef<[u8]> for FontData [#5757](https://github.com/emilk/egui/pull/5757) by [@StratusFearMe21](https://github.com/StratusFearMe21)
+* Add `expand_bg` to customize size of text background [#5365](https://github.com/emilk/egui/pull/5365) by [@MeGaGiGaGon](https://github.com/MeGaGiGaGon)
+* Add anchored text rotation method, and clarify related docs [#7130](https://github.com/emilk/egui/pull/7130) by [@pmarks](https://github.com/pmarks)
+* Add `Galley::intrinsic_size` [#7146](https://github.com/emilk/egui/pull/7146) by [@lucasmerlin](https://github.com/lucasmerlin)
+
+### 🔧 Changed
+* Fix semi-transparent colors appearing too bright [#5824](https://github.com/emilk/egui/pull/5824) by [@emilk](https://github.com/emilk)
+* Improve text sharpness [#5838](https://github.com/emilk/egui/pull/5838) by [@emilk](https://github.com/emilk)
+* Improve text rendering in light mode [#7290](https://github.com/emilk/egui/pull/7290) by [@emilk](https://github.com/emilk)
+* Make text underline and strikethrough pixel perfect crisp [#5857](https://github.com/emilk/egui/pull/5857) by [@emilk](https://github.com/emilk)
+* Update `emoji-icon-font` with fix for fullwidth latin characters [#7067](https://github.com/emilk/egui/pull/7067) by [@emilk](https://github.com/emilk)
+* Add assert messages and print bad argument values in asserts [#5216](https://github.com/emilk/egui/pull/5216) by [@bircni](https://github.com/bircni)
+
+### 🔥 Removed
+* Remove things that have been deprecated for over a year [#7099](https://github.com/emilk/egui/pull/7099) by [@emilk](https://github.com/emilk)
+
+### 🐛 Fixed
+* Fix: transform `TextShape` underline width [#5865](https://github.com/emilk/egui/pull/5865) by [@emilk](https://github.com/emilk)
+* Fix `visual_bounding_rect` for rotated text [#7050](https://github.com/emilk/egui/pull/7050) by [@pmarks](https://github.com/pmarks)
+
+### 🚀 Performance
+* Optimize editing long text by caching each paragraph [#5411](https://github.com/emilk/egui/pull/5411) by [@afishhh](https://github.com/afishhh)
+
+
+## 0.31.1 - 2025-03-05
+* Fix panic when rendering thin textured rectangles [#5692](https://github.com/emilk/egui/pull/5692) by [@PPakalns](https://github.com/PPakalns)
+
+
 ## 0.31.0 - 2025-02-04
 ### ⭐ Added
 * Improve tessellation quality [#5669](https://github.com/emilk/egui/pull/5669) by [@emilk](https://github.com/emilk)
diff --git a/crates/epaint/Cargo.toml b/crates/epaint/Cargo.toml
index 720188872..3ac99a97f 100644
--- a/crates/epaint/Cargo.toml
+++ b/crates/epaint/Cargo.toml
@@ -5,18 +5,13 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Minimal 2D graphics library for GUI work"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/epaint"
+homepage = "https://github.com/emilk/egui/tree/main/crates/epaint"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/epaint"
+repository = "https://github.com/emilk/egui/tree/main/crates/epaint"
 categories = ["graphics", "gui"]
 keywords = ["graphics", "gui", "egui"]
-include = [
-  "../LICENSE-APACHE",
-  "../LICENSE-MIT",
-  "**/*.rs",
-  "Cargo.toml"
-]
+include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
 
 [lints]
 workspace = true
@@ -40,18 +35,10 @@ 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 = ["epaint_default_fonts"]
 
-## Turn on the `log` feature, that makes egui log some errors using the [`log`](https://docs.rs/log) crate.
-log = ["dep:log"]
-
 ## [`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"]
 
@@ -74,11 +61,12 @@ _override_unity = []
 emath.workspace = true
 ecolor.workspace = true
 
-ab_glyph = "0.2.11"
+ab_glyph.workspace = true
 ahash.workspace = true
+log.workspace = true
 nohash-hasher.workspace = true
-parking_lot.workspace = true   # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
-profiling = { workspace = true}
+parking_lot.workspace = true # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
+profiling = { workspace = true }
 
 #! ### Optional dependencies
 bytemuck = { workspace = true, optional = true, features = ["derive"] }
@@ -86,21 +74,17 @@ bytemuck = { workspace = true, optional = true, features = ["derive"] }
 ## Enable this when generating docs.
 document-features = { workspace = true, optional = true }
 
-log = { workspace = true, optional = true }
-rayon = { version = "1.7", optional = true }
+rayon = { workspace = true, optional = true }
 
 ## Allow serialization using [`serde`](https://docs.rs/serde) .
 serde = { workspace = true, optional = true, features = ["derive", "rc"] }
 
 epaint_default_fonts = { workspace = true, optional = true }
 
-# native:
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-backtrace = { workspace = true, optional = true }
-
-
 [dev-dependencies]
 criterion.workspace = true
+mimalloc.workspace = true
+similar-asserts.workspace = true
 
 
 [[bench]]
diff --git a/crates/epaint/benches/benchmark.rs b/crates/epaint/benches/benchmark.rs
index e723638b8..7b97b20a2 100644
--- a/crates/epaint/benches/benchmark.rs
+++ b/crates/epaint/benches/benchmark.rs
@@ -1,10 +1,15 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 
 use epaint::{
-    pos2, tessellator::Path, ClippedShape, Color32, Mesh, PathStroke, Pos2, Rect, Shape, Stroke,
-    TessellationOptions, Tessellator, TextureAtlas, Vec2,
+    AlphaFromCoverage, ClippedShape, Color32, Mesh, PathStroke, Pos2, Rect, Shape, Stroke,
+    TessellationOptions, Tessellator, TextureAtlas, Vec2, pos2, tessellator::Path,
 };
 
+use std::hint::black_box;
+
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; // Much faster allocator
+
 fn single_dashed_lines(c: &mut Criterion) {
     c.bench_function("single_dashed_lines", move |b| {
         b.iter(|| {
@@ -53,12 +58,17 @@ fn tessellate_circles(c: &mut Criterion) {
                 clipped_shapes.push(ClippedShape { clip_rect, shape });
             }
         }
-        assert_eq!(clipped_shapes.len(), 100_000);
+        assert_eq!(
+            clipped_shapes.len(),
+            100_000,
+            "length of clipped shapes should be 100k, but was {}",
+            clipped_shapes.len()
+        );
 
         let pixels_per_point = 2.0;
         let options = TessellationOptions::default();
 
-        let atlas = TextureAtlas::new([4096, 256]);
+        let atlas = TextureAtlas::new([4096, 256], AlphaFromCoverage::default());
         let font_tex_size = atlas.size();
         let prepared_discs = atlas.prepared_discs();
 
diff --git a/crates/epaint/src/image.rs b/crates/epaint/src/image.rs
index f653be2e7..059d9d769 100644
--- a/crates/epaint/src/image.rs
+++ b/crates/epaint/src/image.rs
@@ -1,28 +1,26 @@
-use crate::{textures::TextureOptions, Color32};
+use emath::Vec2;
+
+use crate::{Color32, textures::TextureOptions};
 use std::sync::Arc;
 
 /// 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
+/// This is currently an enum with only one variant, but more image types may be added in the future.
 ///
-/// See also: [`ColorImage`], [`FontImage`].
-#[derive(Clone, PartialEq)]
+/// See also: [`ColorImage`].
+#[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum ImageData {
     /// RGBA image.
     Color(Arc<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,
         }
     }
 
@@ -36,7 +34,7 @@ impl ImageData {
 
     pub fn bytes_per_pixel(&self) -> usize {
         match self {
-            Self::Color(_) | Self::Font(_) => 4,
+            Self::Color(_) => 4,
         }
     }
 }
@@ -47,18 +45,36 @@ impl ImageData {
 #[derive(Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct ColorImage {
-    /// width, height.
+    /// width, height in texels.
     pub size: [usize; 2],
 
+    /// Size of the original SVG image (if any), or just the texel size of the image.
+    pub source_size: Vec2,
+
     /// 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 {
+    pub fn new(size: [usize; 2], pixels: Vec<Color32>) -> Self {
+        debug_assert!(
+            size[0] * size[1] == pixels.len(),
+            "size: {size:?}, pixels.len(): {}",
+            pixels.len()
+        );
         Self {
             size,
+            source_size: Vec2::new(size[0] as f32, size[1] as f32),
+            pixels,
+        }
+    }
+
+    /// Create an image filled with the given color.
+    pub fn filled(size: [usize; 2], color: Color32) -> Self {
+        Self {
+            size,
+            source_size: Vec2::new(size[0] as f32, size[1] as f32),
             pixels: vec![color; size[0] * size[1]],
         }
     }
@@ -94,30 +110,48 @@ impl ColorImage {
     /// }
     /// ```
     pub fn from_rgba_unmultiplied(size: [usize; 2], rgba: &[u8]) -> Self {
-        assert_eq!(size[0] * size[1] * 4, rgba.len());
+        assert_eq!(
+            size[0] * size[1] * 4,
+            rgba.len(),
+            "size: {:?}, rgba.len(): {}",
+            size,
+            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 }
+        Self::new(size, pixels)
     }
 
     pub fn from_rgba_premultiplied(size: [usize; 2], rgba: &[u8]) -> Self {
-        assert_eq!(size[0] * size[1] * 4, rgba.len());
+        assert_eq!(
+            size[0] * size[1] * 4,
+            rgba.len(),
+            "size: {:?}, rgba.len(): {}",
+            size,
+            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 }
+        Self::new(size, pixels)
     }
 
     /// Create a [`ColorImage`] from flat opaque gray data.
     ///
     /// Panics if `size[0] * size[1] != gray.len()`.
     pub fn from_gray(size: [usize; 2], gray: &[u8]) -> Self {
-        assert_eq!(size[0] * size[1], gray.len());
+        assert_eq!(
+            size[0] * size[1],
+            gray.len(),
+            "size: {:?}, gray.len(): {}",
+            size,
+            gray.len()
+        );
         let pixels = gray.iter().map(|p| Color32::from_gray(*p)).collect();
-        Self { size, pixels }
+        Self::new(size, pixels)
     }
 
     /// Alternative method to `from_gray`.
@@ -127,8 +161,14 @@ impl ColorImage {
     #[doc(alias = "from_grey_iter")]
     pub fn from_gray_iter(size: [usize; 2], gray_iter: impl Iterator<Item = u8>) -> Self {
         let pixels: Vec<_> = gray_iter.map(Color32::from_gray).collect();
-        assert_eq!(size[0] * size[1], pixels.len());
-        Self { size, pixels }
+        assert_eq!(
+            size[0] * size[1],
+            pixels.len(),
+            "size: {:?}, pixels.len(): {}",
+            size,
+            pixels.len()
+        );
+        Self::new(size, pixels)
     }
 
     /// A view of the underlying data as `&[u8]`
@@ -150,19 +190,25 @@ impl ColorImage {
     ///
     /// 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());
+        assert_eq!(
+            size[0] * size[1] * 3,
+            rgb.len(),
+            "size: {:?}, rgb.len(): {}",
+            size,
+            rgb.len()
+        );
         let pixels = rgb
             .chunks_exact(3)
             .map(|p| Color32::from_rgb(p[0], p[1], p[2]))
             .collect();
-        Self { size, pixels }
+        Self::new(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);
+        let mut img = Self::filled([width, height], Color32::TRANSPARENT);
         for y in 0..height {
             for x in 0..width {
                 let h = x as f32 / width as f32;
@@ -175,6 +221,13 @@ impl ColorImage {
         img
     }
 
+    /// Set the source size of e.g. the original SVG image.
+    #[inline]
+    pub fn with_source_size(mut self, source_size: Vec2) -> Self {
+        self.source_size = source_size;
+        self
+    }
+
     #[inline]
     pub fn width(&self) -> usize {
         self.size[0]
@@ -212,10 +265,38 @@ impl ColorImage {
                 &self.pixels[row * row_stride + min_x..row * row_stride + max_x],
             );
         }
-        Self {
-            size: [width, height],
-            pixels: output,
+        Self::new([width, height], output)
+    }
+
+    /// Clone a sub-region as a new image.
+    pub fn region_by_pixels(&self, [x, y]: [usize; 2], [w, h]: [usize; 2]) -> Self {
+        assert!(
+            x + w <= self.width(),
+            "x + w should be <= self.width(), but x: {}, w: {}, width: {}",
+            x,
+            w,
+            self.width()
+        );
+        assert!(
+            y + h <= self.height(),
+            "y + h should be <= self.height(), but y: {}, h: {}, height: {}",
+            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,
+            "pixels.len should be w * h, but got {}",
+            pixels.len()
+        );
+        Self::new([w, h], pixels)
     }
 }
 
@@ -225,7 +306,7 @@ impl std::ops::Index<(usize, usize)> for ColorImage {
     #[inline]
     fn index(&self, (x, y): (usize, usize)) -> &Color32 {
         let [w, h] = self.size;
-        assert!(x < w && y < h);
+        assert!(x < w && y < h, "x: {x}, y: {y}, w: {w}, h: {h}");
         &self.pixels[y * w + x]
     }
 }
@@ -234,7 +315,7 @@ 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);
+        assert!(x < w && y < h, "x: {x}, y: {y}, w: {w}, h: {h}");
         &mut self.pixels[y * w + x]
     }
 }
@@ -264,107 +345,58 @@ impl std::fmt::Debug for ColorImage {
 
 // ----------------------------------------------------------------------------
 
-/// 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)]
+/// How to convert font coverage values into alpha and color values.
+//
+// This whole thing is less than rigorous.
+// Ideally we should do this in a shader instead, and use different computations
+// for different text colors.
+// See https://hikogui.org/2022/10/24/the-trouble-with-anti-aliasing.html for an in-depth analysis.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct FontImage {
-    /// width, height
-    pub size: [usize; 2],
-
-    /// The coverage value.
+pub enum AlphaFromCoverage {
+    /// `alpha = coverage`.
     ///
-    /// 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.
+    /// Looks good for black-on-white text, i.e. light mode.
     ///
-    /// `gamma` should normally be set to `None`.
+    /// Same as [`Self::Gamma`]`(1.0)`, but more efficient.
+    Linear,
+
+    /// `alpha = coverage^gamma`.
+    Gamma(f32),
+
+    /// `alpha = 2 * coverage - coverage^2`
     ///
-    /// If you are having problems with text looking skinny and pixelated, try using a low gamma, e.g. `0.4`.
-    #[inline]
-    pub fn srgba_pixels(&self, gamma: Option<f32>) -> impl ExactSizeIterator<Item = Color32> + '_ {
-        // TODO(emilk): this default coverage gamma is a magic constant, chosen by eye. I don't even know why we need it.
-        // Maybe we need to implement the ideas in https://hikogui.org/2022/10/24/the-trouble-with-anti-aliasing.html
-        let gamma = gamma.unwrap_or(0.55);
-        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]) -> Self {
-        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);
-        Self {
-            size: [w, h],
-            pixels,
-        }
-    }
+    /// This looks good for white-on-black text, i.e. dark mode.
+    ///
+    /// Very similar to a gamma of 0.5, but produces sharper text.
+    /// See <https://www.desmos.com/calculator/w0ndf5blmn> for a comparison to gamma=0.5.
+    #[default]
+    TwoCoverageMinusCoverageSq,
 }
 
-impl std::ops::Index<(usize, usize)> for FontImage {
-    type Output = f32;
+impl AlphaFromCoverage {
+    /// A good-looking default for light mode (black-on-white text).
+    pub const LIGHT_MODE_DEFAULT: Self = Self::Linear;
 
-    #[inline]
-    fn index(&self, (x, y): (usize, usize)) -> &f32 {
-        let [w, h] = self.size;
-        assert!(x < w && y < h);
-        &self.pixels[y * w + x]
-    }
-}
+    /// A good-looking default for dark mode (white-on-black text).
+    pub const DARK_MODE_DEFAULT: Self = Self::TwoCoverageMinusCoverageSq;
 
-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 {
+    /// Convert coverage to alpha.
     #[inline(always)]
-    fn from(image: FontImage) -> Self {
-        Self::Font(image)
+    pub fn alpha_from_coverage(&self, coverage: f32) -> f32 {
+        let coverage = coverage.clamp(0.0, 1.0);
+        match self {
+            Self::Linear => coverage,
+            Self::Gamma(gamma) => coverage.powf(*gamma),
+            Self::TwoCoverageMinusCoverageSq => 2.0 * coverage - coverage * coverage,
+        }
     }
-}
 
-#[inline]
-fn fast_round(r: f32) -> u8 {
-    (r + 0.5) as _ // rust does a saturating cast since 1.45
+    #[inline(always)]
+    pub fn color_from_coverage(&self, coverage: f32) -> Color32 {
+        let alpha = self.alpha_from_coverage(coverage);
+        Color32::from_white_alpha(ecolor::linear_u8_from_linear_f32(alpha))
+    }
 }
 
 // ----------------------------------------------------------------------------
@@ -372,7 +404,7 @@ fn fast_round(r: f32) -> u8 {
 /// A change to an image.
 ///
 /// Either a whole new image, or an update to a rectangular region of it.
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[must_use = "The painter must take care of this"]
 pub struct ImageDelta {
diff --git a/crates/epaint/src/lib.rs b/crates/epaint/src/lib.rs
index ac0a90c60..1bf0285bd 100644
--- a/crates/epaint/src/lib.rs
+++ b/crates/epaint/src/lib.rs
@@ -2,7 +2,7 @@
 //!
 //! Made for [`egui`](https://github.com/emilk/egui/).
 //!
-//! Create some [`Shape`]:s and pass them to [`tessellate_shapes`] to generate [`Mesh`]:es
+//! Create some [`Shape`]:s and pass them to [`Tessellator::tessellate_shapes`] to generate [`Mesh`]:es
 //! that you can then paint using some graphics API of your choice (e.g. OpenGL).
 //!
 //! ## Coordinate system
@@ -29,7 +29,7 @@ mod corner_radius;
 mod corner_radius_f32;
 pub mod image;
 mod margin;
-mod marginf;
+mod margin_f32;
 mod mesh;
 pub mod mutex;
 mod shadow;
@@ -50,9 +50,9 @@ pub use self::{
     color::ColorMode,
     corner_radius::CornerRadius,
     corner_radius_f32::CornerRadiusF32,
-    image::{ColorImage, FontImage, ImageData, ImageDelta},
+    image::{AlphaFromCoverage, ColorImage, ImageData, ImageDelta},
     margin::Margin,
-    marginf::Marginf,
+    margin_f32::*,
     mesh::{Mesh, Mesh16, Vertex},
     shadow::Shadow,
     shapes::{
@@ -62,7 +62,7 @@ pub use self::{
     stats::PaintStats,
     stroke::{PathStroke, Stroke, StrokeKind},
     tessellator::{TessellationOptions, Tessellator},
-    text::{FontFamily, FontId, Fonts, Galley},
+    text::{FontFamily, FontId, Fonts, FontsView, Galley},
     texture_atlas::TextureAtlas,
     texture_handle::TextureHandle,
     textures::TextureManager,
@@ -72,11 +72,8 @@ pub use self::{
 #[deprecated = "Renamed to CornerRadius"]
 pub type Rounding = CornerRadius;
 
-#[allow(deprecated)]
-pub use tessellator::tessellate_shapes;
-
 pub use ecolor::{Color32, Hsva, HsvaGamma, Rgba};
-pub use emath::{pos2, vec2, Pos2, Rect, Vec2};
+pub use emath::{Pos2, Rect, Vec2, pos2, vec2};
 
 #[deprecated = "Use the ahash crate directly."]
 pub use ahash;
@@ -130,6 +127,18 @@ pub struct ClippedShape {
     pub shape: Shape,
 }
 
+impl ClippedShape {
+    /// Transform (move/scale) the shape in-place.
+    ///
+    /// If using a [`PaintCallback`], note that only the rect is scaled as opposed
+    /// to other shapes where the stroke is also scaled.
+    pub fn transform(&mut self, transform: emath::TSTransform) {
+        let Self { clip_rect, shape } = self;
+        *clip_rect = transform * *clip_rect;
+        shape.transform(transform);
+    }
+}
+
 /// A [`Mesh`] or [`PaintCallback`] within a clip rectangle.
 ///
 /// Everything is using logical points.
diff --git a/crates/epaint/src/margin.rs b/crates/epaint/src/margin.rs
index e8fc530aa..e6f6d2287 100644
--- a/crates/epaint/src/margin.rs
+++ b/crates/epaint/src/margin.rs
@@ -1,4 +1,4 @@
-use emath::{vec2, Rect, Vec2};
+use emath::{Rect, Vec2, vec2};
 
 /// A value for all four sides of a rectangle,
 /// often used to express padding or spacing.
@@ -9,7 +9,7 @@ use emath::{vec2, Rect, Vec2};
 /// Use with care.
 ///
 /// All values are stored as [`i8`] to keep the size of [`Margin`] small.
-/// If you want floats, use [`crate::Marginf`] instead.
+/// If you want floats, use [`crate::MarginF32`] instead.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Margin {
@@ -96,18 +96,6 @@ impl Margin {
     pub const fn is_same(self) -> bool {
         self.left == self.right && self.left == self.top && self.left == self.bottom
     }
-
-    #[deprecated = "Use `rect + margin` instead"]
-    #[inline]
-    pub fn expand_rect(self, rect: Rect) -> Rect {
-        Rect::from_min_max(rect.min - self.left_top(), rect.max + self.right_bottom())
-    }
-
-    #[deprecated = "Use `rect - margin` instead"]
-    #[inline]
-    pub fn shrink_rect(self, rect: Rect) -> Rect {
-        Rect::from_min_max(rect.min + self.left_top(), rect.max - self.right_bottom())
-    }
 }
 
 impl From<i8> for Margin {
diff --git a/crates/epaint/src/marginf.rs b/crates/epaint/src/margin_f32.rs
similarity index 79%
rename from crates/epaint/src/marginf.rs
rename to crates/epaint/src/margin_f32.rs
index eb3a1fbc9..22bc8b3d4 100644
--- a/crates/epaint/src/marginf.rs
+++ b/crates/epaint/src/margin_f32.rs
@@ -1,4 +1,4 @@
-use emath::{vec2, Rect, Vec2};
+use emath::{Rect, Vec2, vec2};
 
 use crate::Margin;
 
@@ -10,14 +10,17 @@ use crate::Margin;
 /// For storage, use [`crate::Margin`] instead.
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct Marginf {
+pub struct MarginF32 {
     pub left: f32,
     pub right: f32,
     pub top: f32,
     pub bottom: f32,
 }
 
-impl From<Margin> for Marginf {
+#[deprecated = "Renamed to MarginF32"]
+pub type Marginf = MarginF32;
+
+impl From<Margin> for MarginF32 {
     #[inline]
     fn from(margin: Margin) -> Self {
         Self {
@@ -29,9 +32,9 @@ impl From<Margin> for Marginf {
     }
 }
 
-impl From<Marginf> for Margin {
+impl From<MarginF32> for Margin {
     #[inline]
-    fn from(marginf: Marginf) -> Self {
+    fn from(marginf: MarginF32) -> Self {
         Self {
             left: marginf.left as _,
             right: marginf.right as _,
@@ -41,7 +44,7 @@ impl From<Marginf> for Margin {
     }
 }
 
-impl Marginf {
+impl MarginF32 {
     pub const ZERO: Self = Self {
         left: 0.0,
         right: 0.0,
@@ -108,22 +111,22 @@ impl Marginf {
     }
 }
 
-impl From<f32> for Marginf {
+impl From<f32> for MarginF32 {
     #[inline]
     fn from(v: f32) -> Self {
         Self::same(v)
     }
 }
 
-impl From<Vec2> for Marginf {
+impl From<Vec2> for MarginF32 {
     #[inline]
     fn from(v: Vec2) -> Self {
         Self::symmetric(v.x, v.y)
     }
 }
 
-/// `Marginf + Marginf`
-impl std::ops::Add for Marginf {
+/// `MarginF32 + MarginF32`
+impl std::ops::Add for MarginF32 {
     type Output = Self;
 
     #[inline]
@@ -137,8 +140,8 @@ impl std::ops::Add for Marginf {
     }
 }
 
-/// `Marginf + f32`
-impl std::ops::Add<f32> for Marginf {
+/// `MarginF32 + f32`
+impl std::ops::Add<f32> for MarginF32 {
     type Output = Self;
 
     #[inline]
@@ -153,7 +156,7 @@ impl std::ops::Add<f32> for Marginf {
 }
 
 /// `Margind += f32`
-impl std::ops::AddAssign<f32> for Marginf {
+impl std::ops::AddAssign<f32> for MarginF32 {
     #[inline]
     fn add_assign(&mut self, v: f32) {
         self.left += v;
@@ -163,8 +166,8 @@ impl std::ops::AddAssign<f32> for Marginf {
     }
 }
 
-/// `Marginf * f32`
-impl std::ops::Mul<f32> for Marginf {
+/// `MarginF32 * f32`
+impl std::ops::Mul<f32> for MarginF32 {
     type Output = Self;
 
     #[inline]
@@ -178,8 +181,8 @@ impl std::ops::Mul<f32> for Marginf {
     }
 }
 
-/// `Marginf *= f32`
-impl std::ops::MulAssign<f32> for Marginf {
+/// `MarginF32 *= f32`
+impl std::ops::MulAssign<f32> for MarginF32 {
     #[inline]
     fn mul_assign(&mut self, v: f32) {
         self.left *= v;
@@ -189,8 +192,8 @@ impl std::ops::MulAssign<f32> for Marginf {
     }
 }
 
-/// `Marginf / f32`
-impl std::ops::Div<f32> for Marginf {
+/// `MarginF32 / f32`
+impl std::ops::Div<f32> for MarginF32 {
     type Output = Self;
 
     #[inline]
@@ -204,8 +207,8 @@ impl std::ops::Div<f32> for Marginf {
     }
 }
 
-/// `Marginf /= f32`
-impl std::ops::DivAssign<f32> for Marginf {
+/// `MarginF32 /= f32`
+impl std::ops::DivAssign<f32> for MarginF32 {
     #[inline]
     fn div_assign(&mut self, v: f32) {
         self.left /= v;
@@ -215,8 +218,8 @@ impl std::ops::DivAssign<f32> for Marginf {
     }
 }
 
-/// `Marginf - Marginf`
-impl std::ops::Sub for Marginf {
+/// `MarginF32 - MarginF32`
+impl std::ops::Sub for MarginF32 {
     type Output = Self;
 
     #[inline]
@@ -230,8 +233,8 @@ impl std::ops::Sub for Marginf {
     }
 }
 
-/// `Marginf - f32`
-impl std::ops::Sub<f32> for Marginf {
+/// `MarginF32 - f32`
+impl std::ops::Sub<f32> for MarginF32 {
     type Output = Self;
 
     #[inline]
@@ -245,8 +248,8 @@ impl std::ops::Sub<f32> for Marginf {
     }
 }
 
-/// `Marginf -= f32`
-impl std::ops::SubAssign<f32> for Marginf {
+/// `MarginF32 -= f32`
+impl std::ops::SubAssign<f32> for MarginF32 {
     #[inline]
     fn sub_assign(&mut self, v: f32) {
         self.left -= v;
@@ -256,12 +259,12 @@ impl std::ops::SubAssign<f32> for Marginf {
     }
 }
 
-/// `Rect + Marginf`
-impl std::ops::Add<Marginf> for Rect {
+/// `Rect + MarginF32`
+impl std::ops::Add<MarginF32> for Rect {
     type Output = Self;
 
     #[inline]
-    fn add(self, margin: Marginf) -> Self {
+    fn add(self, margin: MarginF32) -> Self {
         Self::from_min_max(
             self.min - margin.left_top(),
             self.max + margin.right_bottom(),
@@ -269,20 +272,20 @@ impl std::ops::Add<Marginf> for Rect {
     }
 }
 
-/// `Rect += Marginf`
-impl std::ops::AddAssign<Marginf> for Rect {
+/// `Rect += MarginF32`
+impl std::ops::AddAssign<MarginF32> for Rect {
     #[inline]
-    fn add_assign(&mut self, margin: Marginf) {
+    fn add_assign(&mut self, margin: MarginF32) {
         *self = *self + margin;
     }
 }
 
-/// `Rect - Marginf`
-impl std::ops::Sub<Marginf> for Rect {
+/// `Rect - MarginF32`
+impl std::ops::Sub<MarginF32> for Rect {
     type Output = Self;
 
     #[inline]
-    fn sub(self, margin: Marginf) -> Self {
+    fn sub(self, margin: MarginF32) -> Self {
         Self::from_min_max(
             self.min + margin.left_top(),
             self.max - margin.right_bottom(),
@@ -290,10 +293,10 @@ impl std::ops::Sub<Marginf> for Rect {
     }
 }
 
-/// `Rect -= Marginf`
-impl std::ops::SubAssign<Marginf> for Rect {
+/// `Rect -= MarginF32`
+impl std::ops::SubAssign<MarginF32> for Rect {
     #[inline]
-    fn sub_assign(&mut self, margin: Marginf) {
+    fn sub_assign(&mut self, margin: MarginF32) {
         *self = *self - margin;
     }
 }
diff --git a/crates/epaint/src/mesh.rs b/crates/epaint/src/mesh.rs
index 930cb7716..8a0a39495 100644
--- a/crates/epaint/src/mesh.rs
+++ b/crates/epaint/src/mesh.rs
@@ -1,4 +1,4 @@
-use crate::{emath, Color32, TextureId, WHITE_UV};
+use crate::{Color32, TextureId, WHITE_UV, emath};
 use emath::{Pos2, Rect, Rot2, TSTransform, Vec2};
 
 /// The 2D vertex type.
@@ -119,7 +119,7 @@ impl Mesh {
     /// Panics when `other` mesh has a different texture.
     pub fn append(&mut self, other: Self) {
         profiling::function_scope!();
-        debug_assert!(other.is_valid());
+        debug_assert!(other.is_valid(), "Other mesh is invalid");
 
         if self.is_empty() {
             *self = other;
@@ -133,7 +133,7 @@ impl Mesh {
     ///
     /// Panics when `other` mesh has a different texture.
     pub fn append_ref(&mut self, other: &Self) {
-        debug_assert!(other.is_valid());
+        debug_assert!(other.is_valid(), "Other mesh is invalid");
 
         if self.is_empty() {
             self.texture_id = other.texture_id;
@@ -155,7 +155,10 @@ impl Mesh {
     /// Panics when the mesh has assigned a texture.
     #[inline(always)]
     pub fn colored_vertex(&mut self, pos: Pos2, color: Color32) {
-        debug_assert!(self.texture_id == TextureId::default());
+        debug_assert!(
+            self.texture_id == TextureId::default(),
+            "Mesh has an assigned texture"
+        );
         self.vertices.push(Vertex {
             pos,
             uv: WHITE_UV,
@@ -166,9 +169,7 @@ impl Mesh {
     /// 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);
+        self.indices.extend_from_slice(&[a, b, c]);
     }
 
     /// Make room for this many additional triangles (will reserve 3x as many indices).
@@ -186,39 +187,44 @@ impl Mesh {
     }
 
     /// Rectangle with a texture and color.
+    #[inline(always)]
     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.indices
+            .extend_from_slice(&[idx + 0, idx + 1, idx + 2, 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,
-        });
+        self.vertices.extend_from_slice(&[
+            Vertex {
+                pos: rect.left_top(),
+                uv: uv.left_top(),
+                color,
+            },
+            Vertex {
+                pos: rect.right_top(),
+                uv: uv.right_top(),
+                color,
+            },
+            Vertex {
+                pos: rect.left_bottom(),
+                uv: uv.left_bottom(),
+                color,
+            },
+            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) {
-        debug_assert!(self.texture_id == TextureId::default());
+        debug_assert!(
+            self.texture_id == TextureId::default(),
+            "Mesh has an assigned texture"
+        );
         self.add_rect_with_uv(rect, [WHITE_UV, WHITE_UV].into(), color);
     }
 
@@ -227,7 +233,7 @@ impl Mesh {
     /// 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> {
-        debug_assert!(self.is_valid());
+        debug_assert!(self.is_valid(), "Mesh is invalid");
 
         const MAX_SIZE: u32 = u16::MAX as u32;
 
@@ -280,7 +286,7 @@ impl Mesh {
                 vertices: self.vertices[(min_vindex as usize)..=(max_vindex as usize)].to_vec(),
                 texture_id: self.texture_id,
             };
-            debug_assert!(mesh.is_valid());
+            debug_assert!(mesh.is_valid(), "Mesh is invalid");
             output.push(mesh);
         }
         output
diff --git a/crates/epaint/src/mutex.rs b/crates/epaint/src/mutex.rs
index 465722c17..2f264f58c 100644
--- a/crates/epaint/src/mutex.rs
+++ b/crates/epaint/src/mutex.rs
@@ -1,368 +1,117 @@
-//! Helper module that adds extra checks when the `deadlock_detection` feature is turned on.
+//! Wrappers around `parking_lot` locks, with a simple deadlock detection mechanism.
 
 // ----------------------------------------------------------------------------
 
-#[cfg(not(feature = "deadlock_detection"))]
-mod mutex_impl {
-    /// Provides interior mutability.
+const DEADLOCK_DURATION: std::time::Duration = std::time::Duration::from_secs(10);
+
+/// Provides interior mutability.
+///
+/// It's tailored for internal use in egui should only be used for short locks (as a guideline,
+/// locks should never be held longer than a single frame). In debug builds, when a lock can't
+/// be acquired within 10 seconds, we assume a deadlock and will panic.
+///
+/// This is a thin wrapper around [`parking_lot::Mutex`].
+#[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))
+    }
+
+    /// Try to acquire the lock.
     ///
-    /// This is a thin wrapper around [`parking_lot::Mutex`], except if
-    /// the feature `deadlock_detection` is turned enabled, in which case
-    /// extra checks are added to detect deadlocks.
-    #[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> {
+    /// ## Panics
+    /// Will panic in debug builds if the lock can't be acquired within 10 seconds.
+    #[inline(always)]
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn lock(&self) -> MutexGuard<'_, T> {
+        if cfg!(debug_assertions) {
+            self.0.try_lock_for(DEADLOCK_DURATION).unwrap_or_else(|| {
+                panic!(
+                    "DEBUG PANIC: Failed to acquire Mutex after {}s. Deadlock?",
+                    DEADLOCK_DURATION.as_secs()
+                )
+            })
+        } else {
             self.0.lock()
         }
     }
 }
 
-#[cfg(feature = "deadlock_detection")]
-mod mutex_impl {
-    /// Provides interior mutability.
-    ///
-    /// This is a thin wrapper around [`parking_lot::Mutex`], except if
-    /// the feature `deadlock_detection` is turned enabled, in which case
-    /// extra checks are added to detect deadlocks.
-    #[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 = std::ptr::from_ref::<parking_lot::Mutex<_>>(&self.0).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)
-        }
-
-        #[inline(always)]
-        pub fn into_inner(self) -> T {
-            self.0.into_inner()
-        }
-    }
-
-    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(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::read`].
+pub use parking_lot::MappedRwLockReadGuard as RwLockReadGuard;
 
-    /// The lock you get from [`RwLock::write`].
-    pub use parking_lot::MappedRwLockWriteGuard as RwLockWriteGuard;
+/// The lock you get from [`RwLock::write`].
+pub use parking_lot::MappedRwLockWriteGuard as RwLockWriteGuard;
 
-    /// Provides interior mutability.
-    ///
-    /// This is a thin wrapper around [`parking_lot::RwLock`], except if
-    /// the feature `deadlock_detection` is turned enabled, in which case
-    /// extra checks are added to detect deadlocks.
-    #[derive(Default)]
-    pub struct RwLock<T: ?Sized>(parking_lot::RwLock<T>);
+/// Provides interior mutability.
+///
+/// It's tailored for internal use in egui should only be used for short locks (as a guideline,
+/// locks should never be held longer than a single frame). In debug builds, when a lock can't
+/// be acquired within 10 seconds, we assume a deadlock and will panic.
+///
+/// This is a thin wrapper around [`parking_lot::RwLock`].
+#[derive(Default)]
+pub struct RwLock<T: ?Sized>(parking_lot::RwLock<T>);
 
-    impl<T> RwLock<T> {
-        #[inline(always)]
-        pub fn new(val: T) -> Self {
-            Self(parking_lot::RwLock::new(val))
-        }
-    }
-
-    impl<T: ?Sized> RwLock<T> {
-        #[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)
-        }
+impl<T> RwLock<T> {
+    #[inline(always)]
+    pub fn new(val: T) -> Self {
+        Self(parking_lot::RwLock::new(val))
     }
 }
 
-#[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<T> Deref for RwLockReadGuard<'_, T> {
-        type Target = T;
-
-        fn deref(&self) -> &Self::Target {
-            self.guard.as_ref().unwrap()
-        }
-    }
-
-    impl<T> Drop for RwLockReadGuard<'_, 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<T> Deref for RwLockWriteGuard<'_, T> {
-        type Target = T;
-
-        fn deref(&self) -> &Self::Target {
-            self.guard.as_ref().unwrap()
-        }
-    }
-
-    impl<T> DerefMut for RwLockWriteGuard<'_, T> {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            self.guard.as_mut().unwrap()
-        }
-    }
-
-    impl<T> Drop for RwLockWriteGuard<'_, T> {
-        fn drop(&mut self) {
-            let tid = std::thread::current().id();
-            self.holders.lock().remove(&tid);
-        }
-    }
-
-    /// Provides interior mutability.
+impl<T: ?Sized> RwLock<T> {
+    /// Try to acquire read-access to the lock.
     ///
-    /// This is a thin wrapper around [`parking_lot::RwLock`], except if
-    /// the feature `deadlock_detection` is turned enabled, in which case
-    /// extra checks are added to detect deadlocks.
-    #[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),
-            }
-        }
-
-        #[inline(always)]
-        pub fn into_inner(self) -> T {
-            self.lock.into_inner()
-        }
-    }
-
-    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()
+    /// ## Panics
+    /// Will panic in debug builds if the lock can't be acquired within 10 seconds.
+    #[inline(always)]
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn read(&self) -> RwLockReadGuard<'_, T> {
+        let guard = if cfg!(debug_assertions) {
+            self.0.try_read_for(DEADLOCK_DURATION).unwrap_or_else(|| {
+                panic!(
+                    "DEBUG PANIC: Failed to acquire RwLock read after {}s. Deadlock?",
+                    DEADLOCK_DURATION.as_secs()
+                )
+            })
         } else {
-            stacktrace.to_owned()
-        }
+            self.0.read()
+        };
+        parking_lot::RwLockReadGuard::map(guard, |v| v)
+    }
+
+    /// Try to acquire write-access to the lock.
+    ///
+    /// ## Panics
+    /// Will panic in debug builds if the lock can't be acquired within 10 seconds.
+    #[inline(always)]
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+        let guard = if cfg!(debug_assertions) {
+            self.0.try_write_for(DEADLOCK_DURATION).unwrap_or_else(|| {
+                panic!(
+                    "DEBUG PANIC: Failed to acquire RwLock write after {}s. Deadlock?",
+                    DEADLOCK_DURATION.as_secs()
+                )
+            })
+        } else {
+            self.0.write()
+        };
+        parking_lot::RwLockWriteGuard::map(guard, |v| v)
     }
 }
 
 // ----------------------------------------------------------------------------
 
-pub use mutex_impl::{Mutex, MutexGuard};
-pub use rw_lock_impl::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-
 impl<T> Clone for Mutex<T>
 where
     T: Clone,
@@ -407,7 +156,6 @@ mod tests {
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(feature = "deadlock_detection")]
 #[cfg(test)]
 mod tests_rwlock {
     #![allow(clippy::disallowed_methods)] // Ok for tests
diff --git a/crates/epaint/src/shadow.rs b/crates/epaint/src/shadow.rs
index e05cbdbe4..ace5ab90a 100644
--- a/crates/epaint/src/shadow.rs
+++ b/crates/epaint/src/shadow.rs
@@ -1,4 +1,4 @@
-use crate::{Color32, CornerRadius, Marginf, Rect, RectShape, Vec2};
+use crate::{Color32, CornerRadius, MarginF32, Rect, RectShape, Vec2};
 
 /// The color and fuzziness of a fuzzy shape.
 ///
@@ -29,7 +29,8 @@ pub struct Shadow {
 #[test]
 fn shadow_size() {
     assert_eq!(
-        std::mem::size_of::<Shadow>(), 8,
+        std::mem::size_of::<Shadow>(),
+        8,
         "Shadow changed size! If it shrank - good! Update this test. If it grew - bad! Try to find a way to avoid it."
     );
 }
@@ -64,7 +65,7 @@ impl Shadow {
     }
 
     /// How much larger than the parent rect are we in each direction?
-    pub fn margin(&self) -> Marginf {
+    pub fn margin(&self) -> MarginF32 {
         let Self {
             offset,
             blur,
@@ -74,7 +75,7 @@ impl Shadow {
         let spread = spread as f32;
         let blur = blur as f32;
         let [offset_x, offset_y] = offset;
-        Marginf {
+        MarginF32 {
             left: spread + 0.5 * blur - offset_x as f32,
             right: spread + 0.5 * blur + offset_x as f32,
             top: spread + 0.5 * blur - offset_y as f32,
diff --git a/crates/epaint/src/shape_transform.rs b/crates/epaint/src/shape_transform.rs
index 469f2e521..4b68d5964 100644
--- a/crates/epaint/src/shape_transform.rs
+++ b/crates/epaint/src/shape_transform.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use crate::{
-    color, CircleShape, Color32, ColorMode, CubicBezierShape, EllipseShape, Mesh, PathShape,
-    QuadraticBezierShape, RectShape, Shape, TextShape,
+    CircleShape, Color32, ColorMode, CubicBezierShape, EllipseShape, Mesh, PathShape,
+    QuadraticBezierShape, RectShape, Shape, TextShape, color,
 };
 
 /// Remember to handle [`Color32::PLACEHOLDER`] specially!
@@ -89,7 +89,8 @@ pub fn adjust_colors(
 
             if !galley.is_empty() {
                 let galley = Arc::make_mut(galley);
-                for row in &mut galley.rows {
+                for placed_row in &mut galley.rows {
+                    let row = Arc::make_mut(&mut placed_row.row);
                     for vertex in &mut row.visuals.mesh.vertices {
                         adjust_color(&mut vertex.color);
                     }
diff --git a/crates/epaint/src/shapes/bezier_shape.rs b/crates/epaint/src/shapes/bezier_shape.rs
index 7d291c7fd..20f7a4e18 100644
--- a/crates/epaint/src/shapes/bezier_shape.rs
+++ b/crates/epaint/src/shapes/bezier_shape.rs
@@ -253,8 +253,8 @@ impl CubicBezierShape {
         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 r = (-(p / 3.0).powi(3)).sqrt();
+        let theta = (-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;
@@ -613,6 +613,8 @@ struct FlatteningParameters {
 impl FlatteningParameters {
     // https://raphlinus.github.io/graphics/curves/2019/12/23/flatten-quadbez.html
     pub fn from_curve(curve: &QuadraticBezierShape, tolerance: f32) -> Self {
+        #![expect(clippy::useless_let_if_seq)]
+
         // Map the quadratic bézier segment to y = x^2 parabola.
         let from = curve.points[0];
         let ctrl = curve.points[1];
diff --git a/crates/epaint/src/shapes/rect_shape.rs b/crates/epaint/src/shapes/rect_shape.rs
index ead5b7af2..2e855d369 100644
--- a/crates/epaint/src/shapes/rect_shape.rs
+++ b/crates/epaint/src/shapes/rect_shape.rs
@@ -59,7 +59,8 @@ pub struct RectShape {
 #[test]
 fn rect_shape_size() {
     assert_eq!(
-        std::mem::size_of::<RectShape>(), 48,
+        std::mem::size_of::<RectShape>(),
+        48,
         "RectShape changed size! If it shrank - good! Update this test. If it grew - bad! Try to find a way to avoid it."
     );
     assert!(
diff --git a/crates/epaint/src/shapes/shape.rs b/crates/epaint/src/shapes/shape.rs
index 6c24881de..8ee852c61 100644
--- a/crates/epaint/src/shapes/shape.rs
+++ b/crates/epaint/src/shapes/shape.rs
@@ -2,12 +2,12 @@
 
 use std::sync::Arc;
 
-use emath::{pos2, Align2, Pos2, Rangef, Rect, TSTransform, Vec2};
+use emath::{Align2, Pos2, Rangef, Rect, TSTransform, Vec2, pos2};
 
 use crate::{
-    stroke::PathStroke,
-    text::{FontId, Fonts, Galley},
     Color32, CornerRadius, Mesh, Stroke, StrokeKind, TextureId,
+    stroke::PathStroke,
+    text::{FontId, FontsView, Galley},
 };
 
 use super::{
@@ -73,7 +73,8 @@ pub enum Shape {
 #[test]
 fn shape_size() {
     assert_eq!(
-        std::mem::size_of::<Shape>(), 64,
+        std::mem::size_of::<Shape>(),
+        64,
         "Shape changed size! If it shrank - good! Update this test. If it grew - bad! Try to find a way to avoid it."
     );
     assert!(
@@ -296,9 +297,9 @@ impl Shape {
         Self::Rect(RectShape::stroke(rect, corner_radius, stroke, stroke_kind))
     }
 
-    #[allow(clippy::needless_pass_by_value)]
+    #[expect(clippy::needless_pass_by_value)]
     pub fn text(
-        fonts: &Fonts,
+        fonts: &mut FontsView<'_>,
         pos: Pos2,
         anchor: Align2,
         text: impl ToString,
@@ -339,7 +340,7 @@ impl Shape {
     #[inline]
     pub fn mesh(mesh: impl Into<Arc<Mesh>>) -> Self {
         let mesh = mesh.into();
-        debug_assert!(mesh.is_valid());
+        debug_assert!(mesh.is_valid(), "Invalid mesh: {mesh:#?}");
         Self::Mesh(mesh)
     }
 
@@ -362,7 +363,7 @@ impl Shape {
             Self::Vec(shapes) => {
                 let mut rect = Rect::NOTHING;
                 for shape in shapes {
-                    rect = rect.union(shape.visual_bounding_rect());
+                    rect |= shape.visual_bounding_rect();
                 }
                 rect
             }
@@ -415,7 +416,7 @@ impl Shape {
         self.transform(TSTransform::from_translation(delta));
     }
 
-    /// Move the shape by this many points, in-place.
+    /// Transform (move/scale) the shape in-place.
     ///
     /// If using a [`PaintCallback`], note that only the rect is scaled as opposed
     /// to other shapes where the stroke is also scaled.
@@ -456,19 +457,7 @@ impl Shape {
                 rect_shape.blur_width *= transform.scaling;
             }
             Self::Text(text_shape) => {
-                text_shape.pos = transform * text_shape.pos;
-
-                // Scale text:
-                let galley = Arc::make_mut(&mut text_shape.galley);
-                for row in &mut galley.rows {
-                    row.visuals.mesh_bounds = transform.scaling * row.visuals.mesh_bounds;
-                    for v in &mut row.visuals.mesh.vertices {
-                        v.pos = Pos2::new(transform.scaling * v.pos.x, transform.scaling * v.pos.y);
-                    }
-                }
-
-                galley.mesh_bounds = transform.scaling * galley.mesh_bounds;
-                galley.rect = transform.scaling * galley.rect;
+                text_shape.transform(transform);
             }
             Self::Mesh(mesh) => {
                 Arc::make_mut(mesh).transform(transform);
@@ -525,7 +514,13 @@ fn dashes_from_line(
     shapes: &mut Vec<Shape>,
     dash_offset: f32,
 ) {
-    assert_eq!(dash_lengths.len(), gap_lengths.len());
+    assert_eq!(
+        dash_lengths.len(),
+        gap_lengths.len(),
+        "Mismatched dash and gap lengths, got dash_lengths: {}, gap_lengths: {}",
+        dash_lengths.len(),
+        gap_lengths.len()
+    );
     let mut position_on_segment = dash_offset;
     let mut drawing_dash = false;
     let mut step = 0;
diff --git a/crates/epaint/src/shapes/text_shape.rs b/crates/epaint/src/shapes/text_shape.rs
index 30287187f..92a0a0514 100644
--- a/crates/epaint/src/shapes/text_shape.rs
+++ b/crates/epaint/src/shapes/text_shape.rs
@@ -1,5 +1,7 @@
 use std::sync::Arc;
 
+use emath::{Align2, Rot2};
+
 use crate::*;
 
 /// How to paint some text on screen.
@@ -8,10 +10,12 @@ use crate::*;
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct TextShape {
-    /// Top left corner of the first character.
+    /// Where the origin of [`Self::galley`] is.
+    ///
+    /// Usually the top left corner of the first character.
     pub pos: Pos2,
 
-    /// The laid out text, from [`Fonts::layout_job`].
+    /// The laid out text, from [`FontsView::layout_job`].
     pub galley: Arc<Galley>,
 
     /// Add this underline to the whole text.
@@ -57,7 +61,10 @@ impl TextShape {
     /// The visual bounding rectangle
     #[inline]
     pub fn visual_bounding_rect(&self) -> Rect {
-        self.galley.mesh_bounds.translate(self.pos.to_vec2())
+        self.galley
+            .mesh_bounds
+            .rotate_bb(emath::Rot2::from_angle(self.angle))
+            .translate(self.pos.to_vec2())
     }
 
     #[inline]
@@ -73,7 +80,7 @@ impl TextShape {
         self
     }
 
-    /// Rotate text by this many radians clockwise.
+    /// Set text rotation to `angle` radians clockwise.
     /// The pivot is `pos` (the upper left corner of the text).
     #[inline]
     pub fn with_angle(mut self, angle: f32) -> Self {
@@ -81,12 +88,86 @@ impl TextShape {
         self
     }
 
+    /// Set the text rotation to the `angle` radians clockwise.
+    /// The pivot is determined by the given `anchor` point on the text bounding box.
+    #[inline]
+    pub fn with_angle_and_anchor(mut self, angle: f32, anchor: Align2) -> Self {
+        self.angle = angle;
+        let a0 = anchor.pos_in_rect(&self.galley.rect).to_vec2();
+        let a1 = Rot2::from_angle(angle) * a0;
+        self.pos += a0 - a1;
+        self
+    }
+
     /// Render text with this opacity in gamma space
     #[inline]
     pub fn with_opacity_factor(mut self, opacity_factor: f32) -> Self {
         self.opacity_factor = opacity_factor;
         self
     }
+
+    /// Move the shape by this many points, in-place.
+    pub fn transform(&mut self, transform: emath::TSTransform) {
+        let Self {
+            pos,
+            galley,
+            underline,
+            fallback_color: _,
+            override_text_color: _,
+            opacity_factor: _,
+            angle: _,
+        } = self;
+
+        *pos = transform * *pos;
+        underline.width *= transform.scaling;
+
+        let Galley {
+            job: _,
+            rows,
+            elided: _,
+            rect,
+            mesh_bounds,
+            num_vertices: _,
+            num_indices: _,
+            pixels_per_point: _,
+            intrinsic_size,
+        } = Arc::make_mut(galley);
+
+        *rect = transform.scaling * *rect;
+        *mesh_bounds = transform.scaling * *mesh_bounds;
+        *intrinsic_size = transform.scaling * *intrinsic_size;
+
+        for text::PlacedRow {
+            pos,
+            row,
+            ends_with_newline: _,
+        } in rows
+        {
+            *pos *= transform.scaling;
+
+            let text::Row {
+                section_index_at_start: _,
+                glyphs: _, // TODO(emilk): would it make sense to transform these?
+                size,
+                visuals,
+            } = Arc::make_mut(row);
+
+            *size *= transform.scaling;
+
+            let text::RowVisuals {
+                mesh,
+                mesh_bounds,
+                glyph_index_start: _,
+                glyph_vertex_range: _,
+            } = visuals;
+
+            *mesh_bounds = transform.scaling * *mesh_bounds;
+
+            for v in &mut mesh.vertices {
+                v.pos *= transform.scaling;
+            }
+        }
+    }
 }
 
 impl From<TextShape> for Shape {
@@ -95,3 +176,42 @@ impl From<TextShape> for Shape {
         Self::Text(shape)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{super::*, *};
+    use crate::text::FontDefinitions;
+    use emath::almost_equal;
+
+    #[test]
+    fn text_bounding_box_under_rotation() {
+        let mut fonts = Fonts::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
+        let font = FontId::monospace(12.0);
+
+        let mut t = crate::Shape::text(
+            &mut fonts.with_pixels_per_point(1.0),
+            Pos2::ZERO,
+            emath::Align2::CENTER_CENTER,
+            "testing123",
+            font,
+            Color32::BLACK,
+        );
+
+        let size_orig = t.visual_bounding_rect().size();
+
+        // 90 degree rotation
+        if let Shape::Text(ts) = &mut t {
+            ts.angle = std::f32::consts::PI / 2.0;
+        }
+
+        let size_rot = t.visual_bounding_rect().size();
+
+        // make sure the box is actually rotated
+        assert!(almost_equal(size_orig.x, size_rot.y, 1e-4));
+        assert!(almost_equal(size_orig.y, size_rot.x, 1e-4));
+    }
+}
diff --git a/crates/epaint/src/stats.rs b/crates/epaint/src/stats.rs
index 68bba622e..1eef4f444 100644
--- a/crates/epaint/src/stats.rs
+++ b/crates/epaint/src/stats.rs
@@ -3,19 +3,14 @@
 use crate::{ClippedShape, Galley, Mesh, Primitive, Shape};
 
 /// Size of the elements in a vector/array.
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, Default, PartialEq)]
 enum ElementSize {
+    #[default]
     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 {
@@ -91,7 +86,7 @@ impl AllocInfo {
             + galley.rows.iter().map(Self::from_galley_row).sum()
     }
 
-    fn from_galley_row(row: &crate::text::Row) -> Self {
+    fn from_galley_row(row: &crate::text::PlacedRow) -> Self {
         Self::from_mesh(&row.visuals.mesh) + Self::from_slice(&row.glyphs)
     }
 
@@ -111,7 +106,10 @@ impl AllocInfo {
     }
 
     pub fn num_elements(&self) -> usize {
-        assert!(self.element_size != ElementSize::Heterogenous);
+        assert!(
+            self.element_size != ElementSize::Heterogenous,
+            "Heterogenous element size"
+        );
         self.num_elements
     }
 
diff --git a/crates/epaint/src/stroke.rs b/crates/epaint/src/stroke.rs
index 5d82c1963..473376f40 100644
--- a/crates/epaint/src/stroke.rs
+++ b/crates/epaint/src/stroke.rs
@@ -2,7 +2,9 @@
 
 use std::{fmt::Debug, sync::Arc};
 
-use super::{emath, Color32, ColorMode, Pos2, Rect};
+use emath::GuiRounding as _;
+
+use super::{Color32, ColorMode, Pos2, Rect, emath};
 
 /// Describes the width and color of a line.
 ///
@@ -34,6 +36,46 @@ impl Stroke {
     pub fn is_empty(&self) -> bool {
         self.width <= 0.0 || self.color == Color32::TRANSPARENT
     }
+
+    /// For vertical or horizontal lines:
+    /// round the stroke center to produce a sharp, pixel-aligned line.
+    pub fn round_center_to_pixel(&self, pixels_per_point: f32, coord: &mut f32) {
+        // If the stroke is an odd number of pixels wide,
+        // we want to round the center of it to the center of a pixel.
+        //
+        // If however it is an even number of pixels wide,
+        // we want to round the center to be between two pixels.
+        //
+        // We also want to treat strokes that are _almost_ odd as it it was odd,
+        // to make it symmetric. Same for strokes that are _almost_ even.
+        //
+        // For strokes less than a pixel wide we also round to the center,
+        // because it will rendered as a single row of pixels by the tessellator.
+
+        let pixel_size = 1.0 / pixels_per_point;
+
+        if self.width <= pixel_size || is_nearest_integer_odd(pixels_per_point * self.width) {
+            *coord = coord.round_to_pixel_center(pixels_per_point);
+        } else {
+            *coord = coord.round_to_pixels(pixels_per_point);
+        }
+    }
+
+    pub(crate) fn round_rect_to_pixel(&self, pixels_per_point: f32, rect: &mut Rect) {
+        // We put odd-width strokes in the center of pixels.
+        // To understand why, see `fn round_center_to_pixel`.
+
+        let pixel_size = 1.0 / pixels_per_point;
+
+        let width = self.width;
+        if width <= 0.0 {
+            *rect = rect.round_to_pixels(pixels_per_point);
+        } else if width <= pixel_size || is_nearest_integer_odd(pixels_per_point * width) {
+            *rect = rect.round_to_pixel_center(pixels_per_point);
+        } else {
+            *rect = rect.round_to_pixels(pixels_per_point);
+        }
+    }
 }
 
 impl<Color> From<(f32, Color)> for Stroke
@@ -182,3 +224,21 @@ impl From<Stroke> for PathStroke {
         }
     }
 }
+
+/// Returns true if the nearest integer is odd.
+fn is_nearest_integer_odd(x: f32) -> bool {
+    (x * 0.5 + 0.25).fract() > 0.5
+}
+
+#[test]
+fn test_is_nearest_integer_odd() {
+    assert!(is_nearest_integer_odd(0.6));
+    assert!(is_nearest_integer_odd(1.0));
+    assert!(is_nearest_integer_odd(1.4));
+    assert!(!is_nearest_integer_odd(1.6));
+    assert!(!is_nearest_integer_odd(2.0));
+    assert!(!is_nearest_integer_odd(2.4));
+    assert!(is_nearest_integer_odd(2.6));
+    assert!(is_nearest_integer_odd(3.0));
+    assert!(is_nearest_integer_odd(3.4));
+}
diff --git a/crates/epaint/src/tessellator.rs b/crates/epaint/src/tessellator.rs
index e8f8ad52c..0c4da74d1 100644
--- a/crates/epaint/src/tessellator.rs
+++ b/crates/epaint/src/tessellator.rs
@@ -5,18 +5,18 @@
 
 #![allow(clippy::identity_op)]
 
-use emath::{pos2, remap, vec2, GuiRounding as _, NumExt, Pos2, Rect, Rot2, Vec2};
+use emath::{GuiRounding as _, NumExt as _, Pos2, Rect, Rot2, Vec2, pos2, remap, vec2};
 
 use crate::{
-    color::ColorMode, emath, stroke::PathStroke, texture_atlas::PreparedDisc, CircleShape,
-    ClippedPrimitive, ClippedShape, Color32, CornerRadiusF32, CubicBezierShape, EllipseShape, Mesh,
-    PathShape, Primitive, QuadraticBezierShape, RectShape, Shape, Stroke, StrokeKind, TextShape,
-    TextureId, Vertex, WHITE_UV,
+    CircleShape, ClippedPrimitive, ClippedShape, Color32, CornerRadiusF32, CubicBezierShape,
+    EllipseShape, Mesh, PathShape, Primitive, QuadraticBezierShape, RectShape, Shape, Stroke,
+    StrokeKind, TextShape, TextureId, Vertex, WHITE_UV, color::ColorMode, emath,
+    stroke::PathStroke, texture_atlas::PreparedDisc,
 };
 
 // ----------------------------------------------------------------------------
 
-#[allow(clippy::approx_constant)]
+#[expect(clippy::approx_constant)]
 mod precomputed_vertices {
     // fn main() {
     //     let n = 64;
@@ -28,7 +28,7 @@ mod precomputed_vertices {
     //     println!("];")
     // }
 
-    use emath::{vec2, Vec2};
+    use emath::{Vec2, vec2};
 
     pub const CIRCLE_8: [Vec2; 9] = [
         vec2(1.000000, 0.000000),
@@ -340,7 +340,7 @@ impl Path {
     }
 
     pub fn add_circle(&mut self, center: Pos2, radius: f32) {
-        use precomputed_vertices::{CIRCLE_128, CIRCLE_16, CIRCLE_32, CIRCLE_64, CIRCLE_8};
+        use precomputed_vertices::{CIRCLE_8, CIRCLE_16, CIRCLE_32, CIRCLE_64, CIRCLE_128};
 
         // These cutoffs are based on a high-dpi display. TODO(emilk): use pixels_per_point here?
         // same cutoffs as in add_circle_quadrant
@@ -382,7 +382,7 @@ impl Path {
 
     pub fn add_open_points(&mut self, points: &[Pos2]) {
         let n = points.len();
-        assert!(n >= 2);
+        assert!(n >= 2, "A path needs at least two points, but got {n}");
 
         if n == 2 {
             // Common case optimization:
@@ -428,7 +428,7 @@ impl Path {
 
     pub fn add_line_loop(&mut self, points: &[Pos2]) {
         let n = points.len();
-        assert!(n >= 2);
+        assert!(n >= 2, "A path needs at least two points, but got {n}");
         self.reserve(n);
 
         let mut n0 = (points[0] - points[n - 1]).normalized().rot90();
@@ -535,7 +535,7 @@ impl Path {
 pub mod path {
     //! Helpers for constructing paths
     use crate::CornerRadiusF32;
-    use emath::{pos2, Pos2, Rect};
+    use emath::{Pos2, Rect, pos2};
 
     /// overwrites existing points
     pub fn rounded_rectangle(path: &mut Vec<Pos2>, rect: Rect, cr: CornerRadiusF32) {
@@ -602,7 +602,7 @@ pub mod path {
     //   - 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::{CIRCLE_128, CIRCLE_16, CIRCLE_32, CIRCLE_64, CIRCLE_8};
+        use super::precomputed_vertices::{CIRCLE_8, CIRCLE_16, CIRCLE_32, CIRCLE_64, CIRCLE_128};
 
         // These cutoffs are based on a high-dpi display. TODO(emilk): use pixels_per_point here?
         // same cutoffs as in add_circle
@@ -1300,8 +1300,6 @@ fn mul_color(color: Color32, factor: f32) -> Color32 {
 /// Converts [`Shape`]s into triangles ([`Mesh`]).
 ///
 /// For performance reasons it is smart to reuse the same [`Tessellator`].
-///
-/// See also [`tessellate_shapes`], a convenient wrapper around [`Tessellator`].
 #[derive(Clone)]
 pub struct Tessellator {
     pixels_per_point: f32,
@@ -1656,7 +1654,7 @@ impl Tessellator {
             if a.x == b.x {
                 // Vertical line
                 let mut x = a.x;
-                round_line_segment(&mut x, &stroke, self.pixels_per_point);
+                stroke.round_center_to_pixel(self.pixels_per_point, &mut x);
                 a.x = x;
                 b.x = x;
 
@@ -1677,7 +1675,7 @@ impl Tessellator {
             if a.y == b.y {
                 // Horizontal line
                 let mut y = a.y;
-                round_line_segment(&mut y, &stroke, self.pixels_per_point);
+                stroke.round_center_to_pixel(self.pixels_per_point, &mut y);
                 a.y = y;
                 b.y = y;
 
@@ -1778,7 +1776,6 @@ impl Tessellator {
 
         let mut corner_radius = CornerRadiusF32::from(corner_radius);
         let round_to_pixels = round_to_pixels.unwrap_or(self.options.round_rects_to_pixels);
-        let pixel_size = 1.0 / self.pixels_per_point;
 
         if stroke.width == 0.0 {
             stroke.color = Color32::TRANSPARENT;
@@ -1810,7 +1807,7 @@ impl Tessellator {
             }
         }
 
-        if stroke.is_empty() {
+        if stroke.is_empty() && out.texture_id == TextureId::default() {
             // Approximate thin rectangles with line segments.
             // This is important so that thin rectangles look good.
             if rect.width() <= 2.0 * self.feathering {
@@ -1849,17 +1846,7 @@ impl Tessellator {
                 }
                 StrokeKind::Middle => {
                     // On this path we optimize for crisp and symmetric strokes.
-                    // We put odd-width strokes in the center of pixels.
-                    // To understand why, see `fn round_line_segment`.
-                    if stroke.width <= 0.0 {
-                        rect = rect.round_to_pixels(self.pixels_per_point);
-                    } else if stroke.width <= pixel_size
-                        || is_nearest_integer_odd(self.pixels_per_point * stroke.width)
-                    {
-                        rect = rect.round_to_pixel_center(self.pixels_per_point);
-                    } else {
-                        rect = rect.round_to_pixels(self.pixels_per_point);
-                    }
+                    stroke.round_rect_to_pixel(self.pixels_per_point, &mut rect);
                 }
                 StrokeKind::Outside => {
                     // Put the inside of the stroke on a pixel boundary.
@@ -2013,12 +2000,10 @@ impl Tessellator {
         }
 
         if galley.pixels_per_point != self.pixels_per_point {
-            let warn = "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.";
-            #[cfg(feature = "log")]
-            log::warn!("{warn}");
-            #[cfg(not(feature = "log"))]
-            println!("{warn}");
+            log::warn!(
+                "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);
@@ -2044,11 +2029,13 @@ impl Tessellator {
                 continue;
             }
 
+            let final_row_pos = galley_pos + rotator * row.pos.to_vec2();
+
             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());
+            row_rect = row_rect.translate(final_row_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`
@@ -2097,7 +2084,7 @@ impl Tessellator {
                         };
 
                         Vertex {
-                            pos: galley_pos + offset,
+                            pos: final_row_pos + offset,
                             uv: (uv.to_vec2() * uv_normalizer).to_pos2(),
                             color,
                         }
@@ -2203,57 +2190,6 @@ impl Tessellator {
     }
 }
 
-fn round_line_segment(coord: &mut f32, stroke: &Stroke, pixels_per_point: f32) {
-    // If the stroke is an odd number of pixels wide,
-    // we want to round the center of it to the center of a pixel.
-    //
-    // If however it is an even number of pixels wide,
-    // we want to round the center to be between two pixels.
-    //
-    // We also want to treat strokes that are _almost_ odd as it it was odd,
-    // to make it symmetric. Same for strokes that are _almost_ even.
-    //
-    // For strokes less than a pixel wide we also round to the center,
-    // because it will rendered as a single row of pixels by the tessellator.
-
-    let pixel_size = 1.0 / pixels_per_point;
-
-    if stroke.width <= pixel_size || is_nearest_integer_odd(pixels_per_point * stroke.width) {
-        *coord = coord.round_to_pixel_center(pixels_per_point);
-    } else {
-        *coord = coord.round_to_pixels(pixels_per_point);
-    }
-}
-
-fn is_nearest_integer_odd(width: f32) -> bool {
-    (width * 0.5 + 0.25).fract() > 0.5
-}
-
-#[test]
-fn test_is_nearest_integer_odd() {
-    assert!(is_nearest_integer_odd(0.6));
-    assert!(is_nearest_integer_odd(1.0));
-    assert!(is_nearest_integer_odd(1.4));
-    assert!(!is_nearest_integer_odd(1.6));
-    assert!(!is_nearest_integer_odd(2.0));
-    assert!(!is_nearest_integer_odd(2.4));
-    assert!(is_nearest_integer_odd(2.6));
-    assert!(is_nearest_integer_odd(3.0));
-    assert!(is_nearest_integer_odd(3.4));
-}
-
-#[deprecated = "Use `Tessellator::new(…).tessellate_shapes(…)` instead"]
-pub fn tessellate_shapes(
-    pixels_per_point: f32,
-    options: TessellationOptions,
-    font_tex_size: [usize; 2],
-    prepared_discs: Vec<PreparedDisc>,
-    shapes: Vec<ClippedShape>,
-) -> Vec<ClippedPrimitive> {
-    Tessellator::new(pixels_per_point, options, font_tex_size, prepared_discs)
-        .tessellate_shapes(shapes)
-}
-
 impl Tessellator {
     /// Turns [`Shape`]:s into sets of triangles.
     ///
@@ -2270,7 +2206,7 @@ impl Tessellator {
     ///
     /// ## Returns
     /// A list of clip rectangles with matching [`Mesh`].
-    #[allow(unused_mut)]
+    #[allow(unused_mut, clippy::allow_attributes)]
     pub fn tessellate_shapes(&mut self, mut shapes: Vec<ClippedShape>) -> Vec<ClippedPrimitive> {
         profiling::function_scope!();
 
diff --git a/crates/epaint/src/text/cursor.rs b/crates/epaint/src/text/cursor.rs
index 2158695ec..a436ca1b1 100644
--- a/crates/epaint/src/text/cursor.rs
+++ b/crates/epaint/src/text/cursor.rs
@@ -26,13 +26,6 @@ impl CCursor {
     }
 }
 
-impl From<Cursor> for CCursor {
-    #[inline]
-    fn from(c: Cursor) -> Self {
-        c.ccursor
-    }
-}
-
 /// 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 {
@@ -76,10 +69,12 @@ impl std::ops::SubAssign<usize> for CCursor {
     }
 }
 
-/// Row Cursor
+/// Row/column cursor.
+///
+/// This refers to rows and columns in layout terms--text wrapping creates multiple rows.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct RCursor {
+pub struct LayoutCursor {
     /// 0 is first row, and so on.
     /// Note that a single paragraph can span multiple rows.
     /// (a paragraph is text separated by `\n`).
@@ -90,48 +85,3 @@ pub struct RCursor {
     /// 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 {
-    #[inline]
-    fn eq(&self, other: &Self) -> 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.
-///
-/// The default cursor is the zero-cursor, to the first character.
-#[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/crates/epaint/src/text/font.rs b/crates/epaint/src/text/font.rs
index a3994ca4c..4584c3457 100644
--- a/crates/epaint/src/text/font.rs
+++ b/crates/epaint/src/text/font.rs
@@ -1,12 +1,14 @@
 use std::collections::BTreeMap;
-use std::sync::Arc;
 
-use emath::{vec2, GuiRounding, Vec2};
+use ab_glyph::{Font as _, OutlinedGlyph, PxScale};
+use emath::{GuiRounding as _, OrderedFloat, Vec2, vec2};
 
 use crate::{
-    mutex::{Mutex, RwLock},
-    text::FontTweak,
     TextureAtlas,
+    text::{
+        FontTweak,
+        fonts::{CachedFamily, FontFaceKey},
+    },
 };
 
 // ----------------------------------------------------------------------------
@@ -34,102 +36,168 @@ impl UvRect {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct GlyphInfo {
+    /// Used for pair-kerning.
+    ///
+    /// Doesn't need to be unique.
+    ///
+    /// Is `None` for a special "invisible" glyph.
+    pub(crate) id: Option<ab_glyph::GlyphId>,
+
+    /// In [`ab_glyph`]s "unscaled" coordinate system.
+    pub advance_width_unscaled: OrderedFloat<f32>,
+}
+
+impl GlyphInfo {
+    /// A valid, but invisible, glyph of zero-width.
+    pub const INVISIBLE: Self = Self {
+        id: None,
+        advance_width_unscaled: OrderedFloat(0.0),
+    };
+}
+
+// Subpixel binning, taken from cosmic-text:
+// https://github.com/pop-os/cosmic-text/blob/974ddaed96b334f560b606ebe5d2ca2d2f9f23ef/src/glyph_cache.rs
+
+/// Bin for subpixel positioning of glyphs.
+///
+/// For accurate glyph positioning, we want to render each glyph at a subpixel coordinate. However, we also want to
+/// cache each glyph's bitmap. As a compromise, we bin each subpixel offset into one of four fractional values. This
+/// means one glyph can have up to four subpixel-positioned bitmaps in the cache.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub(super) enum SubpixelBin {
+    #[default]
+    Zero,
+    One,
+    Two,
+    Three,
+}
+
+impl SubpixelBin {
+    /// Bin the given position and return the new integral coordinate.
+    fn new(pos: f32) -> (i32, Self) {
+        let trunc = pos as i32;
+        let fract = pos - trunc as f32;
+
+        #[expect(clippy::collapsible_else_if)]
+        if pos.is_sign_negative() {
+            if fract > -0.125 {
+                (trunc, Self::Zero)
+            } else if fract > -0.375 {
+                (trunc - 1, Self::Three)
+            } else if fract > -0.625 {
+                (trunc - 1, Self::Two)
+            } else if fract > -0.875 {
+                (trunc - 1, Self::One)
+            } else {
+                (trunc - 1, Self::Zero)
+            }
+        } else {
+            if fract < 0.125 {
+                (trunc, Self::Zero)
+            } else if fract < 0.375 {
+                (trunc, Self::One)
+            } else if fract < 0.625 {
+                (trunc, Self::Two)
+            } else if fract < 0.875 {
+                (trunc, Self::Three)
+            } else {
+                (trunc + 1, Self::Zero)
+            }
+        }
+    }
+
+    pub fn as_float(&self) -> f32 {
+        match self {
+            Self::Zero => 0.0,
+            Self::One => 0.25,
+            Self::Two => 0.5,
+            Self::Three => 0.75,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Default)]
+pub struct GlyphAllocation {
     /// 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,
+    /// Unit: screen pixels.
+    pub advance_width_px: f32,
 
-    /// Texture coordinates.
+    /// UV rectangle for drawing.
     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,
-            uv_rect: Default::default(),
-        }
+#[derive(Hash, PartialEq, Eq)]
+struct GlyphCacheKey(u64);
+
+impl nohash_hasher::IsEnabled for GlyphCacheKey {}
+
+impl GlyphCacheKey {
+    fn new(glyph_id: ab_glyph::GlyphId, metrics: &ScaledMetrics, bin: SubpixelBin) -> Self {
+        let ScaledMetrics {
+            pixels_per_point,
+            px_scale_factor,
+            ..
+        } = *metrics;
+        debug_assert!(
+            0.0 < pixels_per_point && pixels_per_point.is_finite(),
+            "Bad pixels_per_point {pixels_per_point}"
+        );
+        debug_assert!(
+            0.0 < px_scale_factor && px_scale_factor.is_finite(),
+            "Bad px_scale_factor: {px_scale_factor}"
+        );
+        Self(crate::util::hash((
+            glyph_id,
+            pixels_per_point.to_bits(),
+            px_scale_factor.to_bits(),
+            bin,
+        )))
     }
 }
 
 // ----------------------------------------------------------------------------
 
-/// A specific font with a size.
+/// A specific font face.
 /// The interface uses points as the unit for everything.
 pub struct FontImpl {
     name: String,
     ab_glyph_font: ab_glyph::FontArc,
+    tweak: FontTweak,
+    glyph_info_cache: ahash::HashMap<char, GlyphInfo>,
+    glyph_alloc_cache: ahash::HashMap<GlyphCacheKey, GlyphAllocation>,
+}
 
-    /// Maximum character height
-    scale_in_pixels: u32,
+trait FontExt {
+    fn px_scale_factor(&self, scale: f32) -> f32;
+}
 
-    height_in_points: f32,
-
-    // move each character by this much (hack)
-    y_offset_in_points: f32,
-
-    ascent: f32,
-    pixels_per_point: f32,
-    glyph_info_cache: RwLock<ahash::HashMap<char, GlyphInfo>>, // TODO(emilk): standard Mutex
-    atlas: Arc<Mutex<TextureAtlas>>,
+impl<T> FontExt for T
+where
+    T: ab_glyph::Font,
+{
+    fn px_scale_factor(&self, scale: f32) -> f32 {
+        let units_per_em = self.units_per_em().unwrap_or_else(|| {
+            panic!("The font unit size exceeds the expected range (16..=16384)")
+        });
+        scale / units_per_em
+    }
 }
 
 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,
-    ) -> Self {
-        assert!(scale_in_pixels > 0.0);
-        assert!(pixels_per_point > 0.0);
-
-        use ab_glyph::{Font, ScaleFont};
-        let scaled = ab_glyph_font.as_scaled(scale_in_pixels);
-        let ascent = (scaled.ascent() / pixels_per_point).round_ui();
-        let descent = (scaled.descent() / pixels_per_point).round_ui();
-        let line_gap = (scaled.line_gap() / pixels_per_point).round_ui();
-
-        // Tweak the scale as the user desired
-        let scale_in_pixels = scale_in_pixels * tweak.scale;
-        let scale_in_points = scale_in_pixels / pixels_per_point;
-
-        let baseline_offset = (scale_in_points * tweak.baseline_offset_factor).round_ui();
-
-        let y_offset_points =
-            ((scale_in_points * tweak.y_offset_factor) + tweak.y_offset).round_ui();
-
-        // Center scaled glyphs properly:
-        let height = ascent + descent;
-        let y_offset_points = y_offset_points - (1.0 - tweak.scale) * 0.5 * height;
-
-        // 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_in_points = (y_offset_points * pixels_per_point).round() / pixels_per_point;
-
+    pub fn new(name: String, ab_glyph_font: ab_glyph::FontArc, tweak: FontTweak) -> Self {
         Self {
             name,
             ab_glyph_font,
-            scale_in_pixels,
-            height_in_points: ascent - descent + line_gap,
-            y_offset_in_points,
-            ascent: ascent + baseline_offset,
-            pixels_per_point,
+            tweak,
             glyph_info_cache: Default::default(),
-            atlas,
+            glyph_alloc_cache: Default::default(),
         }
     }
 
@@ -143,14 +211,6 @@ impl FontImpl {
             return false;
         }
 
-        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:
@@ -163,7 +223,6 @@ impl FontImpl {
 
     /// 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)
@@ -171,26 +230,26 @@ impl FontImpl {
     }
 
     /// `\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);
-            }
+    pub(super) fn glyph_info(&mut self, c: char) -> Option<GlyphInfo> {
+        if let Some(glyph_info) = self.glyph_info_cache.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,
-                    ..space
-                };
-                self.glyph_info_cache.write().insert(c, glyph_info);
-                return Some(glyph_info);
-            }
+        if c == '\t'
+            && let Some(space) = self.glyph_info(' ')
+        {
+            let glyph_info = GlyphInfo {
+                advance_width_unscaled: (crate::text::TAB_SIZE as f32
+                    * space.advance_width_unscaled.0)
+                    .into(),
+                ..space
+            };
+            self.glyph_info_cache.insert(c, glyph_info);
+            return Some(glyph_info);
         }
 
         if c == '\u{2009}' {
@@ -199,105 +258,165 @@ impl FontImpl {
             // 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 em = self.ab_glyph_font.units_per_em().unwrap_or(1.0);
+                let advance_width = f32::min(em / 6.0, space.advance_width_unscaled.0 * 0.5); // TODO(emilk): make configurable
                 let glyph_info = GlyphInfo {
-                    advance_width,
+                    advance_width_unscaled: advance_width.into(),
                     ..space
                 };
-                self.glyph_info_cache.write().insert(c, glyph_info);
+                self.glyph_info_cache.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);
+            let glyph_info = GlyphInfo::INVISIBLE;
+            self.glyph_info_cache.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);
+            let glyph_info = GlyphInfo {
+                id: Some(glyph_id),
+                advance_width_unscaled: self.ab_glyph_font.h_advance_unscaled(glyph_id).into(),
+            };
+            self.glyph_info_cache.insert(c, glyph_info);
             Some(glyph_info)
         }
     }
 
     #[inline]
-    pub fn pair_kerning(
+    pub(super) fn pair_kerning_pixels(
         &self,
+        metrics: &ScaledMetrics,
         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
+        self.ab_glyph_font.kern_unscaled(last_glyph_id, glyph_id) * metrics.px_scale_factor
     }
 
-    /// Height of one row of text in points.
-    ///
-    /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    #[inline(always)]
-    pub fn row_height(&self) -> f32 {
-        self.height_in_points
+    #[inline]
+    pub fn pair_kerning(
+        &self,
+        metrics: &ScaledMetrics,
+        last_glyph_id: ab_glyph::GlyphId,
+        glyph_id: ab_glyph::GlyphId,
+    ) -> f32 {
+        self.pair_kerning_pixels(metrics, last_glyph_id, glyph_id) / metrics.pixels_per_point
     }
 
     #[inline(always)]
-    pub fn pixels_per_point(&self) -> f32 {
-        self.pixels_per_point
+    pub fn scaled_metrics(&self, pixels_per_point: f32, font_size: f32) -> ScaledMetrics {
+        let pt_scale_factor = self
+            .ab_glyph_font
+            .px_scale_factor(font_size * self.tweak.scale);
+        let ascent = (self.ab_glyph_font.ascent_unscaled() * pt_scale_factor).round_ui();
+        let descent = (self.ab_glyph_font.descent_unscaled() * pt_scale_factor).round_ui();
+        let line_gap = (self.ab_glyph_font.line_gap_unscaled() * pt_scale_factor).round_ui();
+
+        let scale = font_size * self.tweak.scale * pixels_per_point;
+        let px_scale_factor = self.ab_glyph_font.px_scale_factor(scale);
+
+        let y_offset_in_points = ((font_size * self.tweak.scale * self.tweak.y_offset_factor)
+            + self.tweak.y_offset)
+            .round_ui();
+
+        ScaledMetrics {
+            pixels_per_point,
+            px_scale_factor,
+            y_offset_in_points,
+            ascent,
+            row_height: ascent - descent + line_gap,
+        }
     }
 
-    /// This is the distance from the top to the baseline.
-    ///
-    /// Unit: points.
-    #[inline(always)]
-    pub fn ascent(&self) -> f32 {
-        self.ascent
-    }
+    pub fn allocate_glyph(
+        &mut self,
+        atlas: &mut TextureAtlas,
+        metrics: &ScaledMetrics,
+        glyph_info: GlyphInfo,
+        chr: char,
+        h_pos: f32,
+    ) -> (GlyphAllocation, i32) {
+        let advance_width_px = glyph_info.advance_width_unscaled.0 * metrics.px_scale_factor;
 
-    fn allocate_glyph(&self, glyph_id: ab_glyph::GlyphId) -> GlyphInfo {
-        assert!(glyph_id.0 != 0);
-        use ab_glyph::{Font as _, ScaleFont};
+        let Some(glyph_id) = glyph_info.id else {
+            // Invisible.
+            return (GlyphAllocation::default(), h_pos as i32);
+        };
 
-        let glyph = glyph_id.with_scale_and_position(
-            self.scale_in_pixels as f32,
-            ab_glyph::Point { x: 0.0, y: 0.0 },
-        );
+        // CJK scripts contain a lot of characters and could hog the glyph atlas if we stored 4 subpixel offsets per
+        // glyph.
+        let (h_pos_round, bin) = if is_cjk(chr) {
+            (h_pos.round() as i32, SubpixelBin::Zero)
+        } else {
+            SubpixelBin::new(h_pos)
+        };
 
-        let uv_rect = self.ab_glyph_font.outline_glyph(glyph).map(|glyph| {
-            let bb = glyph.px_bounds();
+        let entry = match self
+            .glyph_alloc_cache
+            .entry(GlyphCacheKey::new(glyph_id, metrics, bin))
+        {
+            std::collections::hash_map::Entry::Occupied(glyph_alloc) => {
+                let mut glyph_alloc = *glyph_alloc.get();
+                glyph_alloc.advance_width_px = advance_width_px; // Hack to get `\t` and thin space to work, since they use the same glyph id as ` ` (space).
+                return (glyph_alloc, h_pos_round);
+            }
+            std::collections::hash_map::Entry::Vacant(entry) => entry,
+        };
+
+        debug_assert!(glyph_id.0 != 0, "Can't allocate glyph for id 0");
+
+        let uv_rect = self.ab_glyph_font.outline(glyph_id).map(|outline| {
+            let glyph = ab_glyph::Glyph {
+                id: glyph_id,
+                // We bypass ab-glyph's scaling method because it uses the wrong scale
+                // (https://github.com/alexheretic/ab-glyph/issues/15), and this field is never accessed when
+                // rasterizing. We can just put anything here.
+                scale: PxScale::from(0.0),
+                position: ab_glyph::Point {
+                    x: bin.as_float(),
+                    y: 0.0,
+                },
+            };
+            let outlined = OutlinedGlyph::new(
+                glyph,
+                outline,
+                ab_glyph::PxScaleFactor {
+                    horizontal: metrics.px_scale_factor,
+                    vertical: metrics.px_scale_factor,
+                },
+            );
+            let bb = outlined.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 glyph_pos = {
-                    let atlas = &mut self.atlas.lock();
+                    let text_alpha_from_coverage = atlas.text_alpha_from_coverage;
                     let (glyph_pos, image) = atlas.allocate((glyph_width, glyph_height));
-                    glyph.draw(|x, y, v| {
+                    outlined.draw(|x, y, v| {
                         if 0.0 < v {
                             let px = glyph_pos.0 + x as usize;
                             let py = glyph_pos.1 + y as usize;
-                            image[(px, py)] = v;
+                            image[(px, py)] = text_alpha_from_coverage.color_from_coverage(v);
                         }
                     });
                     glyph_pos
                 };
 
                 let offset_in_pixels = vec2(bb.min.x, bb.min.y);
-                let offset =
-                    offset_in_pixels / self.pixels_per_point + self.y_offset_in_points * Vec2::Y;
+                let offset = offset_in_pixels / metrics.pixels_per_point
+                    + metrics.y_offset_in_points * Vec2::Y;
                 UvRect {
                     offset,
-                    size: vec2(glyph_width as f32, glyph_height as f32) / self.pixels_per_point,
+                    size: vec2(glyph_width as f32, glyph_height as f32) / metrics.pixels_per_point,
                     min: [glyph_pos.0 as u16, glyph_pos.1 as u16],
                     max: [
                         (glyph_pos.0 + glyph_width) as u16,
@@ -308,101 +427,37 @@ impl FontImpl {
         });
         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 {
+        let allocation = GlyphAllocation {
             id: glyph_id,
-            advance_width: advance_width_in_points,
+            advance_width_px,
             uv_rect,
-        }
+        };
+        entry.insert(allocation);
+        (allocation, h_pos_round)
     }
 }
 
-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<BTreeMap<char, Vec<String>>>,
-
-    replacement_glyph: (FontIndex, GlyphInfo),
-    pixels_per_point: f32,
-    row_height: f32,
-    glyph_info_cache: ahash::HashMap<char, (FontIndex, GlyphInfo)>,
+pub struct Font<'a> {
+    pub(super) fonts_by_id: &'a mut nohash_hasher::IntMap<FontFaceKey, FontImpl>,
+    pub(super) cached_family: &'a mut CachedFamily,
+    pub(super) atlas: &'a mut TextureAtlas,
 }
 
-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(|| {
-                #[cfg(feature = "log")]
-                log::warn!(
-                    "Failed to find replacement characters {PRIMARY_REPLACEMENT_CHAR:?} or {FALLBACK_REPLACEMENT_CHAR:?}. Will use empty glyph."
-                );
-                (0, GlyphInfo::default())
-            });
-        slf.replacement_glyph = replacement_glyph;
-
-        slf
-    }
-
+impl Font<'_> {
     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, and in which font they are available in.
     pub fn characters(&mut self) -> &BTreeMap<char, Vec<String>> {
-        self.characters.get_or_insert_with(|| {
+        self.cached_family.characters.get_or_insert_with(|| {
             let mut characters: BTreeMap<char, Vec<String>> = Default::default();
-            for font in &self.fonts {
+            for font_id in &self.cached_family.fonts {
+                let font = self.fonts_by_id.get(font_id).expect("Nonexistent font ID");
                 for chr in font.characters() {
                     characters.entry(chr).or_default().push(font.name.clone());
                 }
@@ -411,34 +466,28 @@ impl Font {
         })
     }
 
-    #[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.
-    ///
-    /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    #[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)
+    pub fn scaled_metrics(&self, pixels_per_point: f32, font_size: f32) -> ScaledMetrics {
+        self.cached_family
+            .fonts
+            .first()
+            .and_then(|key| self.fonts_by_id.get(key))
+            .map(|font_impl| font_impl.scaled_metrics(pixels_per_point, font_size))
             .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
+    pub fn glyph_width(&mut self, c: char, font_size: f32) -> f32 {
+        let (key, glyph_info) = self.glyph_info(c);
+        if let Some(font) = &self.fonts_by_id.get(&key) {
+            glyph_info.advance_width_unscaled.0 * font.ab_glyph_font.px_scale_factor(font_size)
+        } else {
+            0.0
+        }
     }
 
     /// 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 🤦‍♂️
+        self.glyph_info(c) != self.cached_family.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?
@@ -447,44 +496,46 @@ impl Font {
     }
 
     /// `\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) {
+    pub(crate) fn glyph_info(&mut self, c: char) -> (FontFaceKey, GlyphInfo) {
+        if let Some(font_index_glyph_info) = self.cached_family.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);
+        let font_index_glyph_info = self
+            .cached_family
+            .glyph_info_no_cache_or_fallback(c, self.fonts_by_id);
+        let font_index_glyph_info =
+            font_index_glyph_info.unwrap_or(self.cached_family.replacement_glyph);
+        self.cached_family
+            .glyph_info_cache
+            .insert(c, font_index_glyph_info);
         font_index_glyph_info
     }
+}
 
-    #[inline]
-    pub(crate) fn font_impl_and_glyph_info(&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)
-    }
+/// Metrics for a font at a specific screen-space scale.
+#[derive(Clone, Copy, Debug, PartialEq, Default)]
+pub struct ScaledMetrics {
+    /// The DPI part of the screen-space scale.
+    pub pixels_per_point: f32,
 
-    pub(crate) fn ascent(&self) -> f32 {
-        if let Some(first) = self.fonts.first() {
-            first.ascent()
-        } else {
-            self.row_height
-        }
-    }
+    /// Scale factor, relative to the font's units per em (so, probably much less than 1).
+    ///
+    /// Translates "unscaled" units to physical (screen) pixels.
+    pub px_scale_factor: f32,
 
-    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
-    }
+    /// Vertical offset, in UI points.
+    pub y_offset_in_points: f32,
+
+    /// This is the distance from the top to the baseline.
+    ///
+    /// Unit: points.
+    pub ascent: f32,
+
+    /// Height of one row of text in points.
+    ///
+    /// Returns a value rounded to [`emath::GUI_ROUNDING`].
+    pub row_height: f32,
 }
 
 /// Code points that will always be invisible (zero width).
@@ -533,3 +584,28 @@ fn invisible_char(c: char) -> bool {
             | '\u{FEFF}' // ZERO WIDTH NO-BREAK SPACE
     )
 }
+
+#[inline]
+pub(super) 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]
+pub(super) fn is_kana(c: char) -> bool {
+    ('\u{3040}' <= c && c <= '\u{309F}') // Hiragana block
+        || ('\u{30A0}' <= c && c <= '\u{30FF}') // Katakana block
+}
+
+#[inline]
+pub(super) fn is_cjk(c: char) -> bool {
+    // TODO(bigfarts): Add support for Korean Hangul.
+    is_cjk_ideograph(c) || is_kana(c)
+}
+
+#[inline]
+pub(super) 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)
+}
diff --git a/crates/epaint/src/text/fonts.rs b/crates/epaint/src/text/fonts.rs
index b952b2817..6bc7ccf8f 100644
--- a/crates/epaint/src/text/fonts.rs
+++ b/crates/epaint/src/text/fonts.rs
@@ -1,12 +1,17 @@
-use std::{collections::BTreeMap, sync::Arc};
+use std::{
+    collections::BTreeMap,
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering},
+    },
+};
 
 use crate::{
-    mutex::{Mutex, MutexGuard},
+    AlphaFromCoverage, TextureAtlas,
     text::{
-        font::{Font, FontImpl},
-        Galley, LayoutJob,
+        Galley, LayoutJob, LayoutSection,
+        font::{Font, FontImpl, GlyphInfo},
     },
-    TextureAtlas,
 };
 use emath::{NumExt as _, OrderedFloat};
 
@@ -54,7 +59,6 @@ impl FontId {
     }
 }
 
-#[allow(clippy::derived_hash_with_manual_eq)]
 impl std::hash::Hash for FontId {
     #[inline(always)]
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
@@ -144,6 +148,12 @@ impl FontData {
     }
 }
 
+impl AsRef<[u8]> for FontData {
+    fn as_ref(&self) -> &[u8] {
+        self.font.as_ref()
+    }
+}
+
 // ----------------------------------------------------------------------------
 
 /// Extra scale and vertical tweak to apply to all text of a certain font.
@@ -174,13 +184,6 @@ pub struct FontTweak {
     ///
     /// 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 {
@@ -189,7 +192,6 @@ impl Default for FontTweak {
             scale: 1.0,
             y_offset_factor: 0.0,
             y_offset: 0.0,
-            baseline_offset_factor: 0.0,
         }
     }
 }
@@ -402,6 +404,91 @@ impl FontDefinitions {
     }
 }
 
+/// Unique ID for looking up a single font face/file.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct FontFaceKey(u64);
+
+impl FontFaceKey {
+    pub const INVALID: Self = Self(0);
+
+    fn new() -> Self {
+        static KEY_COUNTER: AtomicU64 = AtomicU64::new(1);
+        Self(crate::util::hash(
+            KEY_COUNTER.fetch_add(1, Ordering::Relaxed),
+        ))
+    }
+}
+
+// Safe, because we hash the value in the constructor.
+impl nohash_hasher::IsEnabled for FontFaceKey {}
+
+/// Cached data for working with a font family (e.g. doing character lookups).
+#[derive(Debug)]
+pub(super) struct CachedFamily {
+    pub fonts: Vec<FontFaceKey>,
+
+    /// Lazily calculated.
+    pub characters: Option<BTreeMap<char, Vec<String>>>,
+
+    pub replacement_glyph: (FontFaceKey, GlyphInfo),
+
+    pub glyph_info_cache: ahash::HashMap<char, (FontFaceKey, GlyphInfo)>,
+}
+
+impl CachedFamily {
+    fn new(
+        fonts: Vec<FontFaceKey>,
+        fonts_by_id: &mut nohash_hasher::IntMap<FontFaceKey, FontImpl>,
+    ) -> Self {
+        if fonts.is_empty() {
+            return Self {
+                fonts,
+                characters: None,
+                replacement_glyph: (FontFaceKey::INVALID, GlyphInfo::INVISIBLE),
+                glyph_info_cache: Default::default(),
+            };
+        }
+
+        let mut slf = Self {
+            fonts,
+            characters: None,
+            replacement_glyph: (FontFaceKey::INVALID, GlyphInfo::INVISIBLE),
+            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, fonts_by_id)
+            .or_else(|| slf.glyph_info_no_cache_or_fallback(FALLBACK_REPLACEMENT_CHAR, fonts_by_id))
+            .unwrap_or_else(|| {
+                log::warn!(
+                    "Failed to find replacement characters {PRIMARY_REPLACEMENT_CHAR:?} or {FALLBACK_REPLACEMENT_CHAR:?}. Will use empty glyph."
+                );
+                (FontFaceKey::INVALID, GlyphInfo::INVISIBLE)
+            });
+        slf.replacement_glyph = replacement_glyph;
+
+        slf
+    }
+
+    pub(crate) fn glyph_info_no_cache_or_fallback(
+        &mut self,
+        c: char,
+        fonts_by_id: &mut nohash_hasher::IntMap<FontFaceKey, FontImpl>,
+    ) -> Option<(FontFaceKey, GlyphInfo)> {
+        for font_key in &self.fonts {
+            let font_impl = fonts_by_id.get_mut(font_key).expect("Nonexistent font ID");
+            if let Some(glyph_info) = font_impl.glyph_info(c) {
+                self.glyph_info_cache.insert(c, (*font_key, glyph_info));
+                return Some((*font_key, glyph_info));
+            }
+        }
+        None
+    }
+}
+
 // ----------------------------------------------------------------------------
 
 /// The collection of fonts used by `epaint`.
@@ -413,129 +500,187 @@ impl FontDefinitions {
 /// If you are using `egui`, use `egui::Context::set_fonts` and `egui::Context::fonts`.
 ///
 /// You need to call [`Self::begin_pass`] and [`Self::font_image_delta`] once every frame.
-#[derive(Clone)]
-pub struct Fonts(Arc<Mutex<FontsAndCache>>);
+pub struct Fonts {
+    pub fonts: FontsImpl,
+    galley_cache: GalleyCache,
+}
 
 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,
+        text_alpha_from_coverage: AlphaFromCoverage,
         definitions: FontDefinitions,
     ) -> Self {
-        let fonts_and_cache = FontsAndCache {
-            fonts: FontsImpl::new(pixels_per_point, max_texture_side, definitions),
+        Self {
+            fonts: FontsImpl::new(max_texture_side, text_alpha_from_coverage, 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`.
+    /// `pixels_per_point`, `max_texture_side`, and `text_alpha_from_coverage`.
     ///
     /// 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`,
+    /// This function will react to changes in `pixels_per_point`, `max_texture_side`, and `text_alpha_from_coverage`,
     /// as well as notice when the font atlas is getting full, and handle that.
-    pub fn begin_pass(&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;
-        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;
+    pub fn begin_pass(
+        &mut self,
+        max_texture_side: usize,
+        text_alpha_from_coverage: AlphaFromCoverage,
+    ) {
+        let max_texture_side_changed = self.fonts.max_texture_side != max_texture_side;
+        let text_alpha_from_coverage_changed =
+            self.fonts.atlas.text_alpha_from_coverage != text_alpha_from_coverage;
+        let font_atlas_almost_full = self.fonts.atlas.fill_ratio() > 0.8;
         let needs_recreate =
-            pixels_per_point_changed || max_texture_side_changed || font_atlas_almost_full;
+            max_texture_side_changed || text_alpha_from_coverage_changed || font_atlas_almost_full;
 
         if needs_recreate {
-            let definitions = fonts_and_cache.fonts.definitions.clone();
+            let definitions = self.fonts.definitions.clone();
 
-            *fonts_and_cache = FontsAndCache {
-                fonts: FontsImpl::new(pixels_per_point, max_texture_side, definitions),
+            *self = Self {
+                fonts: FontsImpl::new(max_texture_side, text_alpha_from_coverage, definitions),
                 galley_cache: Default::default(),
             };
         }
 
-        fonts_and_cache.galley_cache.flush_cache();
+        self.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
+    pub fn font_image_delta(&mut self) -> Option<crate::ImageDelta> {
+        self.fonts.atlas.take_delta()
     }
 
     #[inline]
     pub fn max_texture_side(&self) -> usize {
-        self.lock().fonts.max_texture_side
+        self.fonts.max_texture_side
+    }
+
+    #[inline]
+    pub fn definitions(&self) -> &FontDefinitions {
+        &self.fonts.definitions
     }
 
     /// The font atlas.
     /// Pass this to [`crate::Tessellator`].
-    pub fn texture_atlas(&self) -> Arc<Mutex<TextureAtlas>> {
-        self.lock().fonts.atlas.clone()
+    pub fn texture_atlas(&self) -> &TextureAtlas {
+        &self.fonts.atlas
     }
 
     /// The full font atlas image.
     #[inline]
-    pub fn image(&self) -> crate::FontImage {
-        self.lock().fonts.atlas.lock().image().clone()
+    pub fn image(&self) -> crate::ColorImage {
+        self.fonts.atlas.image().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)
+        self.fonts.atlas.size()
     }
 
     /// 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)
+    pub fn has_glyph(&mut self, font_id: &FontId, c: char) -> bool {
+        self.fonts.font(&font_id.family).has_glyph(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)
+    pub fn has_glyphs(&mut self, font_id: &FontId, s: &str) -> bool {
+        self.fonts.font(&font_id.family).has_glyphs(s)
+    }
+
+    pub fn num_galleys_in_cache(&self) -> usize {
+        self.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_pass`].
+    pub fn font_atlas_fill_ratio(&self) -> f32 {
+        self.fonts.atlas.fill_ratio()
+    }
+
+    /// Returns a [`FontsView`] with the given `pixels_per_point` that can be used to do text layout.
+    pub fn with_pixels_per_point(&mut self, pixels_per_point: f32) -> FontsView<'_> {
+        FontsView {
+            fonts: &mut self.fonts,
+            galley_cache: &mut self.galley_cache,
+            pixels_per_point,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// The context's collection of fonts, with this context's `pixels_per_point`. This is what you use to do text layout.
+pub struct FontsView<'a> {
+    pub fonts: &'a mut FontsImpl,
+    galley_cache: &'a mut GalleyCache,
+    pixels_per_point: f32,
+}
+
+impl FontsView<'_> {
+    #[inline]
+    pub fn max_texture_side(&self) -> usize {
+        self.fonts.max_texture_side
+    }
+
+    #[inline]
+    pub fn definitions(&self) -> &FontDefinitions {
+        &self.fonts.definitions
+    }
+
+    /// The full font atlas image.
+    #[inline]
+    pub fn image(&self) -> crate::ColorImage {
+        self.fonts.atlas.image().clone()
+    }
+
+    /// Current size of the font image.
+    /// Pass this to [`crate::Tessellator`].
+    pub fn font_image_size(&self) -> [usize; 2] {
+        self.fonts.atlas.size()
+    }
+
+    /// Width of this character in points.
+    ///
+    /// If the font doesn't exist, this will return `0.0`.
+    pub fn glyph_width(&mut self, font_id: &FontId, c: char) -> f32 {
+        self.fonts
+            .font(&font_id.family)
+            .glyph_width(c, font_id.size)
+    }
+
+    /// Can we display this glyph?
+    pub fn has_glyph(&mut self, font_id: &FontId, c: char) -> bool {
+        self.fonts.font(&font_id.family).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.fonts.font(&font_id.family).has_glyphs(s)
     }
 
     /// Height of one row of text in points.
     ///
     /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    #[inline]
-    pub fn row_height(&self, font_id: &FontId) -> f32 {
-        self.lock().fonts.row_height(font_id)
+    pub fn row_height(&mut self, font_id: &FontId) -> f32 {
+        self.fonts
+            .font(&font_id.family)
+            .scaled_metrics(self.pixels_per_point, font_id.size)
+            .row_height
     }
 
     /// List of all known font families.
     pub fn families(&self) -> Vec<FontFamily> {
-        self.lock()
-            .fonts
-            .definitions
-            .families
-            .keys()
-            .cloned()
-            .collect()
+        self.fonts.definitions.families.keys().cloned().collect()
     }
 
     /// Layout some text.
@@ -546,27 +691,33 @@ impl Fonts {
     ///
     /// 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 layout_job(&mut self, job: LayoutJob) -> Arc<Galley> {
+        let allow_split_paragraphs = true; // Optimization for editing text with many paragraphs.
+        self.galley_cache.layout(
+            self.fonts,
+            self.pixels_per_point,
+            job,
+            allow_split_paragraphs,
+        )
     }
 
     pub fn num_galleys_in_cache(&self) -> usize {
-        self.lock().galley_cache.num_galleys_in_cache()
+        self.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_pass`].
+    /// but can also decrease in a call to [`Fonts::begin_pass`].
     pub fn font_atlas_fill_ratio(&self) -> f32 {
-        self.lock().fonts.atlas.lock().fill_ratio()
+        self.fonts.atlas.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,
+        &mut self,
         text: String,
         font_id: FontId,
         color: crate::Color32,
@@ -580,7 +731,7 @@ impl Fonts {
     ///
     /// The implementation uses memoization so repeated calls are cheap.
     pub fn layout_no_wrap(
-        &self,
+        &mut self,
         text: String,
         font_id: FontId,
         color: crate::Color32,
@@ -593,7 +744,7 @@ impl Fonts {
     ///
     /// The implementation uses memoization so repeated calls are cheap.
     pub fn layout_delayed_color(
-        &self,
+        &mut self,
         text: String,
         font_id: FontId,
         wrap_width: f32,
@@ -604,114 +755,75 @@ impl Fonts {
 
 // ----------------------------------------------------------------------------
 
-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)
-    }
-}
-
-// ----------------------------------------------------------------------------
-
 /// 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<(OrderedFloat<f32>, FontFamily), Font>,
+    atlas: TextureAtlas,
+    fonts_by_id: nohash_hasher::IntMap<FontFaceKey, FontImpl>,
+    fonts_by_name: ahash::HashMap<String, FontFaceKey>,
+    family_cache: ahash::HashMap<FontFamily, CachedFamily>,
 }
 
 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,
+        text_alpha_from_coverage: AlphaFromCoverage,
         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(16 * 1024);
         let initial_height = 32; // Keep initial font atlas small, so it is fast to upload to GPU. This will expand as needed anyways.
-        let atlas = TextureAtlas::new([texture_width, initial_height]);
+        let atlas = TextureAtlas::new([texture_width, initial_height], text_alpha_from_coverage);
 
-        let atlas = Arc::new(Mutex::new(atlas));
-
-        let font_impl_cache =
-            FontImplCache::new(atlas.clone(), pixels_per_point, &definitions.font_data);
+        let mut fonts_by_id: nohash_hasher::IntMap<FontFaceKey, FontImpl> = Default::default();
+        let mut font_impls: ahash::HashMap<String, FontFaceKey> = Default::default();
+        for (name, font_data) in &definitions.font_data {
+            let tweak = font_data.tweak;
+            let ab_glyph = ab_glyph_font_from_font_data(name, font_data);
+            let font_impl = FontImpl::new(name.clone(), ab_glyph, tweak);
+            let key = FontFaceKey::new();
+            fonts_by_id.insert(key, font_impl);
+            font_impls.insert(name.clone(), key);
+        }
 
         Self {
-            pixels_per_point,
             max_texture_side,
             definitions,
             atlas,
-            font_impl_cache,
-            sized_family: Default::default(),
+            fonts_by_id,
+            fonts_by_name: font_impls,
+            family_cache: Default::default(),
         }
     }
 
-    #[inline(always)]
-    pub fn pixels_per_point(&self) -> f32 {
-        self.pixels_per_point
-    }
+    /// Get the right font implementation from [`FontFamily`].
+    pub fn font(&mut self, family: &FontFamily) -> Font<'_> {
+        let cached_family = self.family_cache.entry(family.clone()).or_insert_with(|| {
+            let fonts = &self.definitions.families.get(family);
+            let fonts =
+                fonts.unwrap_or_else(|| panic!("FontFamily::{family:?} is not bound to any fonts"));
 
-    #[inline]
-    pub fn definitions(&self) -> &FontDefinitions {
-        &self.definitions
-    }
+            let fonts: Vec<FontFaceKey> = fonts
+                .iter()
+                .map(|font_name| {
+                    *self
+                        .fonts_by_name
+                        .get(font_name)
+                        .unwrap_or_else(|| panic!("No font data found for {font_name:?}"))
+                })
+                .collect();
 
-    /// Get the right font implementation from size and [`FontFamily`].
-    pub fn font(&mut self, font_id: &FontId) -> &mut Font {
-        let FontId { mut size, family } = font_id;
-        size = size.at_least(0.1).at_most(2048.0);
-
-        self.sized_family
-            .entry((OrderedFloat(size), family.clone()))
-            .or_insert_with(|| {
-                let fonts = &self.definitions.families.get(family);
-                let fonts = fonts
-                    .unwrap_or_else(|| panic!("FontFamily::{family:?} is not bound to any fonts"));
-
-                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.
-    ///
-    /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    fn row_height(&mut self, font_id: &FontId) -> f32 {
-        self.font(font_id).row_height()
+            CachedFamily::new(fonts, &mut self.fonts_by_id)
+        });
+        Font {
+            fonts_by_id: &mut self.fonts_by_id,
+            cached_family,
+            atlas: &mut self.atlas,
+        }
     }
 }
 
@@ -720,6 +832,12 @@ impl FontsImpl {
 struct CachedGalley {
     /// When it was last used
     last_used: u32,
+
+    /// Hashes of all other entries this one depends on for quick re-layout.
+    /// Their `last_used`s should be updated alongside this one to make sure they're
+    /// not evicted.
+    children: Option<Arc<[u64]>>,
+
     galley: Arc<Galley>,
 }
 
@@ -731,13 +849,19 @@ struct GalleyCache {
 }
 
 impl GalleyCache {
-    fn layout(&mut self, fonts: &mut FontsImpl, mut job: LayoutJob) -> Arc<Galley> {
+    fn layout_internal(
+        &mut self,
+        fonts: &mut FontsImpl,
+        mut job: LayoutJob,
+        pixels_per_point: f32,
+        allow_split_paragraphs: bool,
+    ) -> (u64, Arc<Galley>) {
         if job.wrap.max_width.is_finite() {
             // Protect against rounding errors in egui layout code.
 
             // Say the user asks to wrap at width 200.0.
             // The text layout wraps, and reports that the final width was 196.0 points.
-            // This than trickles up the `Ui` chain and gets stored as the width for a tooltip (say).
+            // This then trickles up the `Ui` chain and gets stored as the width for a tooltip (say).
             // On the next frame, this is then set as the max width for the tooltip,
             // and we end up calling the text layout code again, this time with a wrap width of 196.0.
             // Except, somewhere in the `Ui` chain with added margins etc, a rounding error was introduced,
@@ -757,24 +881,182 @@ impl GalleyCache {
             job.wrap.max_width = job.wrap.max_width.round();
         }
 
-        let hash = crate::util::hash(&job); // TODO(emilk): even faster hasher?
+        let hash = crate::util::hash((&job, OrderedFloat(pixels_per_point))); // TODO(emilk): even faster hasher?
 
-        match self.cache.entry(hash) {
+        let galley = match self.cache.entry(hash) {
             std::collections::hash_map::Entry::Occupied(entry) => {
+                // The job was found in cache - no need to re-layout.
                 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(),
-                });
+
+                let galley = cached.galley.clone();
+                if let Some(children) = &cached.children {
+                    // The point of `allow_split_paragraphs` is to split large jobs into paragraph,
+                    // and then cache each paragraph individually.
+                    // That way, if we edit a single paragraph, only that paragraph will be re-layouted.
+                    // For that to work we need to keep all the child/paragraph
+                    // galleys alive while the parent galley is alive:
+                    for child_hash in children.clone().iter() {
+                        if let Some(cached_child) = self.cache.get_mut(child_hash) {
+                            cached_child.last_used = self.generation;
+                        }
+                    }
+                }
+
                 galley
             }
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                let job = Arc::new(job);
+                if allow_split_paragraphs && should_cache_each_paragraph_individually(&job) {
+                    let (child_galleys, child_hashes) =
+                        self.layout_each_paragraph_individually(fonts, &job, pixels_per_point);
+                    debug_assert_eq!(
+                        child_hashes.len(),
+                        child_galleys.len(),
+                        "Bug in `layout_each_paragraph_individually`"
+                    );
+                    let galley = Arc::new(Galley::concat(job, &child_galleys, pixels_per_point));
+
+                    self.cache.insert(
+                        hash,
+                        CachedGalley {
+                            last_used: self.generation,
+                            children: Some(child_hashes.into()),
+                            galley: galley.clone(),
+                        },
+                    );
+                    galley
+                } else {
+                    let galley = super::layout(fonts, pixels_per_point, job);
+                    let galley = Arc::new(galley);
+                    entry.insert(CachedGalley {
+                        last_used: self.generation,
+                        children: None,
+                        galley: galley.clone(),
+                    });
+                    galley
+                }
+            }
+        };
+
+        (hash, galley)
+    }
+
+    fn layout(
+        &mut self,
+        fonts: &mut FontsImpl,
+        pixels_per_point: f32,
+        job: LayoutJob,
+        allow_split_paragraphs: bool,
+    ) -> Arc<Galley> {
+        self.layout_internal(fonts, job, pixels_per_point, allow_split_paragraphs)
+            .1
+    }
+
+    /// Split on `\n` and lay out (and cache) each paragraph individually.
+    fn layout_each_paragraph_individually(
+        &mut self,
+        fonts: &mut FontsImpl,
+        job: &LayoutJob,
+        pixels_per_point: f32,
+    ) -> (Vec<Arc<Galley>>, Vec<u64>) {
+        profiling::function_scope!();
+
+        let mut current_section = 0;
+        let mut start = 0;
+        let mut max_rows_remaining = job.wrap.max_rows;
+        let mut child_galleys = Vec::new();
+        let mut child_hashes = Vec::new();
+
+        while start < job.text.len() {
+            let is_first_paragraph = start == 0;
+            // `end` will not include the `\n` since we don't want to create an empty row in our
+            // split galley
+            let mut end = job.text[start..]
+                .find('\n')
+                .map_or(job.text.len(), |i| start + i);
+            if end == job.text.len() - 1 && job.text.ends_with('\n') {
+                end += 1; // If the text ends with a newline, we include it in the last paragraph.
+            }
+
+            let mut paragraph_job = LayoutJob {
+                text: job.text[start..end].to_owned(),
+                wrap: crate::text::TextWrapping {
+                    max_rows: max_rows_remaining,
+                    ..job.wrap
+                },
+                sections: Vec::new(),
+                break_on_newline: job.break_on_newline,
+                halign: job.halign,
+                justify: job.justify,
+                first_row_min_height: if is_first_paragraph {
+                    job.first_row_min_height
+                } else {
+                    0.0
+                },
+                round_output_to_gui: job.round_output_to_gui,
+            };
+
+            // Add overlapping sections:
+            for section in &job.sections[current_section..job.sections.len()] {
+                let LayoutSection {
+                    leading_space,
+                    byte_range: section_range,
+                    format,
+                } = section;
+
+                // `start` and `end` are the byte range of the current paragraph.
+                // How does the current section overlap with the paragraph range?
+
+                if section_range.end <= start {
+                    // The section is behind us
+                    current_section += 1;
+                } else if end < section_range.start {
+                    break; // Haven't reached this one yet.
+                } else {
+                    // Section range overlaps with paragraph range
+                    debug_assert!(
+                        section_range.start <= section_range.end,
+                        "Bad byte_range: {section_range:?}"
+                    );
+                    let new_range = section_range.start.saturating_sub(start)
+                        ..(section_range.end.at_most(end)).saturating_sub(start);
+                    debug_assert!(
+                        new_range.start <= new_range.end,
+                        "Bad new section range: {new_range:?}"
+                    );
+                    paragraph_job.sections.push(LayoutSection {
+                        leading_space: if start <= section_range.start {
+                            *leading_space
+                        } else {
+                            0.0
+                        },
+                        byte_range: new_range,
+                        format: format.clone(),
+                    });
+                }
+            }
+
+            // TODO(emilk): we could lay out each paragraph in parallel to get a nice speedup on multicore machines.
+            let (hash, galley) =
+                self.layout_internal(fonts, paragraph_job, pixels_per_point, false);
+            child_hashes.push(hash);
+
+            // This will prevent us from invalidating cache entries unnecessarily:
+            if max_rows_remaining != usize::MAX {
+                max_rows_remaining -= galley.rows.len();
+            }
+
+            let elided = galley.elided;
+            child_galleys.push(galley);
+            if elided {
+                break;
+            }
+
+            start = end + 1;
         }
+
+        (child_galleys, child_hashes)
     }
 
     pub fn num_galleys_in_cache(&self) -> usize {
@@ -791,73 +1073,243 @@ impl GalleyCache {
     }
 }
 
-// ----------------------------------------------------------------------------
-
-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>>,
+/// If true, lay out and cache each paragraph (sections separated by newlines) individually.
+///
+/// This makes it much faster to re-layout the full text when only a portion of it has changed since last frame, i.e. when editing somewhere in a file with thousands of lines/paragraphs.
+fn should_cache_each_paragraph_individually(job: &LayoutJob) -> bool {
+    // We currently don't support this elided text, i.e. when `max_rows` is set.
+    // Most often, elided text is elided to one row,
+    // and so will always be fast to lay out.
+    job.break_on_newline && job.wrap.max_rows == usize::MAX && job.text.contains('\n')
 }
 
-impl FontImplCache {
-    pub fn new(
-        atlas: Arc<Mutex<TextureAtlas>>,
-        pixels_per_point: f32,
-        font_data: &BTreeMap<String, Arc<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();
+#[cfg(feature = "default_fonts")]
+#[cfg(test)]
+mod tests {
+    use core::f32;
 
-        Self {
-            atlas,
-            pixels_per_point,
-            ab_glyph_fonts,
-            cache: Default::default(),
+    use super::*;
+    use crate::text::{TextWrapping, layout};
+    use crate::{Stroke, text::TextFormat};
+    use ecolor::Color32;
+    use emath::Align;
+
+    fn jobs() -> Vec<LayoutJob> {
+        vec![
+            LayoutJob::simple(
+                String::default(),
+                FontId::new(14.0, FontFamily::Monospace),
+                Color32::WHITE,
+                f32::INFINITY,
+            ),
+            LayoutJob::simple(
+                "ends with newlines\n\n".to_owned(),
+                FontId::new(14.0, FontFamily::Monospace),
+                Color32::WHITE,
+                f32::INFINITY,
+            ),
+            LayoutJob::simple(
+                "Simple test.".to_owned(),
+                FontId::new(14.0, FontFamily::Monospace),
+                Color32::WHITE,
+                f32::INFINITY,
+            ),
+            {
+                let mut job = LayoutJob::simple(
+                    "hi".to_owned(),
+                    FontId::default(),
+                    Color32::WHITE,
+                    f32::INFINITY,
+                );
+                job.append("\n", 0.0, TextFormat::default());
+                job.append("\n", 0.0, TextFormat::default());
+                job.append("world", 0.0, TextFormat::default());
+                job.wrap.max_rows = 2;
+                job
+            },
+            {
+                let mut job = LayoutJob::simple(
+                    "Test text with a lot of words\n and a newline.".to_owned(),
+                    FontId::new(14.0, FontFamily::Monospace),
+                    Color32::WHITE,
+                    40.0,
+                );
+                job.first_row_min_height = 30.0;
+                job
+            },
+            LayoutJob::simple(
+                "This some text that may be long.\nDet kanske också finns lite ÅÄÖ här.".to_owned(),
+                FontId::new(14.0, FontFamily::Proportional),
+                Color32::WHITE,
+                50.0,
+            ),
+            {
+                let mut job = LayoutJob {
+                    first_row_min_height: 20.0,
+                    ..Default::default()
+                };
+                job.append(
+                    "1st paragraph has underline and strikethrough, and has some non-ASCII characters:\n ÅÄÖ.",
+                    0.0,
+                    TextFormat {
+                        font_id: FontId::new(15.0, FontFamily::Monospace),
+                        underline: Stroke::new(1.0, Color32::RED),
+                        strikethrough: Stroke::new(1.0, Color32::GREEN),
+                        ..Default::default()
+                    },
+                );
+                job.append(
+                    "2nd paragraph has some leading space.\n",
+                    16.0,
+                    TextFormat {
+                        font_id: FontId::new(14.0, FontFamily::Proportional),
+                        ..Default::default()
+                    },
+                );
+                job.append(
+                    "3rd paragraph is kind of boring, but has italics.\nAnd a newline",
+                    0.0,
+                    TextFormat {
+                        font_id: FontId::new(10.0, FontFamily::Proportional),
+                        italics: true,
+                        ..Default::default()
+                    },
+                );
+
+                job
+            },
+            {
+                // Regression test for <https://github.com/emilk/egui/issues/7378>
+                let mut job = LayoutJob::default();
+                job.append("\n", 0.0, TextFormat::default());
+                job.append("", 0.0, TextFormat::default());
+                job
+            },
+        ]
+    }
+
+    #[expect(clippy::print_stdout)]
+    #[test]
+    fn test_split_paragraphs() {
+        for pixels_per_point in [1.0, 2.0_f32.sqrt(), 2.0] {
+            let max_texture_side = 4096;
+            let mut fonts = FontsImpl::new(
+                max_texture_side,
+                AlphaFromCoverage::default(),
+                FontDefinitions::default(),
+            );
+
+            for halign in [Align::Min, Align::Center, Align::Max] {
+                for justify in [false, true] {
+                    for mut job in jobs() {
+                        job.halign = halign;
+                        job.justify = justify;
+
+                        let whole = GalleyCache::default().layout(
+                            &mut fonts,
+                            pixels_per_point,
+                            job.clone(),
+                            false,
+                        );
+
+                        let split = GalleyCache::default().layout(
+                            &mut fonts,
+                            pixels_per_point,
+                            job.clone(),
+                            true,
+                        );
+
+                        for (i, row) in whole.rows.iter().enumerate() {
+                            println!(
+                                "Whole row {i}: section_index_at_start={}, first glyph section_index: {:?}",
+                                row.row.section_index_at_start,
+                                row.row.glyphs.first().map(|g| g.section_index)
+                            );
+                        }
+                        for (i, row) in split.rows.iter().enumerate() {
+                            println!(
+                                "Split row {i}: section_index_at_start={}, first glyph section_index: {:?}",
+                                row.row.section_index_at_start,
+                                row.row.glyphs.first().map(|g| g.section_index)
+                            );
+                        }
+
+                        // Don't compare for equaliity; but format with a specific precision and make sure we hit that.
+                        // NOTE: we use a rather low precision, because as long as we're within a pixel I think it's good enough.
+                        similar_asserts::assert_eq!(
+                            format!("{:#.1?}", split),
+                            format!("{:#.1?}", whole),
+                            "pixels_per_point: {pixels_per_point:.2}, input text: '{}'",
+                            job.text
+                        );
+                    }
+                }
+            }
         }
     }
 
-    pub fn font_impl(&mut self, scale_in_points: f32, font_name: &str) -> Arc<FontImpl> {
-        use ab_glyph::Font as _;
+    #[test]
+    fn test_intrinsic_size() {
+        let pixels_per_point = [1.0, 1.3, 2.0, 0.867];
+        let max_widths = [40.0, 80.0, 133.0, 200.0];
+        let rounded_output_to_gui = [false, true];
 
-        let (tweak, ab_glyph_font) = self
-            .ab_glyph_fonts
-            .get(font_name)
-            .unwrap_or_else(|| panic!("No font data found for {font_name:?}"))
-            .clone();
+        for pixels_per_point in pixels_per_point {
+            let mut fonts = FontsImpl::new(
+                1024,
+                AlphaFromCoverage::default(),
+                FontDefinitions::default(),
+            );
 
-        let scale_in_pixels = self.pixels_per_point * scale_in_points;
+            for &max_width in &max_widths {
+                for round_output_to_gui in rounded_output_to_gui {
+                    for mut job in jobs() {
+                        job.wrap = TextWrapping::wrap_at_width(max_width);
 
-        // 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 {font_name:?} exceeds the expected range (16..=16384)")
-        });
-        let font_scaling = ab_glyph_font.height_unscaled() / units_per_em;
-        let scale_in_pixels = scale_in_pixels * font_scaling;
+                        job.round_output_to_gui = round_output_to_gui;
 
-        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()
+                        let galley_wrapped =
+                            layout(&mut fonts, pixels_per_point, job.clone().into());
+
+                        job.wrap = TextWrapping::no_max_width();
+
+                        let text = job.text.clone();
+                        let galley_unwrapped = layout(&mut fonts, pixels_per_point, job.into());
+
+                        let intrinsic_size = galley_wrapped.intrinsic_size();
+                        let unwrapped_size = galley_unwrapped.size();
+
+                        let difference = (intrinsic_size - unwrapped_size).length().abs();
+                        similar_asserts::assert_eq!(
+                            format!("{intrinsic_size:.4?}"),
+                            format!("{unwrapped_size:.4?}"),
+                            "Wrapped intrinsic size should almost match unwrapped size. Intrinsic: {intrinsic_size:.8?} vs unwrapped: {unwrapped_size:.8?}
+                                Difference: {difference:.8?}
+                                wrapped rows: {}, unwrapped rows: {}
+                                pixels_per_point: {pixels_per_point}, text: {text:?}, max_width: {max_width}, round_output_to_gui: {round_output_to_gui}",
+                            galley_wrapped.rows.len(),
+                            galley_unwrapped.rows.len()
+                            );
+                        similar_asserts::assert_eq!(
+                            format!("{intrinsic_size:.4?}"),
+                            format!("{unwrapped_size:.4?}"),
+                            "Unwrapped galley intrinsic size should exactly match its size. \
+                                {:.8?} vs {:8?}",
+                            galley_unwrapped.intrinsic_size(),
+                            galley_unwrapped.size(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_fallback_glyph_width() {
+        let mut fonts = Fonts::new(1024, AlphaFromCoverage::default(), FontDefinitions::empty());
+        let mut view = fonts.with_pixels_per_point(1.0);
+
+        let width = view.glyph_width(&FontId::new(12.0, FontFamily::Proportional), ' ');
+        assert_eq!(width, 0.0);
     }
 }
diff --git a/crates/epaint/src/text/mod.rs b/crates/epaint/src/text/mod.rs
index 3cb0e98cb..e0f4a3a98 100644
--- a/crates/epaint/src/text/mod.rs
+++ b/crates/epaint/src/text/mod.rs
@@ -12,9 +12,9 @@ pub const TAB_SIZE: usize = 4;
 pub use {
     fonts::{
         FontData, FontDefinitions, FontFamily, FontId, FontInsert, FontPriority, FontTweak, Fonts,
-        FontsImpl, InsertFontFamily,
+        FontsImpl, FontsView, InsertFontFamily,
     },
-    text_layout::layout,
+    text_layout::*,
     text_layout_types::*,
 };
 
diff --git a/crates/epaint/src/text/text_layout.rs b/crates/epaint/src/text/text_layout.rs
index 4eb5965c6..1db56731d 100644
--- a/crates/epaint/src/text/text_layout.rs
+++ b/crates/epaint/src/text/text_layout.rs
@@ -1,11 +1,17 @@
-use std::ops::RangeInclusive;
 use std::sync::Arc;
 
-use emath::{pos2, vec2, Align, GuiRounding as _, NumExt, Pos2, Rect, Vec2};
+use emath::{Align, GuiRounding as _, NumExt as _, Pos2, Rect, Vec2, pos2, vec2};
 
-use crate::{stroke::PathStroke, text::font::Font, Color32, Mesh, Stroke, Vertex};
+use crate::{
+    Color32, Mesh, Stroke, Vertex,
+    stroke::PathStroke,
+    text::{
+        font::{ScaledMetrics, is_cjk, is_cjk_break_allowed},
+        fonts::FontFaceKey,
+    },
+};
 
-use super::{FontsImpl, Galley, Glyph, LayoutJob, LayoutSection, Row, RowVisuals};
+use super::{FontsImpl, Galley, Glyph, LayoutJob, LayoutSection, PlacedRow, Row, RowVisuals};
 
 // ----------------------------------------------------------------------------
 
@@ -42,8 +48,8 @@ impl PointScale {
 /// Temporary storage before line-wrapping.
 #[derive(Clone)]
 struct Paragraph {
-    /// Start of the next glyph to be added.
-    pub cursor_x: f32,
+    /// Start of the next glyph to be added. In screen-space / physical pixels.
+    pub cursor_x_px: f32,
 
     /// This is included in case there are no glyphs
     pub section_index_at_start: u32,
@@ -57,7 +63,7 @@ struct Paragraph {
 impl Paragraph {
     pub fn from_section_index(section_index_at_start: u32) -> Self {
         Self {
-            cursor_x: 0.0,
+            cursor_x_px: 0.0,
             section_index_at_start,
             glyphs: vec![],
             empty_paragraph_height: 0.0,
@@ -67,20 +73,23 @@ impl Paragraph {
 
 /// Layout text into a [`Galley`].
 ///
-/// In most cases you should use [`crate::Fonts::layout_job`] instead
+/// In most cases you should use [`crate::FontsView::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 {
+pub fn layout(fonts: &mut FontsImpl, pixels_per_point: f32, job: Arc<LayoutJob>) -> Galley {
+    profiling::function_scope!();
+
     if job.wrap.max_rows == 0 {
         // Early-out: no text
         return Galley {
             job,
             rows: Default::default(),
-            rect: Rect::from_min_max(Pos2::ZERO, Pos2::ZERO),
+            rect: Rect::ZERO,
             mesh_bounds: Rect::NOTHING,
             num_vertices: 0,
             num_indices: 0,
-            pixels_per_point: fonts.pixels_per_point(),
+            pixels_per_point,
             elided: true,
+            intrinsic_size: Vec2::ZERO,
         };
     }
 
@@ -88,19 +97,27 @@ pub fn layout(fonts: &mut FontsImpl, job: Arc<LayoutJob>) -> Galley {
 
     let mut paragraphs = vec![Paragraph::from_section_index(0)];
     for (section_index, section) in job.sections.iter().enumerate() {
-        layout_section(fonts, &job, section_index as u32, section, &mut paragraphs);
+        layout_section(
+            fonts,
+            pixels_per_point,
+            &job,
+            section_index as u32,
+            section,
+            &mut paragraphs,
+        );
     }
 
-    let point_scale = PointScale::new(fonts.pixels_per_point());
+    let point_scale = PointScale::new(pixels_per_point);
+
+    let intrinsic_size = calculate_intrinsic_size(point_scale, &job, &paragraphs);
 
     let mut elided = false;
     let mut rows = rows_from_paragraphs(paragraphs, &job, &mut elided);
-    if elided {
-        if let Some(last_row) = rows.last_mut() {
-            replace_last_glyph_with_overflow_character(fonts, &job, last_row);
-            if let Some(last) = last_row.glyphs.last() {
-                last_row.rect.max.x = last.max_x();
-            }
+    if elided && let Some(last_placed) = rows.last_mut() {
+        let last_row = Arc::make_mut(&mut last_placed.row);
+        replace_last_glyph_with_overflow_character(fonts, pixels_per_point, &job, last_row);
+        if let Some(last) = last_row.glyphs.last() {
+            last_row.size.x = last.max_x();
         }
     }
 
@@ -108,12 +125,12 @@ pub fn layout(fonts: &mut FontsImpl, job: Arc<LayoutJob>) -> Galley {
 
     if justify || job.halign != Align::LEFT {
         let num_rows = rows.len();
-        for (i, row) in rows.iter_mut().enumerate() {
+        for (i, placed_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;
+            let justify_row = justify && !placed_row.ends_with_newline && !is_last_row;
             halign_and_justify_row(
                 point_scale,
-                row,
+                placed_row,
                 job.halign,
                 job.wrap.max_width,
                 justify_row,
@@ -122,12 +139,13 @@ pub fn layout(fonts: &mut FontsImpl, job: Arc<LayoutJob>) -> Galley {
     }
 
     // Calculate the Y positions and tessellate the text:
-    galley_from_rows(point_scale, job, rows, elided)
+    galley_from_rows(point_scale, job, rows, elided, intrinsic_size)
 }
 
 // Ignores the Y coordinate.
 fn layout_section(
     fonts: &mut FontsImpl,
+    pixels_per_point: f32,
     job: &LayoutJob,
     section_index: u32,
     section: &LayoutSection,
@@ -138,11 +156,13 @@ fn layout_section(
         byte_range,
         format,
     } = section;
-    let font = fonts.font(&format.font_id);
+    let mut font = fonts.font(&format.font_id.family);
+    let font_size = format.font_id.size;
+    let font_metrics = font.scaled_metrics(pixels_per_point, font_size);
     let line_height = section
         .format
         .line_height
-        .unwrap_or_else(|| font.row_height());
+        .unwrap_or(font_metrics.row_height);
     let extra_letter_spacing = section.format.extra_letter_spacing;
 
     let mut paragraph = out_paragraphs.last_mut().unwrap();
@@ -150,47 +170,105 @@ fn layout_section(
         paragraph.empty_paragraph_height = line_height; // TODO(emilk): replace this hack with actually including `\n` in the glyphs?
     }
 
-    paragraph.cursor_x += leading_space;
+    paragraph.cursor_x_px += leading_space * pixels_per_point;
 
     let mut last_glyph_id = None;
 
+    // Optimization: only recompute `ScaledMetrics` when the concrete `FontImpl` changes.
+    let mut current_font = FontFaceKey::INVALID;
+    let mut current_font_impl_metrics = ScaledMetrics::default();
+
     for chr in job.text[byte_range.clone()].chars() {
         if job.break_on_newline && chr == '\n' {
             out_paragraphs.push(Paragraph::from_section_index(section_index));
             paragraph = out_paragraphs.last_mut().unwrap();
             paragraph.empty_paragraph_height = line_height; // TODO(emilk): replace this hack with actually including `\n` in the glyphs?
         } else {
-            let (font_impl, glyph_info) = font.font_impl_and_glyph_info(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.cursor_x += extra_letter_spacing;
-                }
+            let (font_id, glyph_info) = font.glyph_info(chr);
+            let mut font_impl = font.fonts_by_id.get_mut(&font_id);
+            if current_font != font_id {
+                current_font = font_id;
+                current_font_impl_metrics = font_impl
+                    .as_ref()
+                    .map(|font_impl| font_impl.scaled_metrics(pixels_per_point, font_size))
+                    .unwrap_or_default();
             }
 
+            if let (Some(font_impl), Some(last_glyph_id), Some(glyph_id)) =
+                (&font_impl, last_glyph_id, glyph_info.id)
+            {
+                paragraph.cursor_x_px += font_impl.pair_kerning_pixels(
+                    &current_font_impl_metrics,
+                    last_glyph_id,
+                    glyph_id,
+                );
+
+                // Only apply extra_letter_spacing to glyphs after the first one:
+                paragraph.cursor_x_px += extra_letter_spacing * pixels_per_point;
+            }
+
+            let (glyph_alloc, physical_x) = if let Some(font_impl) = font_impl.as_mut() {
+                font_impl.allocate_glyph(
+                    font.atlas,
+                    &current_font_impl_metrics,
+                    glyph_info,
+                    chr,
+                    paragraph.cursor_x_px,
+                )
+            } else {
+                Default::default()
+            };
+
             paragraph.glyphs.push(Glyph {
                 chr,
-                pos: pos2(paragraph.cursor_x, f32::NAN),
-                advance_width: glyph_info.advance_width,
+                pos: pos2(physical_x as f32 / pixels_per_point, f32::NAN),
+                advance_width: glyph_alloc.advance_width_px / pixels_per_point,
                 line_height,
-                font_impl_height: font_impl.map_or(0.0, |f| f.row_height()),
-                font_impl_ascent: font_impl.map_or(0.0, |f| f.ascent()),
-                font_height: font.row_height(),
-                font_ascent: font.ascent(),
-                uv_rect: glyph_info.uv_rect,
+                font_impl_height: current_font_impl_metrics.row_height,
+                font_impl_ascent: current_font_impl_metrics.ascent,
+                font_height: font_metrics.row_height,
+                font_ascent: font_metrics.ascent,
+                uv_rect: glyph_alloc.uv_rect,
                 section_index,
+                first_vertex: 0, // filled in later
             });
 
-            paragraph.cursor_x += glyph_info.advance_width;
-            paragraph.cursor_x = font.round_to_pixel(paragraph.cursor_x);
-            last_glyph_id = Some(glyph_info.id);
+            paragraph.cursor_x_px += glyph_alloc.advance_width_px;
+            last_glyph_id = Some(glyph_alloc.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)
+/// Calculate the intrinsic size of the text.
+///
+/// The result is eventually passed to `Response::intrinsic_size`.
+/// This works by calculating the size of each `Paragraph` (instead of each `Row`).
+fn calculate_intrinsic_size(
+    point_scale: PointScale,
+    job: &LayoutJob,
+    paragraphs: &[Paragraph],
+) -> Vec2 {
+    let mut intrinsic_size = Vec2::ZERO;
+    for (idx, paragraph) in paragraphs.iter().enumerate() {
+        let width = paragraph
+            .glyphs
+            .last()
+            .map(|l| l.max_x())
+            .unwrap_or_default();
+        intrinsic_size.x = f32::max(intrinsic_size.x, width);
+
+        let mut height = paragraph
+            .glyphs
+            .iter()
+            .map(|g| g.line_height)
+            .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+            .unwrap_or(paragraph.empty_paragraph_height);
+        if idx == 0 {
+            height = f32::max(height, job.first_row_min_height);
+        }
+        intrinsic_size.y += point_scale.round_to_pixel(height);
+    }
+    intrinsic_size
 }
 
 // Ignores the Y coordinate.
@@ -198,7 +276,7 @@ fn rows_from_paragraphs(
     paragraphs: Vec<Paragraph>,
     job: &LayoutJob,
     elided: &mut bool,
-) -> Vec<Row> {
+) -> Vec<PlacedRow> {
     let num_paragraphs = paragraphs.len();
 
     let mut rows = vec![];
@@ -212,31 +290,34 @@ fn rows_from_paragraphs(
         let is_last_paragraph = (i + 1) == num_paragraphs;
 
         if paragraph.glyphs.is_empty() {
-            rows.push(Row {
-                section_index_at_start: paragraph.section_index_at_start,
-                glyphs: vec![],
-                visuals: Default::default(),
-                rect: Rect::from_min_size(
-                    pos2(paragraph.cursor_x, 0.0),
-                    vec2(0.0, paragraph.empty_paragraph_height),
-                ),
+            rows.push(PlacedRow {
+                pos: pos2(0.0, f32::NAN),
+                row: Arc::new(Row {
+                    section_index_at_start: paragraph.section_index_at_start,
+                    glyphs: vec![],
+                    visuals: Default::default(),
+                    size: 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.effective_wrap_width() {
                 // Early-out optimization: the whole paragraph fits on one row.
-                let paragraph_min_x = paragraph.glyphs[0].pos.x;
-                rows.push(Row {
-                    section_index_at_start: paragraph.section_index_at_start,
-                    glyphs: paragraph.glyphs,
-                    visuals: Default::default(),
-                    rect: rect_from_x_range(paragraph_min_x..=paragraph_max_x),
+                rows.push(PlacedRow {
+                    pos: pos2(0.0, f32::NAN),
+                    row: Arc::new(Row {
+                        section_index_at_start: paragraph.section_index_at_start,
+                        glyphs: paragraph.glyphs,
+                        visuals: Default::default(),
+                        size: vec2(paragraph_max_x, 0.0),
+                    }),
                     ends_with_newline: !is_last_paragraph,
                 });
             } else {
                 line_break(&paragraph, job, &mut rows, elided);
-                rows.last_mut().unwrap().ends_with_newline = !is_last_paragraph;
+                let placed_row = rows.last_mut().unwrap();
+                placed_row.ends_with_newline = !is_last_paragraph;
             }
         }
     }
@@ -244,7 +325,12 @@ fn rows_from_paragraphs(
     rows
 }
 
-fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, elided: &mut bool) {
+fn line_break(
+    paragraph: &Paragraph,
+    job: &LayoutJob,
+    out_rows: &mut Vec<PlacedRow>,
+    elided: &mut bool,
+) {
     let wrap_width = job.effective_wrap_width();
 
     // Keeps track of good places to insert row break if we exceed `wrap_width`.
@@ -270,11 +356,14 @@ fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, e
             {
                 // 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 {
-                    section_index_at_start: paragraph.section_index_at_start,
-                    glyphs: vec![],
-                    visuals: Default::default(),
-                    rect: rect_from_x_range(first_row_indentation..=first_row_indentation),
+                out_rows.push(PlacedRow {
+                    pos: pos2(0.0, f32::NAN),
+                    row: Arc::new(Row {
+                        section_index_at_start: paragraph.section_index_at_start,
+                        glyphs: vec![],
+                        visuals: Default::default(),
+                        size: Vec2::ZERO,
+                    }),
                     ends_with_newline: false,
                 });
                 row_start_x += first_row_indentation;
@@ -291,14 +380,16 @@ fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, e
                     .collect();
 
                 let section_index_at_start = glyphs[0].section_index;
-                let paragraph_min_x = glyphs[0].pos.x;
                 let paragraph_max_x = glyphs.last().unwrap().max_x();
 
-                out_rows.push(Row {
-                    section_index_at_start,
-                    glyphs,
-                    visuals: Default::default(),
-                    rect: rect_from_x_range(paragraph_min_x..=paragraph_max_x),
+                out_rows.push(PlacedRow {
+                    pos: pos2(0.0, f32::NAN),
+                    row: Arc::new(Row {
+                        section_index_at_start,
+                        glyphs,
+                        visuals: Default::default(),
+                        size: vec2(paragraph_max_x, 0.0),
+                    }),
                     ends_with_newline: false,
                 });
 
@@ -333,11 +424,14 @@ fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, e
             let paragraph_min_x = glyphs[0].pos.x;
             let paragraph_max_x = glyphs.last().unwrap().max_x();
 
-            out_rows.push(Row {
-                section_index_at_start,
-                glyphs,
-                visuals: Default::default(),
-                rect: rect_from_x_range(paragraph_min_x..=paragraph_max_x),
+            out_rows.push(PlacedRow {
+                pos: pos2(paragraph_min_x, 0.0),
+                row: Arc::new(Row {
+                    section_index_at_start,
+                    glyphs,
+                    visuals: Default::default(),
+                    size: vec2(paragraph_max_x - paragraph_min_x, 0.0),
+                }),
                 ends_with_newline: false,
             });
         }
@@ -349,149 +443,106 @@ fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, e
 /// Called before we have any Y coordinates.
 fn replace_last_glyph_with_overflow_character(
     fonts: &mut FontsImpl,
+    pixels_per_point: f32,
     job: &LayoutJob,
     row: &mut Row,
 ) {
-    fn row_width(row: &Row) -> f32 {
-        if let (Some(first), Some(last)) = (row.glyphs.first(), row.glyphs.last()) {
-            last.max_x() - first.pos.x
-        } else {
-            0.0
-        }
-    }
-
-    fn row_height(section: &LayoutSection, font: &Font) -> f32 {
-        section
-            .format
-            .line_height
-            .unwrap_or_else(|| font.row_height())
-    }
-
     let Some(overflow_character) = job.wrap.overflow_character else {
         return;
     };
 
-    // We always try to just append the character first:
-    if let Some(last_glyph) = row.glyphs.last() {
-        let section_index = last_glyph.section_index;
-        let section = &job.sections[section_index as usize];
-        let font = fonts.font(&section.format.font_id);
-        let line_height = row_height(section, font);
-
-        let (_, last_glyph_info) = font.font_impl_and_glyph_info(last_glyph.chr);
-
-        let mut x = last_glyph.pos.x + last_glyph.advance_width;
-
-        let (font_impl, replacement_glyph_info) = font.font_impl_and_glyph_info(overflow_character);
-
-        {
-            // Kerning:
-            x += section.format.extra_letter_spacing;
-            if let Some(font_impl) = font_impl {
-                x += font_impl.pair_kerning(last_glyph_info.id, replacement_glyph_info.id);
-            }
-        }
-
-        row.glyphs.push(Glyph {
-            chr: overflow_character,
-            pos: pos2(x, f32::NAN),
-            advance_width: replacement_glyph_info.advance_width,
-            line_height,
-            font_impl_height: font_impl.map_or(0.0, |f| f.row_height()),
-            font_impl_ascent: font_impl.map_or(0.0, |f| f.ascent()),
-            font_height: font.row_height(),
-            font_ascent: font.ascent(),
-            uv_rect: replacement_glyph_info.uv_rect,
-            section_index,
-        });
-    } else {
-        let section_index = row.section_index_at_start;
-        let section = &job.sections[section_index as usize];
-        let font = fonts.font(&section.format.font_id);
-        let line_height = row_height(section, font);
-
-        let x = 0.0; // TODO(emilk): heed paragraph leading_space 😬
-
-        let (font_impl, replacement_glyph_info) = font.font_impl_and_glyph_info(overflow_character);
-
-        row.glyphs.push(Glyph {
-            chr: overflow_character,
-            pos: pos2(x, f32::NAN),
-            advance_width: replacement_glyph_info.advance_width,
-            line_height,
-            font_impl_height: font_impl.map_or(0.0, |f| f.row_height()),
-            font_impl_ascent: font_impl.map_or(0.0, |f| f.ascent()),
-            font_height: font.row_height(),
-            font_ascent: font.ascent(),
-            uv_rect: replacement_glyph_info.uv_rect,
-            section_index,
-        });
-    }
-
-    if row_width(row) <= job.effective_wrap_width() || row.glyphs.len() == 1 {
-        return; // we are done
-    }
-
-    // We didn't fit it. Remove it again…
-    row.glyphs.pop();
-
-    // …then go into a loop where we replace the last character with the overflow character
-    // until we fit within the max_width:
-
+    let mut section_index = row
+        .glyphs
+        .last()
+        .map(|g| g.section_index)
+        .unwrap_or(row.section_index_at_start);
     loop {
-        let (prev_glyph, last_glyph) = match row.glyphs.as_mut_slice() {
-            [.., prev, last] => (Some(prev), last),
-            [.., last] => (None, last),
-            _ => {
-                unreachable!("We've already explicitly handled the empty row");
-            }
+        let section = &job.sections[section_index as usize];
+        let extra_letter_spacing = section.format.extra_letter_spacing;
+        let mut font = fonts.font(&section.format.font_id.family);
+        let font_size = section.format.font_id.size;
+
+        let (font_id, glyph_info) = font.glyph_info(overflow_character);
+        let mut font_impl = font.fonts_by_id.get_mut(&font_id);
+        let font_impl_metrics = font_impl
+            .as_mut()
+            .map(|f| f.scaled_metrics(pixels_per_point, font_size))
+            .unwrap_or_default();
+
+        let overflow_glyph_x = if let Some(prev_glyph) = row.glyphs.last() {
+            // Kern the overflow character properly
+            let pair_kerning = font_impl
+                .as_mut()
+                .map(|font_impl| {
+                    if let (Some(prev_glyph_id), Some(overflow_glyph_id)) = (
+                        font_impl.glyph_info(prev_glyph.chr).and_then(|g| g.id),
+                        font_impl.glyph_info(overflow_character).and_then(|g| g.id),
+                    ) {
+                        font_impl.pair_kerning(&font_impl_metrics, prev_glyph_id, overflow_glyph_id)
+                    } else {
+                        0.0
+                    }
+                })
+                .unwrap_or_default();
+
+            prev_glyph.max_x() + extra_letter_spacing + pair_kerning
+        } else {
+            0.0 // TODO(emilk): heed paragraph leading_space 😬
         };
 
-        let section = &job.sections[last_glyph.section_index as usize];
-        let extra_letter_spacing = section.format.extra_letter_spacing;
-        let font = fonts.font(&section.format.font_id);
+        let replacement_glyph_width = font_impl
+            .as_mut()
+            .and_then(|f| f.glyph_info(overflow_character))
+            .map(|i| i.advance_width_unscaled.0 * font_impl_metrics.px_scale_factor)
+            .unwrap_or_default();
 
-        if let Some(prev_glyph) = prev_glyph {
-            let prev_glyph_id = font.font_impl_and_glyph_info(prev_glyph.chr).1.id;
+        // Check if we're within width budget:
+        if overflow_glyph_x + replacement_glyph_width <= job.effective_wrap_width()
+            || row.glyphs.is_empty()
+        {
+            // we are done
 
-            // Undo kerning with previous glyph:
-            let (font_impl, glyph_info) = font.font_impl_and_glyph_info(last_glyph.chr);
-            last_glyph.pos.x -= extra_letter_spacing;
-            if let Some(font_impl) = font_impl {
-                last_glyph.pos.x -= font_impl.pair_kerning(prev_glyph_id, glyph_info.id);
-            }
+            let (replacement_glyph_alloc, physical_x) = font_impl
+                .as_mut()
+                .map(|f| {
+                    f.allocate_glyph(
+                        font.atlas,
+                        &font_impl_metrics,
+                        glyph_info,
+                        overflow_character,
+                        overflow_glyph_x * pixels_per_point,
+                    )
+                })
+                .unwrap_or_default();
 
-            // Replace the glyph:
-            last_glyph.chr = overflow_character;
-            let (font_impl, glyph_info) = font.font_impl_and_glyph_info(last_glyph.chr);
-            last_glyph.advance_width = glyph_info.advance_width;
-            last_glyph.font_impl_ascent = font_impl.map_or(0.0, |f| f.ascent());
-            last_glyph.font_impl_height = font_impl.map_or(0.0, |f| f.row_height());
-            last_glyph.uv_rect = glyph_info.uv_rect;
+            let font_metrics = font.scaled_metrics(pixels_per_point, font_size);
+            let line_height = section
+                .format
+                .line_height
+                .unwrap_or(font_metrics.row_height);
 
-            // Reapply kerning:
-            last_glyph.pos.x += extra_letter_spacing;
-            if let Some(font_impl) = font_impl {
-                last_glyph.pos.x += font_impl.pair_kerning(prev_glyph_id, glyph_info.id);
-            }
-
-            // Check if we're within width budget:
-            if row_width(row) <= job.effective_wrap_width() || row.glyphs.len() == 1 {
-                return; // We are done
-            }
-
-            // We didn't fit - pop the last glyph and try again.
-            row.glyphs.pop();
-        } else {
-            // Just replace and be done with it.
-            last_glyph.chr = overflow_character;
-            let (font_impl, glyph_info) = font.font_impl_and_glyph_info(last_glyph.chr);
-            last_glyph.advance_width = glyph_info.advance_width;
-            last_glyph.font_impl_ascent = font_impl.map_or(0.0, |f| f.ascent());
-            last_glyph.font_impl_height = font_impl.map_or(0.0, |f| f.row_height());
-            last_glyph.uv_rect = glyph_info.uv_rect;
+            row.glyphs.push(Glyph {
+                chr: overflow_character,
+                pos: pos2(physical_x as f32 / pixels_per_point, f32::NAN),
+                advance_width: replacement_glyph_alloc.advance_width_px / pixels_per_point,
+                line_height,
+                font_impl_height: font_impl_metrics.row_height,
+                font_impl_ascent: font_impl_metrics.ascent,
+                font_height: font_metrics.row_height,
+                font_ascent: font_metrics.ascent,
+                uv_rect: replacement_glyph_alloc.uv_rect,
+                section_index,
+                first_vertex: 0, // filled in later
+            });
             return;
         }
+
+        // We didn't fit - pop the last glyph and try again.
+        if let Some(last_glyph) = row.glyphs.pop() {
+            section_index = last_glyph.section_index;
+        } else {
+            section_index = row.section_index_at_start;
+        }
     }
 }
 
@@ -500,11 +551,15 @@ fn replace_last_glyph_with_overflow_character(
 /// Ignores the Y coordinate.
 fn halign_and_justify_row(
     point_scale: PointScale,
-    row: &mut Row,
+    placed_row: &mut PlacedRow,
     halign: Align,
     wrap_width: f32,
     justify: bool,
 ) {
+    #![expect(clippy::useless_let_if_seq)] // False positive
+
+    let row = Arc::make_mut(&mut placed_row.row);
+
     if row.glyphs.is_empty() {
         return;
     }
@@ -529,7 +584,7 @@ fn halign_and_justify_row(
         (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);
+    assert!(num_glyphs_in_range > 0, "Should have at least one glyph");
 
     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;
@@ -572,7 +627,8 @@ fn halign_and_justify_row(
             / (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;
+    placed_row.pos.x = point_scale.round_to_pixel(target_min_x);
+    let mut translate_x = -original_min_x - extra_x_per_glyph * glyph_range.0 as f32;
 
     for glyph in &mut row.glyphs {
         glyph.pos.x += translate_x;
@@ -584,26 +640,27 @@ fn halign_and_justify_row(
     }
 
     // Note we ignore the leading/trailing whitespace here!
-    row.rect.min.x = target_min_x;
-    row.rect.max.x = target_max_x;
+    row.size.x = target_max_x - target_min_x;
 }
 
 /// Calculate the Y positions and tessellate the text.
 fn galley_from_rows(
     point_scale: PointScale,
     job: Arc<LayoutJob>,
-    mut rows: Vec<Row>,
+    mut rows: Vec<PlacedRow>,
     elided: bool,
+    intrinsic_size: Vec2,
 ) -> 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 max_row_height = first_row_min_height.max(row.rect.height());
+
+    for placed_row in &mut rows {
+        let mut max_row_height = first_row_min_height.at_least(placed_row.height());
+        let row = Arc::make_mut(&mut placed_row.row);
+
         first_row_min_height = 0.0;
         for glyph in &row.glyphs {
-            max_row_height = max_row_height.max(glyph.line_height);
+            max_row_height = max_row_height.at_least(glyph.line_height);
         }
         max_row_height = point_scale.round_to_pixel(max_row_height);
 
@@ -611,8 +668,7 @@ fn galley_from_rows(
         for glyph in &mut row.glyphs {
             let format = &job.sections[glyph.section_index as usize].format;
 
-            glyph.pos.y = cursor_y
-                + glyph.font_impl_ascent
+            glyph.pos.y = glyph.font_impl_ascent
 
                 // Apply valign to the different in height of the entire row, and the height of this `Font`:
                 + format.valign.to_factor() * (max_row_height - glyph.line_height)
@@ -624,53 +680,37 @@ fn galley_from_rows(
             glyph.pos.y = point_scale.round_to_pixel(glyph.pos.y);
         }
 
-        row.rect.min.y = cursor_y;
-        row.rect.max.y = cursor_y + max_row_height;
+        placed_row.pos.y = cursor_y;
+        row.size.y = max_row_height;
 
-        min_x = min_x.min(row.rect.min.x);
-        max_x = max_x.max(row.rect.max.x);
         cursor_y += max_row_height;
         cursor_y = point_scale.round_to_pixel(cursor_y); // TODO(emilk): it would be better to do the calculations in pixels instead.
     }
 
     let format_summary = format_summary(&job);
 
+    let mut rect = Rect::ZERO;
     let mut mesh_bounds = Rect::NOTHING;
     let mut num_vertices = 0;
     let mut num_indices = 0;
 
-    for row in &mut rows {
+    for placed_row in &mut rows {
+        rect |= placed_row.rect();
+
+        let row = Arc::make_mut(&mut placed_row.row);
         row.visuals = tessellate_row(point_scale, &job, &format_summary, row);
-        mesh_bounds = mesh_bounds.union(row.visuals.mesh_bounds);
+
+        mesh_bounds |= row.visuals.mesh_bounds.translate(placed_row.pos.to_vec2());
         num_vertices += row.visuals.mesh.vertices.len();
         num_indices += row.visuals.mesh.indices.len();
-    }
 
-    let mut rect = Rect::from_min_max(pos2(min_x, 0.0), pos2(max_x, cursor_y));
-
-    if job.round_output_to_gui {
-        for row in &mut rows {
-            row.rect = row.rect.round_ui();
-        }
-
-        let did_exceed_wrap_width_by_a_lot = rect.width() > job.wrap.max_width + 1.0;
-
-        rect = rect.round_ui();
-
-        if did_exceed_wrap_width_by_a_lot {
-            // If the user picked a too aggressive wrap width (e.g. more narrow than any individual glyph),
-            // we should let the user know by reporting that our width is wider than the wrap width.
-        } else {
-            // Make sure we don't report being wider than the wrap width the user picked:
-            rect.max.x = rect
-                .max
-                .x
-                .at_most(rect.min.x + job.wrap.max_width)
-                .floor_ui();
+        row.section_index_at_start = u32::MAX; // No longer in use.
+        for glyph in &mut row.glyphs {
+            glyph.section_index = u32::MAX; // No longer in use.
         }
     }
 
-    Galley {
+    let mut galley = Galley {
         job,
         rows,
         elided,
@@ -679,7 +719,14 @@ fn galley_from_rows(
         num_vertices,
         num_indices,
         pixels_per_point: point_scale.pixels_per_point,
+        intrinsic_size,
+    };
+
+    if galley.job.round_output_to_gui {
+        galley.round_output_to_gui();
     }
+
+    galley
 }
 
 #[derive(Default)]
@@ -703,7 +750,7 @@ fn tessellate_row(
     point_scale: PointScale,
     job: &LayoutJob,
     format_summary: &FormatSummary,
-    row: &Row,
+    row: &mut Row,
 ) -> RowVisuals {
     if row.glyphs.is_empty() {
         return Default::default();
@@ -715,7 +762,7 @@ fn tessellate_row(
     mesh.reserve_vertices(row.glyphs.len() * 4);
 
     if format_summary.any_background {
-        add_row_backgrounds(job, row, &mut mesh);
+        add_row_backgrounds(point_scale, job, row, &mut mesh);
     }
 
     let glyph_index_start = mesh.indices.len();
@@ -753,15 +800,16 @@ fn tessellate_row(
 
 /// 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) {
+fn add_row_backgrounds(point_scale: PointScale, 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 mut end_run = |start: Option<(Color32, Rect, f32)>, stop_x: f32| {
+        if let Some((color, start_rect, expand)) = 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
+            let rect = rect.expand(expand);
+            let rect = rect.round_to_pixels(point_scale.pixels_per_point());
             mesh.add_colored_rect(rect, color);
         }
     };
@@ -776,18 +824,19 @@ fn add_row_backgrounds(job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
 
         if color == Color32::TRANSPARENT {
             end_run(run_start.take(), last_rect.right());
-        } else if let Some((existing_color, start)) = run_start {
+        } else if let Some((existing_color, start, expand)) = run_start {
             if existing_color == color
                 && start.top() == rect.top()
                 && start.bottom() == rect.bottom()
+                && format.expand_bg == expand
             {
                 // continue the same background rectangle
             } else {
                 end_run(run_start.take(), last_rect.right());
-                run_start = Some((color, rect));
+                run_start = Some((color, rect, format.expand_bg));
             }
         } else {
-            run_start = Some((color, rect));
+            run_start = Some((color, rect, format.expand_bg));
         }
 
         last_rect = rect;
@@ -796,8 +845,9 @@ fn add_row_backgrounds(job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
     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 {
+fn tessellate_glyphs(point_scale: PointScale, job: &LayoutJob, row: &mut Row, mesh: &mut Mesh) {
+    for glyph in &mut row.glyphs {
+        glyph.first_vertex = mesh.vertices.len() as u32;
         let uv_rect = glyph.uv_rect;
         if !uv_rect.is_nothing() {
             let mut left_top = glyph.pos + uv_rect.offset;
@@ -855,9 +905,15 @@ fn add_row_hline(
     mesh: &mut Mesh,
     stroke_and_y: impl Fn(&Glyph) -> (Stroke, f32),
 ) {
+    let mut path = crate::tessellator::Path::default(); // reusing path to avoid re-allocations.
+
     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 stop = pos2(stop_x, start.y);
+            path.clear();
+            path.add_line_segment([start, stop]);
+            let feathering = 1.0 / point_scale.pixels_per_point();
+            path.stroke_open(feathering, &PathStroke::from(stroke), mesh);
         }
     };
 
@@ -865,9 +921,10 @@ fn add_row_hline(
     let mut last_right_x = f32::NAN;
 
     for glyph in &row.glyphs {
-        let (stroke, y) = stroke_and_y(glyph);
+        let (stroke, mut y) = stroke_and_y(glyph);
+        stroke.round_center_to_pixel(point_scale.pixels_per_point, &mut y);
 
-        if stroke == Stroke::NONE {
+        if stroke.is_empty() {
             end_line(line_start.take(), last_right_x);
         } else if let Some((existing_stroke, start)) = line_start {
             if existing_stroke == stroke && start.y == y {
@@ -886,31 +943,6 @@ fn add_row_hline(
     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, &PathStroke::from(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.
@@ -1014,43 +1046,25 @@ impl RowBreakCandidates {
     }
 }
 
-#[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(bigfarts): 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)
-}
-
 // ----------------------------------------------------------------------------
 
 #[cfg(test)]
 mod tests {
+    use crate::AlphaFromCoverage;
+
     use super::{super::*, *};
 
     #[test]
     fn test_zero_max_width() {
-        let mut fonts = FontsImpl::new(1.0, 1024, FontDefinitions::default());
+        let pixels_per_point = 1.0;
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
         let mut layout_job = LayoutJob::single_section("W".into(), TextFormat::default());
         layout_job.wrap.max_width = 0.0;
-        let galley = layout(&mut fonts, layout_job.into());
+        let galley = layout(&mut fonts, pixels_per_point, layout_job.into());
         assert_eq!(galley.rows.len(), 1);
     }
 
@@ -1058,7 +1072,13 @@ mod tests {
     fn test_truncate_with_newline() {
         // No matter where we wrap, we should be appending the newline character.
 
-        let mut fonts = FontsImpl::new(1.0, 1024, FontDefinitions::default());
+        let pixels_per_point = 1.0;
+
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
         let text_format = TextFormat {
             font_id: FontId::monospace(12.0),
             ..Default::default()
@@ -1073,7 +1093,7 @@ mod tests {
                     layout_job.wrap.max_rows = 1;
                     layout_job.wrap.break_anywhere = break_anywhere;
 
-                    let galley = layout(&mut fonts, layout_job.into());
+                    let galley = layout(&mut fonts, pixels_per_point, layout_job.into());
 
                     assert!(galley.elided);
                     assert_eq!(galley.rows.len(), 1);
@@ -1092,7 +1112,7 @@ mod tests {
             layout_job.wrap.max_rows = 1;
             layout_job.wrap.break_anywhere = false;
 
-            let galley = layout(&mut fonts, layout_job.into());
+            let galley = layout(&mut fonts, pixels_per_point, layout_job.into());
 
             assert!(galley.elided);
             assert_eq!(galley.rows.len(), 1);
@@ -1103,13 +1123,18 @@ mod tests {
 
     #[test]
     fn test_cjk() {
-        let mut fonts = FontsImpl::new(1.0, 1024, FontDefinitions::default());
+        let pixels_per_point = 1.0;
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
         let mut layout_job = LayoutJob::single_section(
             "日本語とEnglishの混在した文章".into(),
             TextFormat::default(),
         );
         layout_job.wrap.max_width = 90.0;
-        let galley = layout(&mut fonts, layout_job.into());
+        let galley = layout(&mut fonts, pixels_per_point, layout_job.into());
         assert_eq!(
             galley.rows.iter().map(|row| row.text()).collect::<Vec<_>>(),
             vec!["日本語と", "Englishの混在", "した文章"]
@@ -1118,13 +1143,18 @@ mod tests {
 
     #[test]
     fn test_pre_cjk() {
-        let mut fonts = FontsImpl::new(1.0, 1024, FontDefinitions::default());
+        let pixels_per_point = 1.0;
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
         let mut layout_job = LayoutJob::single_section(
             "日本語とEnglishの混在した文章".into(),
             TextFormat::default(),
         );
         layout_job.wrap.max_width = 110.0;
-        let galley = layout(&mut fonts, layout_job.into());
+        let galley = layout(&mut fonts, pixels_per_point, layout_job.into());
         assert_eq!(
             galley.rows.iter().map(|row| row.text()).collect::<Vec<_>>(),
             vec!["日本語とEnglish", "の混在した文章"]
@@ -1133,19 +1163,99 @@ mod tests {
 
     #[test]
     fn test_truncate_width() {
-        let mut fonts = FontsImpl::new(1.0, 1024, FontDefinitions::default());
+        let pixels_per_point = 1.0;
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
         let mut layout_job =
             LayoutJob::single_section("# DNA\nMore text".into(), TextFormat::default());
         layout_job.wrap.max_width = f32::INFINITY;
         layout_job.wrap.max_rows = 1;
         layout_job.round_output_to_gui = false;
-        let galley = layout(&mut fonts, layout_job.into());
+        let galley = layout(&mut fonts, pixels_per_point, layout_job.into());
         assert!(galley.elided);
         assert_eq!(
             galley.rows.iter().map(|row| row.text()).collect::<Vec<_>>(),
             vec!["# DNA…"]
         );
         let row = &galley.rows[0];
-        assert_eq!(row.rect.max.x, row.glyphs.last().unwrap().max_x());
+        assert_eq!(row.pos, Pos2::ZERO);
+        assert_eq!(row.rect().max.x, row.glyphs.last().unwrap().max_x());
+    }
+
+    #[test]
+    fn test_empty_row() {
+        let pixels_per_point = 1.0;
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
+
+        let font_id = FontId::default();
+        let font_height = fonts
+            .font(&font_id.family)
+            .scaled_metrics(pixels_per_point, font_id.size)
+            .row_height;
+
+        let job = LayoutJob::simple(String::new(), font_id, Color32::WHITE, f32::INFINITY);
+
+        let galley = layout(&mut fonts, pixels_per_point, job.into());
+
+        assert_eq!(galley.rows.len(), 1, "Expected one row");
+        assert_eq!(
+            galley.rows[0].row.glyphs.len(),
+            0,
+            "Expected no glyphs in the empty row"
+        );
+        assert_eq!(
+            galley.size(),
+            Vec2::new(0.0, font_height.round()),
+            "Unexpected galley size"
+        );
+        assert_eq!(
+            galley.intrinsic_size(),
+            Vec2::new(0.0, font_height.round()),
+            "Unexpected intrinsic size"
+        );
+    }
+
+    #[test]
+    fn test_end_with_newline() {
+        let pixels_per_point = 1.0;
+        let mut fonts = FontsImpl::new(
+            1024,
+            AlphaFromCoverage::default(),
+            FontDefinitions::default(),
+        );
+
+        let font_id = FontId::default();
+        let font_height = fonts
+            .font(&font_id.family)
+            .scaled_metrics(pixels_per_point, font_id.size)
+            .row_height;
+
+        let job = LayoutJob::simple("Hi!\n".to_owned(), font_id, Color32::WHITE, f32::INFINITY);
+
+        let galley = layout(&mut fonts, pixels_per_point, job.into());
+
+        assert_eq!(galley.rows.len(), 2, "Expected two rows");
+        assert_eq!(
+            galley.rows[1].row.glyphs.len(),
+            0,
+            "Expected no glyphs in the empty row"
+        );
+        assert_eq!(
+            galley.size().round(),
+            Vec2::new(17.0, font_height.round() * 2.0),
+            "Unexpected galley size"
+        );
+        assert_eq!(
+            galley.intrinsic_size().round(),
+            Vec2::new(17.0, font_height.round() * 2.0),
+            "Unexpected intrinsic size"
+        );
     }
 }
diff --git a/crates/epaint/src/text/text_layout_types.rs b/crates/epaint/src/text/text_layout_types.rs
index b228d023e..f3963394a 100644
--- a/crates/epaint/src/text/text_layout_types.rs
+++ b/crates/epaint/src/text/text_layout_types.rs
@@ -5,17 +5,17 @@ use std::ops::Range;
 use std::sync::Arc;
 
 use super::{
-    cursor::{CCursor, Cursor, PCursor, RCursor},
+    cursor::{CCursor, LayoutCursor},
     font::UvRect,
 };
-use crate::{Color32, FontId, Mesh, Stroke};
-use emath::{pos2, vec2, Align, NumExt, OrderedFloat, Pos2, Rect, Vec2};
+use crate::{Color32, FontId, Mesh, Stroke, text::FontsView};
+use emath::{Align, GuiRounding as _, NumExt as _, OrderedFloat, Pos2, Rect, Vec2, pos2, vec2};
 
 /// 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`].
+/// Pass this to [`crate::FontsView::layout_job`] or [`crate::text::layout`].
 ///
 /// ## Example:
 /// ```
@@ -118,6 +118,21 @@ impl LayoutJob {
         }
     }
 
+    /// Break on `\n`
+    #[inline]
+    pub fn simple_format(text: String, format: TextFormat) -> Self {
+        Self {
+            sections: vec![LayoutSection {
+                leading_space: 0.0,
+                byte_range: 0..text.len(),
+                format,
+            }],
+            text,
+            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 {
@@ -169,7 +184,7 @@ impl LayoutJob {
     /// The height of the tallest font used in the job.
     ///
     /// Returns a value rounded to [`emath::GUI_ROUNDING`].
-    pub fn font_height(&self, fonts: &crate::Fonts) -> f32 {
+    pub fn font_height(&self, fonts: &mut FontsView<'_>) -> 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));
@@ -254,8 +269,6 @@ pub struct TextFormat {
     /// Extra spacing between letters, in points.
     ///
     /// Default: 0.0.
-    ///
-    /// For even text it is recommended you round this to an even number of _pixels_.
     pub extra_letter_spacing: f32,
 
     /// Explicit line height of the text in points.
@@ -272,6 +285,11 @@ pub struct TextFormat {
 
     pub background: Color32,
 
+    /// Amount to expand background fill by.
+    ///
+    /// Default: 1.0
+    pub expand_bg: f32,
+
     pub italics: bool,
 
     pub underline: Stroke,
@@ -299,6 +317,7 @@ impl Default for TextFormat {
             line_height: None,
             color: Color32::GRAY,
             background: Color32::TRANSPARENT,
+            expand_bg: 1.0,
             italics: false,
             underline: Stroke::NONE,
             strikethrough: Stroke::NONE,
@@ -316,6 +335,7 @@ impl std::hash::Hash for TextFormat {
             line_height,
             color,
             background,
+            expand_bg,
             italics,
             underline,
             strikethrough,
@@ -328,6 +348,7 @@ impl std::hash::Hash for TextFormat {
         }
         color.hash(state);
         background.hash(state);
+        emath::OrderedFloat(*expand_bg).hash(state);
         italics.hash(state);
         underline.hash(state);
         strikethrough.hash(state);
@@ -481,7 +502,7 @@ impl TextWrapping {
 
 /// Text that has been laid out, ready for painting.
 ///
-/// You can create a [`Galley`] using [`crate::Fonts::layout_job`];
+/// You can create a [`Galley`] using [`crate::FontsView::layout_job`];
 ///
 /// Needs to be recreated if the underlying font atlas texture changes, which
 /// happens under the following conditions:
@@ -500,14 +521,14 @@ pub struct Galley {
     /// Contains the original string and style sections.
     pub job: Arc<LayoutJob>,
 
-    /// Rows of text, from top to bottom.
+    /// Rows of text, from top to bottom, and their offsets.
     ///
     /// The number of characters in all rows sum up to `job.text.chars().count()`
     /// unless [`Self::elided`] is `true`.
     ///
     /// Note that a paragraph (a piece of text separated with `\n`)
     /// can be split up into multiple rows.
-    pub rows: Vec<Row>,
+    pub rows: Vec<PlacedRow>,
 
     /// Set to true the text was truncated due to [`TextWrapping::max_rows`].
     pub elided: bool,
@@ -537,31 +558,72 @@ pub struct Galley {
     /// so that we can warn if this has changed once we get to
     /// tessellation.
     pub pixels_per_point: f32,
+
+    pub(crate) intrinsic_size: Vec2,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct PlacedRow {
+    /// The position of this [`Row`] relative to the galley.
+    ///
+    /// This is rounded to the closest _pixel_ in order to produce crisp, pixel-perfect text.
+    pub pos: Pos2,
+
+    /// The underlying unpositioned [`Row`].
+    pub row: Arc<Row>,
+
+    /// If true, this [`PlacedRow`] came from a paragraph ending with a `\n`.
+    /// The `\n` itself is omitted from row's [`Row::glyphs`].
+    /// A `\n` in the input text always creates a new [`PlacedRow`] below it,
+    /// so that text that ends with `\n` has an empty [`PlacedRow`] last.
+    /// This also implies that the last [`PlacedRow`] in a [`Galley`] always has `ends_with_newline == false`.
+    pub ends_with_newline: bool,
+}
+
+impl PlacedRow {
+    /// Logical bounding rectangle on font heights etc.
+    ///
+    /// This ignores / includes the `LayoutSection::leading_space`.
+    pub fn rect(&self) -> Rect {
+        Rect::from_min_size(self.pos, self.row.size)
+    }
+
+    /// Same as [`Self::rect`] but excluding the `LayoutSection::leading_space`.
+    pub fn rect_without_leading_space(&self) -> Rect {
+        let x = self.glyphs.first().map_or(self.pos.x, |g| g.pos.x);
+        let size_x = self.size.x - x;
+        Rect::from_min_size(Pos2::new(x, self.pos.y), Vec2::new(size_x, self.size.y))
+    }
+}
+
+impl std::ops::Deref for PlacedRow {
+    type Target = Row;
+
+    fn deref(&self) -> &Self::Target {
+        &self.row
+    }
 }
 
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Row {
-    /// This is included in case there are no glyphs
-    pub section_index_at_start: u32,
+    /// This is included in case there are no glyphs.
+    ///
+    /// Only used during layout, then set to an invalid value in order to
+    /// enable the paragraph-concat optimization path without having to
+    /// adjust `section_index` when concatting.
+    pub(crate) section_index_at_start: u32,
 
     /// One for each `char`.
     pub glyphs: Vec<Glyph>,
 
-    /// Logical bounding rectangle based on font heights etc.
-    /// Use this when drawing a selection or similar!
+    /// Logical size based on font heights etc.
     /// Includes leading and trailing whitespace.
-    pub rect: Rect,
+    pub size: Vec2,
 
     /// 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.
@@ -605,7 +667,7 @@ pub struct Glyph {
     /// The character this glyph represents.
     pub chr: char,
 
-    /// Baseline position, relative to the galley.
+    /// Baseline position, relative to the row.
     /// Logical position: pos.y is the same for all chars of the same [`TextFormat`].
     pub pos: Pos2,
 
@@ -634,7 +696,14 @@ pub struct Glyph {
     pub uv_rect: UvRect,
 
     /// Index into [`LayoutJob::sections`]. Decides color etc.
-    pub section_index: u32,
+    ///
+    /// Only used during layout, then set to an invalid value in order to
+    /// enable the paragraph-concat optimization path without having to
+    /// adjust `section_index` when concatting.
+    pub(crate) section_index: u32,
+
+    /// Which is our first vertex in [`RowVisuals::mesh`].
+    pub first_vertex: u32,
 }
 
 impl Glyph {
@@ -669,28 +738,7 @@ impl Row {
         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.
+    /// Closest char at the desired x coordinate in row-relative coordinates.
     /// 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() {
@@ -705,9 +753,32 @@ impl Row {
         if let Some(glyph) = self.glyphs.get(column) {
             glyph.pos.x
         } else {
-            self.rect.right()
+            self.size.x
         }
     }
+
+    #[inline]
+    pub fn height(&self) -> f32 {
+        self.size.y
+    }
+}
+
+impl PlacedRow {
+    #[inline]
+    pub fn min_y(&self) -> f32 {
+        self.rect().top()
+    }
+
+    #[inline]
+    pub fn max_y(&self) -> f32 {
+        self.rect().bottom()
+    }
+
+    /// Includes the implicit `\n` after the [`PlacedRow`], if any.
+    #[inline]
+    pub fn char_count_including_newline(&self) -> usize {
+        self.row.glyphs.len() + (self.ends_with_newline as usize)
+    }
 }
 
 impl Galley {
@@ -726,6 +797,106 @@ impl Galley {
     pub fn size(&self) -> Vec2 {
         self.rect.size()
     }
+
+    /// This is the size that a non-wrapped, non-truncated, non-justified version of the text
+    /// would have.
+    ///
+    /// Useful for advanced layouting.
+    #[inline]
+    pub fn intrinsic_size(&self) -> Vec2 {
+        // We do the rounding here instead of in `round_output_to_gui` so that rounding
+        // errors don't accumulate when concatenating multiple galleys.
+        if self.job.round_output_to_gui {
+            self.intrinsic_size.round_ui()
+        } else {
+            self.intrinsic_size
+        }
+    }
+
+    pub(crate) fn round_output_to_gui(&mut self) {
+        for placed_row in &mut self.rows {
+            // Optimization: only call `make_mut` if necessary (can cause a deep clone)
+            let rounded_size = placed_row.row.size.round_ui();
+            if placed_row.row.size != rounded_size {
+                Arc::make_mut(&mut placed_row.row).size = rounded_size;
+            }
+        }
+
+        let rect = &mut self.rect;
+
+        let did_exceed_wrap_width_by_a_lot = rect.width() > self.job.wrap.max_width + 1.0;
+
+        *rect = rect.round_ui();
+
+        if did_exceed_wrap_width_by_a_lot {
+            // If the user picked a too aggressive wrap width (e.g. more narrow than any individual glyph),
+            // we should let the user know by reporting that our width is wider than the wrap width.
+        } else {
+            // Make sure we don't report being wider than the wrap width the user picked:
+            rect.max.x = rect
+                .max
+                .x
+                .at_most(rect.min.x + self.job.wrap.max_width)
+                .floor_ui();
+        }
+    }
+
+    /// Append each galley under the previous one.
+    pub fn concat(job: Arc<LayoutJob>, galleys: &[Arc<Self>], pixels_per_point: f32) -> Self {
+        profiling::function_scope!();
+
+        let mut merged_galley = Self {
+            job,
+            rows: Vec::new(),
+            elided: false,
+            rect: Rect::ZERO,
+            mesh_bounds: Rect::NOTHING,
+            num_vertices: 0,
+            num_indices: 0,
+            pixels_per_point,
+            intrinsic_size: Vec2::ZERO,
+        };
+
+        for (i, galley) in galleys.iter().enumerate() {
+            let current_y_offset = merged_galley.rect.height();
+            let is_last_galley = i + 1 == galleys.len();
+
+            merged_galley
+                .rows
+                .extend(galley.rows.iter().enumerate().map(|(row_idx, placed_row)| {
+                    let new_pos = placed_row.pos + current_y_offset * Vec2::Y;
+                    let new_pos = new_pos.round_to_pixels(pixels_per_point);
+                    merged_galley.mesh_bounds |=
+                        placed_row.visuals.mesh_bounds.translate(new_pos.to_vec2());
+                    merged_galley.rect |= Rect::from_min_size(new_pos, placed_row.size);
+
+                    let mut ends_with_newline = placed_row.ends_with_newline;
+                    let is_last_row_in_galley = row_idx + 1 == galley.rows.len();
+                    // Since we remove the `\n` when splitting rows, we need to add it back here
+                    ends_with_newline |= !is_last_galley && is_last_row_in_galley;
+                    super::PlacedRow {
+                        pos: new_pos,
+                        row: placed_row.row.clone(),
+                        ends_with_newline,
+                    }
+                }));
+
+            merged_galley.num_vertices += galley.num_vertices;
+            merged_galley.num_indices += galley.num_indices;
+            // Note that if `galley.elided` is true this will be the last `Galley` in
+            // the vector and the loop will end.
+            merged_galley.elided |= galley.elided;
+            merged_galley.intrinsic_size.x =
+                f32::max(merged_galley.intrinsic_size.x, galley.intrinsic_size.x);
+            merged_galley.intrinsic_size.y += galley.intrinsic_size.y;
+        }
+
+        if merged_galley.job.round_output_to_gui {
+            merged_galley.round_output_to_gui();
+        }
+
+        merged_galley
+    }
 }
 
 impl AsRef<str> for Galley {
@@ -757,7 +928,7 @@ 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();
+            let x = row.rect().right();
             Rect::from_min_max(pos2(x, row.min_y()), pos2(x, row.max_y()))
         } else {
             // Empty galley
@@ -766,53 +937,18 @@ impl Galley {
     }
 
     /// 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
+    fn pos_from_layout_cursor(&self, layout_cursor: &LayoutCursor) -> Rect {
+        let Some(row) = self.rows.get(layout_cursor.row) else {
+            return self.end_pos();
+        };
+
+        let x = row.x_offset(layout_cursor.column);
+        Rect::from_min_max(pos2(x, row.min_y()), pos2(x, row.max_y()))
     }
 
     /// 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_ccursor(&self, ccursor: CCursor) -> Rect {
-        self.pos_from_cursor(&self.from_ccursor(ccursor))
-    }
-
-    /// Returns a 0-width Rect.
-    pub fn pos_from_rcursor(&self, rcursor: RCursor) -> Rect {
-        self.pos_from_cursor(&self.from_rcursor(rcursor))
+    pub fn pos_from_cursor(&self, cursor: CCursor) -> Rect {
+        self.pos_from_layout_cursor(&self.layout_from_cursor(cursor))
     }
 
     /// Cursor at the given position within the galley.
@@ -822,45 +958,40 @@ impl Galley {
     /// and a cursor below the galley is considered
     /// same as a cursor at the end.
     /// This allows implementing text-selection by dragging above/below the galley.
-    pub fn cursor_from_pos(&self, pos: Vec2) -> Cursor {
-        if let Some(first_row) = self.rows.first() {
-            if pos.y < first_row.min_y() {
-                return self.begin();
-            }
+    pub fn cursor_from_pos(&self, pos: Vec2) -> CCursor {
+        // Vertical margin around galley improves text selection UX
+        const VMARGIN: f32 = 5.0;
+
+        if let Some(first_row) = self.rows.first()
+            && pos.y < first_row.min_y() - VMARGIN
+        {
+            return self.begin();
         }
-        if let Some(last_row) = self.rows.last() {
-            if last_row.max_y() < pos.y {
-                return self.end();
-            }
+        if let Some(last_row) = self.rows.last()
+            && last_row.max_y() + VMARGIN < pos.y
+        {
+            return self.end();
         }
 
         let mut best_y_dist = f32::INFINITY;
-        let mut cursor = Cursor::default();
+        let mut cursor = CCursor::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 = row.min_y() <= pos.y && pos.y <= row.max_y();
-            let y_dist = (row.min_y() - pos.y).abs().min((row.max_y() - pos.y).abs());
+        for row in &self.rows {
+            let min_y = row.min_y();
+            let max_y = row.max_y();
+
+            let is_pos_within_row = min_y <= pos.y && pos.y <= max_y;
+            let y_dist = (min_y - pos.y).abs().min((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);
+                // char_at is `Row` not `PlacedRow` relative which means we have to subtract the pos.
+                let column = row.char_at(pos.x - row.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,
-                    },
+                cursor = CCursor {
+                    index: ccursor_index + column,
+                    prefer_next_row,
                 };
 
                 if is_pos_within_row {
@@ -868,12 +999,6 @@ impl Galley {
                 }
             }
             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
@@ -884,15 +1009,15 @@ impl Galley {
 impl Galley {
     /// Cursor to the first character.
     ///
-    /// This is the same as [`Cursor::default`].
+    /// This is the same as [`CCursor::default`].
     #[inline]
-    #[allow(clippy::unused_self)]
-    pub fn begin(&self) -> Cursor {
-        Cursor::default()
+    #[expect(clippy::unused_self)]
+    pub fn begin(&self) -> CCursor {
+        CCursor::default()
     }
 
     /// Cursor to one-past last character.
-    pub fn end(&self) -> Cursor {
+    pub fn end(&self) -> CCursor {
         if self.rows.is_empty() {
             return Default::default();
         }
@@ -900,31 +1025,47 @@ impl Galley {
             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,
         }
+        ccursor
     }
+}
+
+/// ## Cursor conversions
+impl Galley {
+    // The returned cursor is clamped.
+    pub fn layout_from_cursor(&self, cursor: CCursor) -> LayoutCursor {
+        let prefer_next_row = cursor.prefer_next_row;
+        let mut ccursor_it = CCursor {
+            index: 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 <= cursor.index && cursor.index <= ccursor_it.index + row_char_count
+            {
+                let column = cursor.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 {
+                    return LayoutCursor {
+                        row: row_nr,
+                        column,
+                    };
+                }
+            }
+            ccursor_it.index += row.char_count_including_newline();
+        }
+        debug_assert!(ccursor_it == self.end(), "Cursor out of bounds");
 
-    pub fn end_rcursor(&self) -> RCursor {
         if let Some(last_row) = self.rows.last() {
-            RCursor {
+            LayoutCursor {
                 row: self.rows.len() - 1,
                 column: last_row.char_count_including_newline(),
             }
@@ -932,268 +1073,160 @@ impl Galley {
             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();
-            }
-        }
-        debug_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() {
+    fn cursor_from_layout(&self, layout_cursor: LayoutCursor) -> CCursor {
+        if layout_cursor.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 {
+            layout_cursor.column < self.rows[layout_cursor.row].char_count_excluding_newline();
+        let mut cursor_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_nr == layout_cursor.row {
+                cursor_it.index += layout_cursor
+                    .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();
+                return cursor_it;
             }
+            cursor_it.index += 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_it
     }
 }
 
 /// ## Cursor positions
 impl Galley {
-    pub fn cursor_left_one_character(&self, cursor: &Cursor) -> Cursor {
-        if cursor.ccursor.index == 0 {
+    #[expect(clippy::unused_self)]
+    pub fn cursor_left_one_character(&self, cursor: &CCursor) -> CCursor {
+        if cursor.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)
+            CCursor {
+                index: cursor.index - 1,
+                prefer_next_row: true, // default to this when navigating. It is more often useful to put cursor at the beginning of a row than at the end.
+            }
         }
     }
 
-    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_right_one_character(&self, cursor: &CCursor) -> CCursor {
+        CCursor {
+            index: (cursor.index + 1).min(self.end().index),
+            prefer_next_row: true, // default to this when navigating. It is more often useful to put cursor at the beginning of a row than at the end.
+        }
     }
 
-    pub fn cursor_up_one_row(&self, cursor: &Cursor) -> Cursor {
-        if cursor.rcursor.row == 0 {
-            Cursor::default()
+    pub fn clamp_cursor(&self, cursor: &CCursor) -> CCursor {
+        self.cursor_from_layout(self.layout_from_cursor(*cursor))
+    }
+
+    pub fn cursor_up_one_row(
+        &self,
+        cursor: &CCursor,
+        h_pos: Option<f32>,
+    ) -> (CCursor, Option<f32>) {
+        let layout_cursor = self.layout_from_cursor(*cursor);
+        let h_pos = h_pos.unwrap_or_else(|| self.pos_from_layout_cursor(&layout_cursor).center().x);
+        if layout_cursor.row == 0 {
+            (CCursor::default(), None)
         } else {
-            let new_row = cursor.rcursor.row - 1;
+            let new_row = layout_cursor.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 {
+            let new_layout_cursor = {
                 // 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 {
+                let column = self.rows[new_row].char_at(h_pos);
+                LayoutCursor {
                     row: new_row,
                     column,
                 }
             };
-            self.from_rcursor(new_rcursor)
+            (self.cursor_from_layout(new_layout_cursor), Some(h_pos))
         }
     }
 
-    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;
+    pub fn cursor_down_one_row(
+        &self,
+        cursor: &CCursor,
+        h_pos: Option<f32>,
+    ) -> (CCursor, Option<f32>) {
+        let layout_cursor = self.layout_from_cursor(*cursor);
+        let h_pos = h_pos.unwrap_or_else(|| self.pos_from_layout_cursor(&layout_cursor).center().x);
+        if layout_cursor.row + 1 < self.rows.len() {
+            let new_row = layout_cursor.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 {
+            let new_layout_cursor = {
                 // 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 {
+                let column = self.rows[new_row].char_at(h_pos);
+                LayoutCursor {
                     row: new_row,
                     column,
                 }
             };
 
-            self.from_rcursor(new_rcursor)
+            (self.cursor_from_layout(new_layout_cursor), Some(h_pos))
         } else {
-            self.end()
+            (self.end(), None)
         }
     }
 
-    pub fn cursor_begin_of_row(&self, cursor: &Cursor) -> Cursor {
-        self.from_rcursor(RCursor {
-            row: cursor.rcursor.row,
+    pub fn cursor_begin_of_row(&self, cursor: &CCursor) -> CCursor {
+        let layout_cursor = self.layout_from_cursor(*cursor);
+        self.cursor_from_layout(LayoutCursor {
+            row: layout_cursor.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(),
+    pub fn cursor_end_of_row(&self, cursor: &CCursor) -> CCursor {
+        let layout_cursor = self.layout_from_cursor(*cursor);
+        self.cursor_from_layout(LayoutCursor {
+            row: layout_cursor.row,
+            column: self.rows[layout_cursor.row].char_count_excluding_newline(),
         })
     }
+
+    pub fn cursor_begin_of_paragraph(&self, cursor: &CCursor) -> CCursor {
+        let mut layout_cursor = self.layout_from_cursor(*cursor);
+        layout_cursor.column = 0;
+
+        loop {
+            let prev_row = layout_cursor
+                .row
+                .checked_sub(1)
+                .and_then(|row| self.rows.get(row));
+
+            let Some(prev_row) = prev_row else {
+                // This is the first row
+                break;
+            };
+
+            if prev_row.ends_with_newline {
+                break;
+            }
+
+            layout_cursor.row -= 1;
+        }
+
+        self.cursor_from_layout(layout_cursor)
+    }
+
+    pub fn cursor_end_of_paragraph(&self, cursor: &CCursor) -> CCursor {
+        let mut layout_cursor = self.layout_from_cursor(*cursor);
+        loop {
+            let row = &self.rows[layout_cursor.row];
+            if row.ends_with_newline || layout_cursor.row == self.rows.len() - 1 {
+                layout_cursor.column = row.char_count_excluding_newline();
+                break;
+            }
+
+            layout_cursor.row += 1;
+        }
+
+        self.cursor_from_layout(layout_cursor)
+    }
 }
diff --git a/crates/epaint/src/texture_atlas.rs b/crates/epaint/src/texture_atlas.rs
index 7ea76f872..6488d9079 100644
--- a/crates/epaint/src/texture_atlas.rs
+++ b/crates/epaint/src/texture_atlas.rs
@@ -1,6 +1,7 @@
-use emath::{remap_clamp, Rect};
+use ecolor::Color32;
+use emath::{Rect, remap_clamp};
 
-use crate::{FontImage, ImageDelta};
+use crate::{AlphaFromCoverage, ColorImage, ImageDelta};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 struct Rectu {
@@ -57,7 +58,7 @@ pub struct PreparedDisc {
 /// More characters can be added, possibly expanding the texture.
 #[derive(Clone)]
 pub struct TextureAtlas {
-    image: FontImage,
+    image: ColorImage,
 
     /// What part of the image that is dirty
     dirty: Rectu,
@@ -72,24 +73,32 @@ pub struct TextureAtlas {
 
     /// pre-rasterized discs of radii `2^i`, where `i` is the index.
     discs: Vec<PrerasterizedDisc>,
+
+    /// Controls how to convert glyph coverage to alpha.
+    pub(crate) text_alpha_from_coverage: AlphaFromCoverage,
 }
 
 impl TextureAtlas {
-    pub fn new(size: [usize; 2]) -> Self {
+    pub fn new(size: [usize; 2], text_alpha_from_coverage: AlphaFromCoverage) -> Self {
         assert!(size[0] >= 1024, "Tiny texture atlas");
         let mut atlas = Self {
-            image: FontImage::new(size),
+            image: ColorImage::filled(size, Color32::TRANSPARENT),
             dirty: Rectu::EVERYTHING,
             cursor: (0, 0),
             row_height: 0,
             overflowed: false,
             discs: vec![], // will be filled in below
+            text_alpha_from_coverage,
         };
 
         // 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;
+        assert_eq!(
+            pos,
+            (0, 0),
+            "Expected the first allocation to be at (0, 0), but was at {pos:?}"
+        );
+        image[pos] = Color32::WHITE;
 
         // Allocate a series of anti-aliased discs used to render small filled circles:
         // TODO(emilk): these circles can be packed A LOT better.
@@ -112,7 +121,7 @@ impl TextureAtlas {
                     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;
+                        text_alpha_from_coverage.color_from_coverage(coverage);
                 }
             }
             atlas.discs.push(PrerasterizedDisc {
@@ -180,7 +189,7 @@ impl TextureAtlas {
 
     /// The full font atlas image.
     #[inline]
-    pub fn image(&self) -> &FontImage {
+    pub fn image(&self) -> &ColorImage {
         &self.image
     }
 
@@ -196,14 +205,14 @@ impl TextureAtlas {
         } 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);
+            let region = self.image.region_by_pixels(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) {
+    pub fn allocate(&mut self, (w, h): (usize, usize)) -> ((usize, usize), &mut ColorImage) {
         /// 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.
@@ -229,7 +238,6 @@ impl TextureAtlas {
         if required_height > self.max_height() {
             // This is a bad place to be - we need to start reusing space :/
 
-            #[cfg(feature = "log")]
             log::warn!("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
@@ -250,13 +258,15 @@ impl TextureAtlas {
     }
 }
 
-fn resize_to_min_height(image: &mut FontImage, required_height: usize) -> bool {
+fn resize_to_min_height(image: &mut ColorImage, 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);
+        image
+            .pixels
+            .resize(image.width() * image.height(), Color32::TRANSPARENT);
         true
     } else {
         false
diff --git a/crates/epaint/src/texture_handle.rs b/crates/epaint/src/texture_handle.rs
index 1f640a171..919b7405f 100644
--- a/crates/epaint/src/texture_handle.rs
+++ b/crates/epaint/src/texture_handle.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use crate::{
-    emath::NumExt, mutex::RwLock, textures::TextureOptions, ImageData, ImageDelta, TextureId,
-    TextureManager,
+    ImageData, ImageDelta, TextureId, TextureManager, emath::NumExt as _, mutex::RwLock,
+    textures::TextureOptions,
 };
 
 /// Used to paint images.
@@ -66,7 +66,7 @@ impl TextureHandle {
     }
 
     /// Assign a new image to an existing texture.
-    #[allow(clippy::needless_pass_by_ref_mut)] // Intentionally hide interiority of mutability
+    #[expect(clippy::needless_pass_by_ref_mut)] // Intentionally hide interiority of mutability
     pub fn set(&mut self, image: impl Into<ImageData>, options: TextureOptions) {
         self.tex_mngr
             .write()
@@ -74,7 +74,7 @@ impl TextureHandle {
     }
 
     /// Assign a new image to a subregion of the whole texture.
-    #[allow(clippy::needless_pass_by_ref_mut)] // Intentionally hide interiority of mutability
+    #[expect(clippy::needless_pass_by_ref_mut)] // Intentionally hide interiority of mutability
     pub fn set_partial(
         &mut self,
         pos: [usize; 2],
diff --git a/crates/epaint/src/textures.rs b/crates/epaint/src/textures.rs
index cc191a75f..0944a9052 100644
--- a/crates/epaint/src/textures.rs
+++ b/crates/epaint/src/textures.rs
@@ -271,7 +271,7 @@ pub enum TextureWrapMode {
 /// What has been allocated and freed during the last period.
 ///
 /// These are commands given to the integration painter.
-#[derive(Clone, Default, PartialEq)]
+#[derive(Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[must_use = "The painter must take care of this"]
 pub struct TexturesDelta {
diff --git a/crates/epaint/src/util/mod.rs b/crates/epaint/src/util/mod.rs
index 383b94567..471576630 100644
--- a/crates/epaint/src/util/mod.rs
+++ b/crates/epaint/src/util/mod.rs
@@ -1,6 +1,3 @@
-#[deprecated = "Use emath::OrderedFloat instead"]
-pub use emath::OrderedFloat;
-
 /// Hash the given value with a predictable hasher.
 #[inline]
 pub fn hash(value: impl std::hash::Hash) -> u64 {
diff --git a/crates/epaint_default_fonts/CHANGELOG.md b/crates/epaint_default_fonts/CHANGELOG.md
index 8d9eff7cd..3f131cb55 100644
--- a/crates/epaint_default_fonts/CHANGELOG.md
+++ b/crates/epaint_default_fonts/CHANGELOG.md
@@ -5,6 +5,34 @@ This file is updated upon each release.
 Changes since the last release can be found at <https://github.com/emilk/egui/compare/latest...HEAD> or by running the `scripts/generate_changelog.py` script.
 
 
+## 0.33.2 - 2025-11-13
+Nothing new
+
+
+## 0.33.0 - 2025-10-09
+Nothing new
+
+
+## 0.32.3 - 2025-09-12
+Nothing new
+
+
+## 0.32.2 - 2025-09-04
+Nothing new
+
+
+## 0.32.1 - 2025-08-15
+Nothing new
+
+
+## 0.32.0 - 2025-07-10
+Nothing new
+
+
+## 0.31.1 - 2025-03-05
+Nothing new
+
+
 ## 0.31.0 - 2025-02-04
 * Update `egui_default_fonts` license [#5361](https://github.com/emilk/egui/pull/5361) by [@pombredanne](https://github.com/pombredanne)
 
diff --git a/crates/epaint_default_fonts/Cargo.toml b/crates/epaint_default_fonts/Cargo.toml
index 9e71d390c..588719871 100644
--- a/crates/epaint_default_fonts/Cargo.toml
+++ b/crates/epaint_default_fonts/Cargo.toml
@@ -5,10 +5,10 @@ authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 description = "Default fonts for use in epaint / egui"
 edition.workspace = true
 rust-version.workspace = true
-homepage = "https://github.com/emilk/egui/tree/master/crates/epaint_default_fonts"
+homepage = "https://github.com/emilk/egui/tree/main/crates/epaint_default_fonts"
 license = "(MIT OR Apache-2.0) AND OFL-1.1 AND Ubuntu-font-1.0" # OFL and UFL are from the font files themselves.
 readme = "README.md"
-repository = "https://github.com/emilk/egui/tree/master/crates/epaint_default_fonts"
+repository = "https://github.com/emilk/egui/tree/main/crates/epaint_default_fonts"
 categories = ["graphics", "gui"]
 keywords = ["graphics", "gui", "egui"]
 include = [
diff --git a/crates/epaint_default_fonts/emoji-icon-font.ttf b/crates/epaint_default_fonts/emoji-icon-font.ttf
new file mode 100644
index 000000000..0f29dfed8
Binary files /dev/null and b/crates/epaint_default_fonts/emoji-icon-font.ttf differ
diff --git a/deny.toml b/deny.toml
index 3e8a63371..c7206ff26 100644
--- a/deny.toml
+++ b/deny.toml
@@ -31,7 +31,8 @@ all-features = true
 [advisories]
 version = 2
 ignore = [
-  "RUSTSEC-2024-0320", # unmaintaines yaml-rust pulled in by syntect
+  "RUSTSEC-2024-0320", # unmaintained yaml-rust pulled in by syntect
+  "RUSTSEC-2024-0436", # unmaintained paste pulled via metal/wgpu, see https://github.com/gfx-rs/metal-rs/issues/349
 ]
 
 [bans]
@@ -44,26 +45,24 @@ deny = [
 ]
 
 skip = [
-  { name = "base64" },         # Pretty small
-  { name = "bit-set" },        # wgpu's naga depends on 0.8, syntect's (used by egui_extras) fancy-regex depends on 0.5
-  { name = "bit-vec" },        # dependency of bit-set in turn, different between 0.6 and 0.5
-  { name = "bitflags" },       # old 1.0 version via glutin, png, spirv, …
-  { name = "event-listener" }, # TODO(emilk): rustls pulls in two versions of this 😭
-  { name = "futures-lite" },   # old version via accesskit_unix and zbus
-  { name = "memoffset" },      # tiny dependency
-  { name = "ndk-sys" },        # old version via wgpu, winit uses newer version
-  { name = "quick-xml" },      # old version via wayland-scanner
-  { name = "redox_syscall" },  # old version via winit
-  { name = "thiserror" },      # ecosystem is in the process of migrating from 1.x to 2.x
+  { name = "bit-set" }, # wgpu's naga depends on 0.8, syntect's (used by egui_extras) fancy-regex depends on 0.5
+  { name = "bit-vec" }, # dependency of bit-set in turn, different between 0.6 and 0.5
+  { name = "bitflags" }, # old 1.0 version via glutin, png, spirv, …
+  { name = "core-foundation" }, # version conflict between winit and wgpu ecosystems
+  { name = "core-graphics-types" }, # version conflict between winit and wgpu ecosystems
+  { name = "getrandom" }, # ring / rustls (and thus ehttp) still depend on getrandom 0.2
+  { name = "quick-xml" }, # old version via wayland-scanner
+  { name = "redox_syscall" }, # old version via winit
+  { name = "rustc-hash" }, # Small enough
+  { name = "thiserror" }, # ecosystem is in the process of migrating from 1.x to 2.x
   { name = "thiserror-impl" }, # same as above
-  { name = "time" },           # old version pulled in by unmaintianed crate 'chrono'
-  { name = "windows-core" },   # Chrono pulls in 0.51, accesskit uses 0.58.0
-  { name = "windows-sys" },    # glutin pulls in 0.52.0, accesskit pulls in 0.59.0, rfd pulls 0.48, webbrowser pulls 0.45.0 (via jni)
+  { name = "windows-sys" }, # mostly hopeless to avoid
+  { name = "zerocopy" }, # Small enough
 ]
 skip-tree = [
-  { name = "criterion" },     # dev-dependency
-  { name = "foreign-types" }, # small crate. Old version via core-graphics (winit).
-  { name = "rfd" },           # example dependency
+  { name = "hashbrown" }, # wgpu's naga depends on 0.16, accesskit depends on 0.15
+  { name = "rfd" }, # example dependency
+  { name = "windows" }, # the ecosystem is currently transitioning from 0.58 to 0.61
 ]
 
 
@@ -73,21 +72,21 @@ private = { ignore = true }
 confidence-threshold = 0.93 # We want really high confidence when inferring licenses from text
 allow = [
   "Apache-2.0 WITH LLVM-exception", # https://spdx.org/licenses/LLVM-exception.html
-  "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://www.tldrlegal.com/license/isc-license
-  "MIT-0",                          # https://choosealicense.com/licenses/mit-0/
-  "MIT",                            # https://tldrlegal.com/license/mit-license
-  "MPL-2.0",                        # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11. Used by webpki-roots on Linux.
-  "OFL-1.1",                        # https://spdx.org/licenses/OFL-1.1.html
-  "OpenSSL",                        # https://www.openssl.org/source/license.html - used on Linux
-  "Ubuntu-font-1.0",                # https://ubuntu.com/legal/font-licence
-  "Unicode-3.0",                    # https://www.unicode.org/license.txt
-  "Unicode-DFS-2016",               # https://spdx.org/licenses/Unicode-DFS-2016.html
-  "Zlib",                           # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
+  "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://www.tldrlegal.com/license/isc-license
+  "MIT-0", # https://choosealicense.com/licenses/mit-0/
+  "MIT", # https://tldrlegal.com/license/mit-license
+  "MPL-2.0", # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11. Used by webpki-roots on Linux.
+  "OFL-1.1", # https://spdx.org/licenses/OFL-1.1.html
+  "OpenSSL", # https://www.openssl.org/source/license.html - used on Linux
+  "Ubuntu-font-1.0", # https://ubuntu.com/legal/font-licence
+  "Unicode-3.0", # https://www.unicode.org/license.txt
+  "Unicode-DFS-2016", # https://spdx.org/licenses/Unicode-DFS-2016.html
+  "Zlib", # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
 ]
 exceptions = []
 
diff --git a/examples/README.md b/examples/README.md
index 43bf63f70..d7e23fa86 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,10 +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.
+All the examples in this folder uses [`eframe`](https://github.com/emilk/egui/tree/main/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`.
+Note that all the examples on `main` are for the latest `main` 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/examples/confirm_exit/Cargo.toml b/examples/confirm_exit/Cargo.toml
index c3050c32d..2724ae079 100644
--- a/examples/confirm_exit/Cargo.toml
+++ b/examples/confirm_exit/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/confirm_exit/screenshot.png b/examples/confirm_exit/screenshot.png
index 854955cf7..372b6abc1 100644
--- a/examples/confirm_exit/screenshot.png
+++ b/examples/confirm_exit/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3122591a76a063f1db0b88b54ecc4afe012ee27a1404c0948d0b9d639aeeece6
-size 3124
+oid sha256:79ee820be9374c44e684373acb62fe7bcfaa2347346d1aed8083a706f6cae8c9
+size 3798
diff --git a/examples/custom_3d_glow/Cargo.toml b/examples/custom_3d_glow/Cargo.toml
index 3ed54df78..8636b0f43 100644
--- a/examples/custom_3d_glow/Cargo.toml
+++ b/examples/custom_3d_glow/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/custom_3d_glow/screenshot.png b/examples/custom_3d_glow/screenshot.png
index c3907a5ec..1840bca3f 100644
--- a/examples/custom_3d_glow/screenshot.png
+++ b/examples/custom_3d_glow/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4dd5ffcf5a530f6fbe959fd74e2f5b4aeaee335baf79ad1cde8e42c34d84156c
-size 24590
+oid sha256:c02ea6a9b0f2d215255b5550237f3d9aa43b257849591cc8a1cd206f401c2747
+size 28455
diff --git a/examples/custom_font/Cargo.toml b/examples/custom_font/Cargo.toml
index afaeb4117..b10bd12cb 100644
--- a/examples/custom_font/Cargo.toml
+++ b/examples/custom_font/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/custom_font/screenshot.png b/examples/custom_font/screenshot.png
index 7e6edc3dd..9939d8756 100644
--- a/examples/custom_font/screenshot.png
+++ b/examples/custom_font/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d0ab12a55c0d87f044ef7675f5b94b39977f2c5d3a2ea74eb843dfc85d5b9f31
-size 5645
+oid sha256:c13f5b5f70c194316bbb116700619fd1611f423ae86244d1668f21ba622aaa45
+size 7104
diff --git a/examples/custom_font_style/Cargo.toml b/examples/custom_font_style/Cargo.toml
index f64a48803..373225f60 100644
--- a/examples/custom_font_style/Cargo.toml
+++ b/examples/custom_font_style/Cargo.toml
@@ -3,8 +3,8 @@ name = "custom_font_style"
 version = "0.1.0"
 authors = ["tami5 <kkharji@proton.me>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/custom_font_style/screenshot.png b/examples/custom_font_style/screenshot.png
index bb7727a1d..7e7e8f709 100644
--- a/examples/custom_font_style/screenshot.png
+++ b/examples/custom_font_style/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5d443ef30cf12d2c4367135fd663270ed46f4864af2f3aae424610be86c73197
-size 66193
+oid sha256:3d705d757b1689f3730a673988ffd2b3f8c1729c8c84b4236cd72593420ff0bd
+size 109694
diff --git a/examples/custom_keypad/Cargo.toml b/examples/custom_keypad/Cargo.toml
index 7e765e4ec..6c3cd0f2f 100644
--- a/examples/custom_keypad/Cargo.toml
+++ b/examples/custom_keypad/Cargo.toml
@@ -3,8 +3,8 @@ name = "custom_keypad"
 version = "0.1.0"
 authors = ["Varphone Wong <varphone@qq.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,14 +13,11 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
 
 # For image support:
 egui_extras = { workspace = true, features = ["default", "image"] }
 
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
-] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/custom_keypad/src/keypad.rs b/examples/custom_keypad/src/keypad.rs
index 1934ff602..df8d1f484 100644
--- a/examples/custom_keypad/src/keypad.rs
+++ b/examples/custom_keypad/src/keypad.rs
@@ -1,4 +1,4 @@
-use eframe::egui::{self, pos2, vec2, Button, Ui, Vec2};
+use eframe::egui::{self, Button, Ui, Vec2, pos2, vec2};
 
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 enum Transition {
@@ -179,8 +179,8 @@ impl Keypad {
             )
         });
 
-        let mut is_first_show = false;
-        if ctx.wants_keyboard_input() && state.focus != focus {
+        let is_first_show = ctx.wants_keyboard_input() && state.focus != focus;
+        if is_first_show {
             let y = ctx.style().spacing.interact_size.y * 1.25;
             state.open = true;
             state.start_pos = ctx.input(|i| {
@@ -189,7 +189,6 @@ impl Keypad {
                     .map_or(pos2(100.0, 100.0), |p| p + vec2(0.0, y))
             });
             state.focus = focus;
-            is_first_show = true;
         }
 
         if state.close_on_next_frame {
diff --git a/examples/custom_style/Cargo.toml b/examples/custom_style/Cargo.toml
index 423179aaa..d4f874e96 100644
--- a/examples/custom_style/Cargo.toml
+++ b/examples/custom_style/Cargo.toml
@@ -2,8 +2,8 @@
 name = "custom_style"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -16,13 +16,10 @@ ignored = ["image"] # We need the .png feature
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
 egui_demo_lib.workspace = true
 egui_extras = { workspace = true, features = ["image"] }
 image = { workspace = true, features = ["png"] }
diff --git a/examples/custom_style/src/main.rs b/examples/custom_style/src/main.rs
index 111139379..58f7e1d3a 100644
--- a/examples/custom_style/src/main.rs
+++ b/examples/custom_style/src/main.rs
@@ -2,9 +2,9 @@
 #![allow(rustdoc::missing_crate_level_docs)] // it's an example
 
 use eframe::egui::{
-    self, global_theme_preference_buttons, style::Selection, Color32, Stroke, Style, Theme,
+    self, Color32, Stroke, Style, Theme, global_theme_preference_buttons, style::Selection,
 };
-use egui_demo_lib::{View, WidgetGallery};
+use egui_demo_lib::{View as _, WidgetGallery};
 
 fn main() -> eframe::Result {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
diff --git a/examples/custom_window_frame/Cargo.toml b/examples/custom_window_frame/Cargo.toml
index b0e89c8a6..453893583 100644
--- a/examples/custom_window_frame/Cargo.toml
+++ b/examples/custom_window_frame/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/custom_window_frame/screenshot.png b/examples/custom_window_frame/screenshot.png
index 92e11a695..81e28f07c 100644
--- a/examples/custom_window_frame/screenshot.png
+++ b/examples/custom_window_frame/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bfdf77d119ae7926f52ac781455c4b1574eea53276069614738ba8b13b9921ea
-size 6024
+oid sha256:8d153d2468d7099f2da099c5ea65329196a83baf112b292de1c5a6ce758dfced
+size 17635
diff --git a/examples/custom_window_frame/src/main.rs b/examples/custom_window_frame/src/main.rs
index eef0db002..bc7ddcb82 100644
--- a/examples/custom_window_frame/src/main.rs
+++ b/examples/custom_window_frame/src/main.rs
@@ -75,7 +75,7 @@ fn custom_window_frame(ctx: &egui::Context, title: &str, add_contents: impl FnOn
 }
 
 fn title_bar_ui(ui: &mut egui::Ui, title_bar_rect: eframe::epaint::Rect, title: &str) {
-    use egui::{vec2, Align2, FontId, Id, PointerButton, Sense, UiBuilder};
+    use egui::{Align2, FontId, Id, PointerButton, Sense, UiBuilder, vec2};
 
     let painter = ui.painter();
 
@@ -114,7 +114,7 @@ fn title_bar_ui(ui: &mut egui::Ui, title_bar_rect: eframe::epaint::Rect, title:
         ui.ctx().send_viewport_cmd(ViewportCommand::StartDrag);
     }
 
-    ui.allocate_new_ui(
+    ui.scope_builder(
         UiBuilder::new()
             .max_rect(title_bar_rect)
             .layout(egui::Layout::right_to_left(egui::Align::Center)),
diff --git a/examples/external_eventloop/Cargo.toml b/examples/external_eventloop/Cargo.toml
new file mode 100644
index 000000000..d54d1b1c5
--- /dev/null
+++ b/examples/external_eventloop/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "external_eventloop"
+version = "0.1.0"
+authors = ["Will Brown <opensource@rebeagle.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2024"
+rust-version = "1.88"
+publish = false
+
+[lints]
+workspace = true
+
+
+[dependencies]
+eframe = { workspace = true, features = [
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
+
+winit.workspace = true
diff --git a/examples/external_eventloop/README.md b/examples/external_eventloop/README.md
new file mode 100644
index 000000000..11b06389b
--- /dev/null
+++ b/examples/external_eventloop/README.md
@@ -0,0 +1,7 @@
+Example running an eframe application on an external eventloop.
+
+This allows you to run your eframe application alongside other windows and/or toolkits on the same event loop.
+
+```sh
+cargo run -p external_eventloop
+```
diff --git a/examples/external_eventloop/screenshot.png b/examples/external_eventloop/screenshot.png
new file mode 100644
index 000000000..b5b2a568c
--- /dev/null
+++ b/examples/external_eventloop/screenshot.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52c47927d0c4caace5e5489cb3c6e4880f4f29b34378e072222ad8492225fef0
+size 9366
diff --git a/examples/external_eventloop/src/main.rs b/examples/external_eventloop/src/main.rs
new file mode 100644
index 000000000..d72f6914a
--- /dev/null
+++ b/examples/external_eventloop/src/main.rs
@@ -0,0 +1,89 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+#![allow(rustdoc::missing_crate_level_docs)] // it's an example
+
+use eframe::{UserEvent, egui};
+use std::{cell::Cell, rc::Rc};
+use winit::event_loop::{ControlFlow, EventLoop};
+
+fn main() -> eframe::Result {
+    env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default().with_inner_size([320.0, 240.0]),
+        ..Default::default()
+    };
+
+    let eventloop = EventLoop::<UserEvent>::with_user_event().build().unwrap();
+    eventloop.set_control_flow(ControlFlow::Poll);
+
+    let mut winit_app = eframe::create_native(
+        "External Eventloop Application",
+        options,
+        Box::new(|_| Ok(Box::<MyApp>::default())),
+        &eventloop,
+    );
+
+    eventloop.run_app(&mut winit_app)?;
+
+    Ok(())
+}
+
+struct MyApp {
+    value: Rc<Cell<u32>>,
+    spin: bool,
+    blinky: bool,
+}
+
+impl Default for MyApp {
+    fn default() -> Self {
+        Self {
+            value: Rc::new(Cell::new(42)),
+            spin: false,
+            blinky: false,
+        }
+    }
+}
+
+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 External Eventloop Application");
+
+            ui.horizontal(|ui| {
+                if ui.button("Increment Now").clicked() {
+                    self.value.set(self.value.get() + 1);
+                }
+            });
+            ui.label(format!("Value: {}", self.value.get()));
+
+            if ui.button("Toggle Spinner").clicked() {
+                self.spin = !self.spin;
+            }
+
+            if ui.button("Toggle Blinky").clicked() {
+                self.blinky = !self.blinky;
+            }
+
+            if self.spin {
+                ui.spinner();
+            }
+
+            if self.blinky {
+                let now = ui.ctx().input(|i| i.time);
+                let blink = now % 1.0 < 0.5;
+                egui::Frame::new()
+                    .inner_margin(3)
+                    .corner_radius(5)
+                    .fill(if blink {
+                        egui::Color32::RED
+                    } else {
+                        egui::Color32::TRANSPARENT
+                    })
+                    .show(ui, |ui| {
+                        ui.label("Blinky!");
+                    });
+
+                ctx.request_repaint_after_secs((0.5 - (now % 0.5)) as f32);
+            }
+        });
+    }
+}
diff --git a/examples/external_eventloop_async/Cargo.toml b/examples/external_eventloop_async/Cargo.toml
new file mode 100644
index 000000000..c0537b107
--- /dev/null
+++ b/examples/external_eventloop_async/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "external_eventloop_async"
+version = "0.1.0"
+authors = ["Will Brown <opensource@rebeagle.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2024"
+rust-version = "1.88"
+publish = false
+
+[lints]
+workspace = true
+
+[features]
+linux-example = []
+
+[[bin]]
+name = "external_eventloop_async"
+required-features = ["linux-example"]
+
+[dependencies]
+eframe = { workspace = true, features = [
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+] }
+
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
+
+log.workspace = true
+
+winit.workspace = true
+
+tokio = { workspace = true, features = ["rt", "time", "net"] }
diff --git a/examples/external_eventloop_async/README.md b/examples/external_eventloop_async/README.md
new file mode 100644
index 000000000..37755e08d
--- /dev/null
+++ b/examples/external_eventloop_async/README.md
@@ -0,0 +1,10 @@
+Example running an eframe application on an external eventloop on top of a tokio executor on Linux.
+
+By running the event loop, eframe, and tokio in the same thread, one can leverage local async tasks.
+These tasks can share data with the UI without the need for locks or message passing.
+
+In tokio CPU-bound async tasks can be run with `spawn_blocking` to avoid impacting the UI frame rate.
+
+```sh
+cargo run -p external_eventloop_async --features linux-example
+```
diff --git a/examples/external_eventloop_async/src/app.rs b/examples/external_eventloop_async/src/app.rs
new file mode 100644
index 000000000..a7b3e0efe
--- /dev/null
+++ b/examples/external_eventloop_async/src/app.rs
@@ -0,0 +1,130 @@
+use eframe::{EframePumpStatus, UserEvent, egui};
+use std::{cell::Cell, io, os::fd::AsRawFd as _, rc::Rc, time::Duration};
+use tokio::task::LocalSet;
+use winit::event_loop::{ControlFlow, EventLoop};
+
+pub fn run() -> io::Result<()> {
+    env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default().with_inner_size([320.0, 240.0]),
+        ..Default::default()
+    };
+
+    let mut eventloop = EventLoop::<UserEvent>::with_user_event().build().unwrap();
+    eventloop.set_control_flow(ControlFlow::Poll);
+
+    let mut winit_app = eframe::create_native(
+        "External Eventloop Application",
+        options,
+        Box::new(|_| Ok(Box::<MyApp>::default())),
+        &eventloop,
+    );
+
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+
+    let local = LocalSet::new();
+    local.block_on(&rt, async {
+        let eventloop_fd = tokio::io::unix::AsyncFd::new(eventloop.as_raw_fd())?;
+        let mut control_flow = ControlFlow::Poll;
+
+        loop {
+            let mut guard = match control_flow {
+                ControlFlow::Poll => None,
+                ControlFlow::Wait => Some(eventloop_fd.readable().await?),
+                ControlFlow::WaitUntil(deadline) => {
+                    tokio::time::timeout_at(deadline.into(), eventloop_fd.readable())
+                        .await
+                        .ok()
+                        .transpose()?
+                }
+            };
+
+            match winit_app.pump_eframe_app(&mut eventloop, None) {
+                EframePumpStatus::Continue(next) => control_flow = next,
+                EframePumpStatus::Exit(code) => {
+                    log::info!("exit code: {code}");
+                    break;
+                }
+            }
+
+            if let Some(mut guard) = guard.take() {
+                guard.clear_ready();
+            }
+        }
+
+        Ok::<_, io::Error>(())
+    })
+}
+
+struct MyApp {
+    value: Rc<Cell<u32>>,
+    spin: bool,
+    blinky: bool,
+}
+
+impl Default for MyApp {
+    fn default() -> Self {
+        Self {
+            value: Rc::new(Cell::new(42)),
+            spin: false,
+            blinky: false,
+        }
+    }
+}
+
+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 External Eventloop Application");
+
+            ui.horizontal(|ui| {
+                if ui.button("Increment Now").clicked() {
+                    self.value.set(self.value.get() + 1);
+                }
+                if ui.button("Increment Later").clicked() {
+                    let value = self.value.clone();
+                    let ctx = ctx.clone();
+                    tokio::task::spawn_local(async move {
+                        tokio::time::sleep(Duration::from_secs(1)).await;
+                        value.set(value.get() + 1);
+                        ctx.request_repaint();
+                    });
+                }
+            });
+            ui.label(format!("Value: {}", self.value.get()));
+
+            if ui.button("Toggle Spinner").clicked() {
+                self.spin = !self.spin;
+            }
+
+            if ui.button("Toggle Blinky").clicked() {
+                self.blinky = !self.blinky;
+            }
+
+            if self.spin {
+                ui.spinner();
+            }
+
+            if self.blinky {
+                let now = ui.ctx().input(|i| i.time);
+                let blink = now % 1.0 < 0.5;
+                egui::Frame::new()
+                    .inner_margin(3)
+                    .corner_radius(5)
+                    .fill(if blink {
+                        egui::Color32::RED
+                    } else {
+                        egui::Color32::TRANSPARENT
+                    })
+                    .show(ui, |ui| {
+                        ui.label("Blinky!");
+                    });
+
+                ctx.request_repaint_after_secs((0.5 - (now % 0.5)) as f32);
+            }
+        });
+    }
+}
diff --git a/examples/external_eventloop_async/src/main.rs b/examples/external_eventloop_async/src/main.rs
new file mode 100644
index 000000000..f77dea941
--- /dev/null
+++ b/examples/external_eventloop_async/src/main.rs
@@ -0,0 +1,16 @@
+#![allow(rustdoc::missing_crate_level_docs)] // it's an example
+
+#[cfg(target_os = "linux")]
+mod app;
+
+#[cfg(target_os = "linux")]
+fn main() -> std::io::Result<()> {
+    app::run()
+}
+
+// Do not check `app` on unsupported platforms when check "--all-features" is used in CI.
+#[cfg(not(target_os = "linux"))]
+fn main() {
+    #![expect(clippy::print_stdout)]
+    println!("This example only supports Linux.");
+}
diff --git a/examples/file_dialog/Cargo.toml b/examples/file_dialog/Cargo.toml
index cf61cd45f..a3b5318b0 100644
--- a/examples/file_dialog/Cargo.toml
+++ b/examples/file_dialog/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,11 +13,8 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
-] }
-rfd = "0.15"
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
+rfd.workspace = true
diff --git a/examples/file_dialog/screenshot.png b/examples/file_dialog/screenshot.png
index 7a1cc0417..2858a9d55 100644
--- a/examples/file_dialog/screenshot.png
+++ b/examples/file_dialog/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fb8e0b6d09f6d4c598f4a4d91f849a6221acbfaab55711f890b03d551967d3a8
-size 3996
+oid sha256:93689f54b621ab0e978a123492ba64615e67815c39df7e3869f233cdd16f6ded
+size 5558
diff --git a/examples/file_dialog/src/main.rs b/examples/file_dialog/src/main.rs
index ac4f05251..9a8bbe966 100644
--- a/examples/file_dialog/src/main.rs
+++ b/examples/file_dialog/src/main.rs
@@ -29,10 +29,10 @@ impl eframe::App for MyApp {
         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 ui.button("Open file…").clicked()
+                && let Some(path) = rfd::FileDialog::new().pick_file()
+            {
+                self.picked_path = Some(path.display().to_string());
             }
 
             if let Some(picked_path) = &self.picked_path {
@@ -107,10 +107,10 @@ fn preview_files_being_dropped(ctx: &egui::Context) {
         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));
+        let content_rect = ctx.content_rect();
+        painter.rect_filled(content_rect, 0.0, Color32::from_black_alpha(192));
         painter.text(
-            screen_rect.center(),
+            content_rect.center(),
             Align2::CENTER_CENTER,
             text,
             TextStyle::Heading.resolve(&ctx.style()),
diff --git a/examples/hello_android/Cargo.toml b/examples/hello_android/Cargo.toml
index b3bf4407e..c4b5a93f3 100644
--- a/examples/hello_android/Cargo.toml
+++ b/examples/hello_android/Cargo.toml
@@ -3,8 +3,8 @@ name = "hello_android"
 version = "0.1.0"
 authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 # `unsafe_code` is required for `#[no_mangle]`, disable workspace lints to workaround lint error.
@@ -12,18 +12,28 @@ publish = false
 # workspace = true
 
 [lib]
-crate-type = ["cdylib"]
+# cdylib is required for Android, lib is required for desktop
+crate-type = ["cdylib", "lib"]
 
 
 [dependencies]
-eframe = { workspace = true, features = ["default", "android-native-activity"] }
+eframe = { workspace = true, default-features = false, features = [
+  "default_fonts",
+  "glow",
+  "android-native-activity",
+] }
+egui_demo_lib = { workspace = true, features = ["chrono"] }
 
 # For image support:
 egui_extras = { workspace = true, features = ["default", "image"] }
 
-log = { workspace = true }
-winit = { workspace = true }
-android_logger = "0.14"
+android_logger.workspace = true
+log.workspace = true
+winit.workspace = true
 
 [package.metadata.android]
 build_targets = ["armv7-linux-androideabi", "aarch64-linux-android"]
+
+[package.metadata.android.sdk]
+min_sdk_version = 23
+target_sdk_version = 35
diff --git a/examples/hello_android/README.md b/examples/hello_android/README.md
index fe14eb9fa..6ad26348a 100644
--- a/examples/hello_android/README.md
+++ b/examples/hello_android/README.md
@@ -14,7 +14,11 @@ cargo install \
 Build and run:
 
 ```sh
-cargo apk run -p hello_android
+# Run on android
+cargo apk run -p hello_android --lib
+
+# Run on your desktop
+cargo run -p hello_android
 ```
 
 ![](screenshot.png)
diff --git a/examples/hello_android/screenshot.png b/examples/hello_android/screenshot.png
index 91179fa2f..ff376284a 100644
--- a/examples/hello_android/screenshot.png
+++ b/examples/hello_android/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7add91d7d6b73f48e98f20d84cba3bd3a950cf97aa31f5e9fa93da9af98e876c
-size 120019
+oid sha256:16bb465d73b7cf8133aee8cdb773a10d213ad23359a21c0bc2af3e4f9893057f
+size 507047
diff --git a/examples/hello_android/src/lib.rs b/examples/hello_android/src/lib.rs
index adda66ca5..c138b97e1 100644
--- a/examples/hello_android/src/lib.rs
+++ b/examples/hello_android/src/lib.rs
@@ -1,15 +1,14 @@
-#![cfg(target_os = "android")]
-#![allow(rustdoc::missing_crate_level_docs)] // it's an example
+#![doc = include_str!("../README.md")]
 
-use android_logger::Config;
-use eframe::egui;
-use log::LevelFilter;
-use winit::platform::android::activity::AndroidApp;
+use eframe::{CreationContext, egui};
 
+#[cfg(target_os = "android")]
 #[no_mangle]
-fn android_main(app: AndroidApp) {
+fn android_main(app: winit::platform::android::activity::AndroidApp) {
     // Log to android output
-    android_logger::init_once(Config::default().with_max_level(LevelFilter::Info));
+    android_logger::init_once(
+        android_logger::Config::default().with_max_level(log::LevelFilter::Info),
+    );
 
     let options = eframe::NativeOptions {
         android_app: Some(app),
@@ -18,48 +17,34 @@ fn android_main(app: AndroidApp) {
     eframe::run_native(
         "My egui App",
         options,
-        Box::new(|cc| {
-            // This gives us image support:
-            egui_extras::install_image_loaders(&cc.egui_ctx);
-
-            Ok(Box::<MyApp>::default())
-        }),
+        Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),
     )
     .unwrap()
 }
 
-struct MyApp {
-    name: String,
-    age: u32,
+pub struct MyApp {
+    demo: egui_demo_lib::DemoWindows,
 }
 
-impl Default for MyApp {
-    fn default() -> Self {
+impl MyApp {
+    pub fn new(cc: &CreationContext) -> Self {
+        egui_extras::install_image_loaders(&cc.egui_ctx);
         Self {
-            name: "Arthur".to_owned(),
-            age: 42,
+            demo: egui_demo_lib::DemoWindows::default(),
         }
     }
 }
 
 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("Increment").clicked() {
-                self.age += 1;
-            }
-            ui.label(format!("Hello '{}', age {}", self.name, self.age));
-
-            ui.image(egui::include_image!(
-                "../../../crates/egui/assets/ferris.png"
-            ));
+        // Reserve some space at the top so the demo ui isn't hidden behind the android status bar
+        // TODO(lucasmerlin): This is a pretty big hack, should be fixed once safe_area implemented
+        // for android:
+        // https://github.com/rust-windowing/winit/issues/3910
+        egui::TopBottomPanel::top("status_bar_space").show(ctx, |ui| {
+            ui.set_height(32.0);
         });
+
+        self.demo.ui(ctx);
     }
 }
diff --git a/examples/hello_android/src/main.rs b/examples/hello_android/src/main.rs
new file mode 100644
index 000000000..e3cdb05ad
--- /dev/null
+++ b/examples/hello_android/src/main.rs
@@ -0,0 +1,9 @@
+use hello_android::MyApp;
+
+fn main() -> eframe::Result {
+    eframe::run_native(
+        "hello_android",
+        Default::default(),
+        Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),
+    )
+}
diff --git a/examples/hello_world/Cargo.toml b/examples/hello_world/Cargo.toml
index 1e4b553db..00e279898 100644
--- a/examples/hello_world/Cargo.toml
+++ b/examples/hello_world/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,14 +13,11 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
 
 # For image support:
 egui_extras = { workspace = true, features = ["default", "image"] }
 
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
-] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/hello_world_par/Cargo.toml b/examples/hello_world_par/Cargo.toml
index 541b220f7..84f1fe7e1 100644
--- a/examples/hello_world_par/Cargo.toml
+++ b/examples/hello_world_par/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -17,16 +17,13 @@ ignored = ["winit"] # Just enable some features of it; see below
 
 [dependencies]
 eframe = { workspace = true, default-features = false, features = [
-    # accesskit struggles with threading
-    "default_fonts",
-    "wayland",
-    "x11",
-    "wgpu",
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  # accesskit struggles with threading
+  "default_fonts",
+  "wayland",
+  "x11",
+  "wgpu",
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
 # This is normally enabled by eframe/default, which is not being used here
 # because of accesskit, as mentioned above
 winit = { workspace = true, features = ["default"] }
diff --git a/examples/hello_world_simple/Cargo.toml b/examples/hello_world_simple/Cargo.toml
index db1d7906d..954db50aa 100644
--- a/examples/hello_world_simple/Cargo.toml
+++ b/examples/hello_world_simple/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/hello_world_simple/screenshot.png b/examples/hello_world_simple/screenshot.png
index 8e5d56570..0d27bc056 100644
--- a/examples/hello_world_simple/screenshot.png
+++ b/examples/hello_world_simple/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0bb13d0cb819d30ffbcd12d9327589a1e3ca226943cb381fa17eccfb8f7c06fb
-size 3229
+oid sha256:7cde6a351fbcf5a5d3b5474353c627a9c93801563880b7ff41dfa025da3c6d37
+size 8587
diff --git a/examples/images/Cargo.toml b/examples/images/Cargo.toml
index c013e7b43..2618618ae 100644
--- a/examples/images/Cargo.toml
+++ b/examples/images/Cargo.toml
@@ -3,8 +3,8 @@ name = "images"
 version = "0.1.0"
 authors = ["Jan Procházka <github.com/jprochazk>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -21,8 +21,5 @@ eframe = { workspace = true, features = [
   "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
 egui_extras = { workspace = true, features = ["default", "all_loaders"] }
-env_logger = { version = "0.10", default-features = false, features = [
-  "auto-color",
-  "humantime",
-] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
 image = { workspace = true, features = ["jpeg", "png"] }
diff --git a/examples/images/screenshot.png b/examples/images/screenshot.png
index 833b6565b..688345247 100644
--- a/examples/images/screenshot.png
+++ b/examples/images/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a836741d52e1972b2047cefaabf59f601637d430d4b41bf6407ebda4f7931dac
-size 273450
+oid sha256:aab48522ee4e3382982a0ee558a78e7b501ab4205c793a66078c6e74631bd7a5
+size 79718
diff --git a/examples/images/src/ferris.gif b/examples/images/src/ferris.gif
index 55784ef4d..358bcf987 100644
Binary files a/examples/images/src/ferris.gif and b/examples/images/src/ferris.gif differ
diff --git a/examples/keyboard_events/Cargo.toml b/examples/keyboard_events/Cargo.toml
index d57f17193..f3786152c 100644
--- a/examples/keyboard_events/Cargo.toml
+++ b/examples/keyboard_events/Cargo.toml
@@ -3,8 +3,8 @@ name = "keyboard_events"
 version = "0.1.0"
 authors = ["Jose Palazon <jose@palako.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,10 +13,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/keyboard_events/screenshot.png b/examples/keyboard_events/screenshot.png
index ed6ba6837..973827481 100644
--- a/examples/keyboard_events/screenshot.png
+++ b/examples/keyboard_events/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6cf53e0da26c4295bafe9cbb9ea0ad8c50933e29eb67467c3a11783697ec5494
-size 7525
+oid sha256:c4b314fc336e6cf027594b3ca123318bc4772fb611486170fd370cfa6a56edc5
+size 9599
diff --git a/examples/multiple_viewports/Cargo.toml b/examples/multiple_viewports/Cargo.toml
index d5efc23df..3187bf16d 100644
--- a/examples/multiple_viewports/Cargo.toml
+++ b/examples/multiple_viewports/Cargo.toml
@@ -3,8 +3,8 @@ name = "multiple_viewports"
 version = "0.1.0"
 authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -15,10 +15,7 @@ wgpu = ["eframe/wgpu"]
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/multiple_viewports/src/main.rs b/examples/multiple_viewports/src/main.rs
index a8adab2c7..919c24a3a 100644
--- a/examples/multiple_viewports/src/main.rs
+++ b/examples/multiple_viewports/src/main.rs
@@ -2,8 +2,8 @@
 #![allow(rustdoc::missing_crate_level_docs)] // it's an example
 
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
 
 use eframe::egui;
diff --git a/examples/popups/Cargo.toml b/examples/popups/Cargo.toml
index 2f9d6b092..d1f199918 100644
--- a/examples/popups/Cargo.toml
+++ b/examples/popups/Cargo.toml
@@ -9,13 +9,10 @@ version.workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
 
 
 [lints]
diff --git a/examples/popups/README.md b/examples/popups/README.md
index ce32e895a..ba2faa2e2 100644
--- a/examples/popups/README.md
+++ b/examples/popups/README.md
@@ -3,3 +3,5 @@ Example of how to use menus, popups, context menus and tooltips.
 ```sh
 cargo run -p popups
 ```
+
+![](screenshot.png)
diff --git a/examples/popups/screenshot.png b/examples/popups/screenshot.png
new file mode 100644
index 000000000..c650c1466
--- /dev/null
+++ b/examples/popups/screenshot.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb79ed9f98a4e5b452f52c9d5a857126481aad7c98e871895b8eea90d89c61c7
+size 20053
diff --git a/examples/popups/src/main.rs b/examples/popups/src/main.rs
index baed12c2a..3da475832 100644
--- a/examples/popups/src/main.rs
+++ b/examples/popups/src/main.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 #![allow(rustdoc::missing_crate_level_docs)] // it's an example
 
-use eframe::egui::{popup_below_widget, CentralPanel, ComboBox, Id, PopupCloseBehavior};
+use eframe::egui::{CentralPanel, ComboBox, Popup, PopupCloseBehavior};
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -42,23 +42,14 @@ impl eframe::App for MyApp {
 
             ui.label("PopupCloseBehavior::IgnoreClicks popup");
             let response = ui.button("Open");
-            let popup_id = Id::new("popup_id");
 
-            if response.clicked() {
-                ui.memory_mut(|mem| mem.toggle_popup(popup_id));
-            }
-
-            popup_below_widget(
-                ui,
-                popup_id,
-                &response,
-                PopupCloseBehavior::IgnoreClicks,
-                |ui| {
+            Popup::menu(&response)
+                .close_behavior(PopupCloseBehavior::IgnoreClicks)
+                .show(|ui| {
                     ui.set_min_width(310.0);
                     ui.label("This popup will be open until you press the button again");
                     ui.checkbox(&mut self.checkbox, "Checkbox");
-                },
-            );
+                });
         });
     }
 }
diff --git a/examples/puffin_profiler/Cargo.toml b/examples/puffin_profiler/Cargo.toml
index d26d8a6cb..2fd92d2ab 100644
--- a/examples/puffin_profiler/Cargo.toml
+++ b/examples/puffin_profiler/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [package.metadata.cargo-machete]
@@ -20,14 +20,11 @@ wgpu = ["eframe/wgpu"]
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
-] }
-log = { workspace = true }
-puffin = "0.19"
-puffin_http = "0.16"
-profiling = {workspace = true, features = ["profile-with-puffin"] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
+log.workspace = true
+puffin.workspace = true
+puffin_http.workspace = true
+profiling = { workspace = true, features = ["profile-with-puffin"] }
diff --git a/examples/puffin_profiler/screenshot.png b/examples/puffin_profiler/screenshot.png
index 319a34730..616b95e09 100644
--- a/examples/puffin_profiler/screenshot.png
+++ b/examples/puffin_profiler/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:610b003b4c7715751d2d3753d304e2c5a0af17c9259fa24f21a97b33b9d0c3c7
-size 8549
+oid sha256:bfc5dcdf4e4a606cc5b656cfe61d9def9ce1a2eb515003a6a339fefc9335079e
+size 29711
diff --git a/examples/puffin_profiler/src/main.rs b/examples/puffin_profiler/src/main.rs
index 91e3d5866..942b57a4a 100644
--- a/examples/puffin_profiler/src/main.rs
+++ b/examples/puffin_profiler/src/main.rs
@@ -2,15 +2,21 @@
 #![allow(rustdoc::missing_crate_level_docs)] // it's an example
 
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
 
 use eframe::egui;
 
 fn main() -> eframe::Result {
     let rust_log = std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_owned());
-    std::env::set_var("RUST_LOG", rust_log);
+
+    // SAFETY: we call this from the main thread without any other threads running.
+    #[expect(unsafe_code)]
+    unsafe {
+        std::env::set_var("RUST_LOG", rust_log);
+    };
+
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
     start_puffin_server(); // NOTE: you may only want to call this if the users specifies some flag or clicks a button!
 
@@ -31,7 +37,7 @@ fn main() -> eframe::Result {
 struct MyApp {
     keep_repainting: bool,
 
-    // It is useful to be able t oinspect how eframe acts with multiple viewport
+    // It is useful to be able to inspect how eframe acts with multiple viewport
     // so we have two viewports here that we can toggle on/off.
     show_immediate_viewport: bool,
     show_deferred_viewport: Arc<AtomicBool>,
@@ -165,11 +171,11 @@ fn start_puffin_server() {
 
             // 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)]
+            #[expect(clippy::mem_forget)]
             std::mem::forget(puffin_server);
         }
         Err(err) => {
             log::error!("Failed to start puffin server: {err}");
         }
-    };
+    }
 }
diff --git a/examples/screenshot/Cargo.toml b/examples/screenshot/Cargo.toml
index b5a22ce7b..983963469 100644
--- a/examples/screenshot/Cargo.toml
+++ b/examples/screenshot/Cargo.toml
@@ -1,13 +1,10 @@
 [package]
 name = "screenshot"
 version = "0.1.0"
-authors = [
-    "René Rössler <rene@freshx.de>",
-    "Andreas Faber <andreas.mfaber@gmail.com",
-]
+authors = ["René Rössler <rene@freshx.de>", "Andreas Faber <andreas.mfaber@gmail.com"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -16,12 +13,9 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-    "wgpu",
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+  "wgpu",
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
 image = { workspace = true, features = ["png"] }
diff --git a/examples/screenshot/src/main.rs b/examples/screenshot/src/main.rs
index 1dd0bbf50..0cff59a93 100644
--- a/examples/screenshot/src/main.rs
+++ b/examples/screenshot/src/main.rs
@@ -57,7 +57,7 @@ impl eframe::App for MyApp {
                             ctx.set_theme(egui::Theme::Dark);
                         } else {
                             ctx.set_theme(egui::Theme::Light);
-                        };
+                        }
                         ctx.send_viewport_cmd(
                             egui::ViewportCommand::Screenshot(Default::default()),
                         );
diff --git a/examples/serial_windows/Cargo.toml b/examples/serial_windows/Cargo.toml
index c18a6029d..7b1347f01 100644
--- a/examples/serial_windows/Cargo.toml
+++ b/examples/serial_windows/Cargo.toml
@@ -3,8 +3,8 @@ 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.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -13,11 +13,8 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
-] }
-log = { workspace = true }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
+log.workspace = true
diff --git a/examples/serial_windows/README.md b/examples/serial_windows/README.md
index 7543f95ca..9cf60b01f 100644
--- a/examples/serial_windows/README.md
+++ b/examples/serial_windows/README.md
@@ -7,8 +7,7 @@ Expected order of execution:
 - 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>.
+NOTE: this doesn't work on Mac. See also <https://github.com/emilk/egui/issues/1918>.
 
 ```sh
 cargo run -p serial_windows
diff --git a/examples/user_attention/Cargo.toml b/examples/user_attention/Cargo.toml
index 3ae28d693..2bd156cc3 100644
--- a/examples/user_attention/Cargo.toml
+++ b/examples/user_attention/Cargo.toml
@@ -3,8 +3,8 @@ name = "user_attention"
 version = "0.1.0"
 authors = ["TicClick <ya@ticclick.ch>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -12,10 +12,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/examples/user_attention/screenshot.png b/examples/user_attention/screenshot.png
index 015bdf7ec..e38a84958 100644
--- a/examples/user_attention/screenshot.png
+++ b/examples/user_attention/screenshot.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:85a508fa7d16d9bc51f38d3531b30f024d8888f7f74bf2f351453fd13d13e0aa
-size 5928
+oid sha256:d3b56bdd917a8f789f5bad954bbd37fc27ddec404025dd0608894e5d50e9f37f
+size 7375
diff --git a/examples/user_attention/src/main.rs b/examples/user_attention/src/main.rs
index 3d171c279..ccec8c92a 100644
--- a/examples/user_attention/src/main.rs
+++ b/examples/user_attention/src/main.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 #![allow(rustdoc::missing_crate_level_docs)] // it's an example
 
-use eframe::{egui, CreationContext, NativeOptions};
+use eframe::{CreationContext, NativeOptions, egui};
 use egui::{Button, CentralPanel, Context, UserAttentionType};
 
 use std::time::{Duration, SystemTime};
@@ -56,24 +56,24 @@ impl Application {
 
 impl eframe::App for Application {
     fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
-        if let Some(request_at) = self.request_at {
-            if request_at < SystemTime::now() {
-                self.request_at = None;
-                ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(self.attention));
-                if self.auto_reset {
-                    self.auto_reset = false;
-                    self.reset_at = Some(SystemTime::now() + Self::attention_reset_timeout());
-                }
+        if let Some(request_at) = self.request_at
+            && request_at < SystemTime::now()
+        {
+            self.request_at = None;
+            ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(self.attention));
+            if self.auto_reset {
+                self.auto_reset = false;
+                self.reset_at = Some(SystemTime::now() + Self::attention_reset_timeout());
             }
         }
 
-        if let Some(reset_at) = self.reset_at {
-            if reset_at < SystemTime::now() {
-                self.reset_at = None;
-                ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(
-                    UserAttentionType::Reset,
-                ));
-            }
+        if let Some(reset_at) = self.reset_at
+            && reset_at < SystemTime::now()
+        {
+            self.reset_at = None;
+            ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(
+                UserAttentionType::Reset,
+            ));
         }
 
         CentralPanel::default().show(ctx, |ui| {
diff --git a/lychee.toml b/lychee.toml
new file mode 100644
index 000000000..21e91f2ef
--- /dev/null
+++ b/lychee.toml
@@ -0,0 +1,46 @@
+################################################################################
+# Config for the link checker lychee.
+#
+# Download & learn more at:
+# https://github.com/lycheeverse/lychee
+#
+# Example config:
+# https://github.com/lycheeverse/lychee/blob/master/lychee.example.toml
+#
+# Run `lychee . --dump` to list all found links that are being checked.
+#
+# Note that by default lychee will only check markdown and html files,
+# to check any other files you have to point to them explicitly, e.g.:
+# `lychee **/*.rs`.
+#
+# This unfortunately doesn't list anything for non-glob checks.
+################################################################################
+
+# Maximum number of concurrent link checks.
+# Workaround for "too many open files" error on MacOS, see https://github.com/lycheeverse/lychee/issues/1248
+max_concurrency = 32
+
+# Check links inside `<code>` and `<pre>` blocks as well as Markdown code blocks.
+include_verbatim = true
+
+# Proceed for server connections considered insecure (invalid TLS).
+insecure = true
+
+# Maximum number of allowed retries before a link is declared dead.
+max_retries = 4
+
+# Wait time between attempts in seconds.
+retry_wait_time = 2
+
+# Comma-separated list of accepted status codes for valid links.
+accept = [
+  "100..=103", # Informational codes.
+  "200..=299", # Success codes.
+  "429", # Too many requests. This is practically never a sign of a broken link.
+]
+
+# Exclude URLs and mail addresses from checking (supports regex).
+exclude = [
+  "https://creativecommons.org/.*", # They don't like bots
+  "https://www.unicode.org/.*",
+]
diff --git a/media/0.9.0-disabled.gif b/media/0.9.0-disabled.gif
index 002aff5d6..b032b3731 100644
Binary files a/media/0.9.0-disabled.gif and b/media/0.9.0-disabled.gif differ
diff --git a/media/demo-2021-01-17.gif b/media/demo-2021-01-17.gif
index d45671566..a1045518c 100644
Binary files a/media/demo-2021-01-17.gif and b/media/demo-2021-01-17.gif differ
diff --git a/media/demo.gif b/media/demo.gif
index 2df2ed080..67234b45b 100644
Binary files a/media/demo.gif and b/media/demo.gif differ
diff --git a/media/egui-0.10-plot.gif b/media/egui-0.10-plot.gif
index ecd8fd204..d952adedd 100644
Binary files a/media/egui-0.10-plot.gif and b/media/egui-0.10-plot.gif differ
diff --git a/media/egui-0.15-code-editor.gif b/media/egui-0.15-code-editor.gif
index 67648b789..a929b400c 100644
Binary files a/media/egui-0.15-code-editor.gif and b/media/egui-0.15-code-editor.gif differ
diff --git a/media/widget_gallery.gif b/media/widget_gallery.gif
index 87ad694f4..3b1fb9032 100644
Binary files a/media/widget_gallery.gif and b/media/widget_gallery.gif differ
diff --git a/media/widget_gallery_0.23.gif b/media/widget_gallery_0.23.gif
index 666631079..e7f33004f 100644
Binary files a/media/widget_gallery_0.23.gif and b/media/widget_gallery_0.23.gif differ
diff --git a/media/widget_gallery_0.8.0.gif b/media/widget_gallery_0.8.0.gif
index 8ee7d0b83..805b21bdb 100644
Binary files a/media/widget_gallery_0.8.0.gif and b/media/widget_gallery_0.8.0.gif differ
diff --git a/rust-toolchain b/rust-toolchain
index 0eefd31bc..20a74465b 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -5,6 +5,6 @@
 # to the user in the error, instead of "error: invalid channel name '[toolchain]'".
 
 [toolchain]
-channel = "1.81.0"
+channel = "1.88.0"
 components = ["rustfmt", "clippy"]
 targets = ["wasm32-unknown-unknown"]
diff --git a/scripts/accept_snapshots.sh b/scripts/accept_snapshots.sh
new file mode 100755
index 000000000..9e02eadbc
--- /dev/null
+++ b/scripts/accept_snapshots.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+# This script moves all {name}.new.png files to {name}.png.
+# Its main use is in the update_kittest_snapshots CI job, but you can also use it locally.
+
+set -eu
+
+# rename the .new.png files to .png
+find . -type d -path "*/tests/snapshots*" | while read dir; do
+    find "$dir" -type f -name "*.new.png" | while read file; do
+        mv -f "$file" "${file%.new.png}.png"
+    done
+done
+
+echo "Done!"
diff --git a/scripts/build_demo_web.sh b/scripts/build_demo_web.sh
index b6eb7197a..4ba3846db 100755
--- a/scripts/build_demo_web.sh
+++ b/scripts/build_demo_web.sh
@@ -13,13 +13,13 @@ OPEN=false
 OPTIMIZE=false
 BUILD=debug
 BUILD_FLAGS=""
-WGPU=false
+GLOW=false
 WASM_OPT_FLAGS="-O2 --fast-math"
 
 while test $# -gt 0; do
   case "$1" in
     -h|--help)
-      echo "build_demo_web.sh [--release] [--wgpu] [--open]"
+      echo "build_demo_web.sh [--release] [--glow] [--open]"
       echo ""
       echo "  -g:        Keep debug symbols even with --release."
       echo "             These are useful profiling and size trimming."
@@ -29,9 +29,7 @@ while test $# -gt 0; do
       echo "  --release: Build with --release, and then run wasm-opt."
       echo "             NOTE: --release also removes debug symbols, unless you also use -g."
       echo ""
-      echo "  --wgpu:    Build a binary using wgpu instead of glow/webgl."
-      echo "             The resulting binary will automatically use WebGPU if available and"
-      echo "             fall back to a WebGL emulation layer otherwise."
+      echo "  --glow:    Build a binary using glow instead of wgpu."
       exit 0
       ;;
 
@@ -52,9 +50,9 @@ while test $# -gt 0; do
       BUILD_FLAGS="--release"
       ;;
 
-    --wgpu)
+    --glow)
       shift
-      WGPU=true
+      GLOW=true
       ;;
 
     *)
@@ -66,10 +64,10 @@ done
 
 OUT_FILE_NAME="egui_demo_app"
 
-if [[ "${WGPU}" == true ]]; then
-  FEATURES="${FEATURES},wgpu"
-else
+if [[ "${GLOW}" == true ]]; then
   FEATURES="${FEATURES},glow"
+else
+  FEATURES="${FEATURES},wgpu"
 fi
 
 FINAL_WASM_PATH=web_demo/${OUT_FILE_NAME}_bg.wasm
diff --git a/scripts/check.sh b/scripts/check.sh
index 0d835617b..ffee218f6 100755
--- a/scripts/check.sh
+++ b/scripts/check.sh
@@ -9,7 +9,7 @@ set -x
 # Checks all tests, lints etc.
 # Basically does what the CI does.
 
-cargo +1.81.0 install --quiet typos-cli
+# cargo +1.88.0 install --quiet typos-cli
 
 export RUSTFLAGS="-D warnings"
 export RUSTDOCFLAGS="-D warnings" # https://github.com/emilk/egui/pull/1454
@@ -35,20 +35,20 @@ cargo test  --quiet --doc # slow - checks all doc-tests
 
 cargo check --quiet -p eframe --no-default-features --features "glow"
 if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-  cargo check --quiet -p eframe --no-default-features --features "wgpu","x11"
-  cargo check --quiet -p eframe --no-default-features --features "wgpu","wayland"
+    cargo check --quiet -p eframe --no-default-features --features "wgpu","x11"
+    cargo check --quiet -p eframe --no-default-features --features "wgpu","wayland"
 else
-  cargo check --quiet -p eframe --no-default-features --features "wgpu"
+    cargo check --quiet -p eframe --no-default-features --features "wgpu"
 fi
 
 cargo check --quiet -p egui --no-default-features --features "serde"
 cargo check --quiet -p egui_demo_app --no-default-features --features "glow"
 
 if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-  cargo check --quiet -p egui_demo_app --no-default-features --features "wgpu","x11"
-  cargo check --quiet -p egui_demo_app --no-default-features --features "wgpu","wayland"
+    cargo check --quiet -p egui_demo_app --no-default-features --features "wgpu","x11"
+    cargo check --quiet -p egui_demo_app --no-default-features --features "wgpu","wayland"
 else
-  cargo check --quiet -p egui_demo_app --no-default-features --features "wgpu"
+    cargo check --quiet -p egui_demo_app --no-default-features --features "wgpu"
 fi
 
 cargo check --quiet -p egui_demo_lib --no-default-features
diff --git a/scripts/clippy_wasm/clippy.toml b/scripts/clippy_wasm/clippy.toml
index 2d34d64fc..d2b8365d9 100644
--- a/scripts/clippy_wasm/clippy.toml
+++ b/scripts/clippy_wasm/clippy.toml
@@ -6,7 +6,7 @@
 # -----------------------------------------------------------------------------
 # Section identical to the root clippy.toml:
 
-msrv = "1.81"
+msrv = "1.88"
 
 allow-unwrap-in-tests = true
 
@@ -26,12 +26,11 @@ type-complexity-threshold = 350
 
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
 disallowed-methods = [
-  "std::time::Instant::now",      # use `instant` crate instead for wasm/web compatibility
-  "std::time::Duration::elapsed", # use `instant` crate instead for wasm/web compatibility
-  "std::time::SystemTime::now",   # use `instant` or `time` crates instead for wasm/web compatibility
+  { path = "std::time::Instant::elapsed", reason = "use `instant` crate instead for wasm/web compatibility" },
+  { path = "std::time::Instant::now", reason = "use `instant` crate instead for wasm/web compatibility" },
+  { path = "std::time::SystemTime::now", reason = "use `instant` or `time` crates instead for wasm/web compatibility" },
 
-  # Cannot spawn threads on wasm:
-  "std::thread::spawn",
+  { path = "std::thread::spawn", reason = "Cannot spawn threads on wasm" },
 ]
 
 # https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
diff --git a/scripts/docs.sh b/scripts/docs.sh
index ee8f863fe..5d755ddc4 100755
--- a/scripts/docs.sh
+++ b/scripts/docs.sh
@@ -4,6 +4,6 @@ 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 doc -p emath -p epaint -p egui -p eframe -p egui-winit -p egui_extras -p egui_glow -p egui_kittest --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/scripts/generate_changelog.py b/scripts/generate_changelog.py
index 7e3ae4284..e54b18431 100755
--- a/scripts/generate_changelog.py
+++ b/scripts/generate_changelog.py
@@ -192,7 +192,9 @@ def remove_prefix(text, prefix):
 def print_section(heading: str, content: str) -> None:
     if content != "":
         print(f"## {heading}")
-        print(content)
+        print(content.strip())
+        print()
+        print()
         print()
 
 
@@ -270,6 +272,7 @@ def main() -> None:
         "egui-wgpu",
         "egui-winit",
         "egui",
+        "emath",
         "epaint",
         "epaint_default_fonts",
     ]
@@ -345,11 +348,8 @@ def main() -> None:
     print()
     for crate in crate_names:
         if crate in crate_sections:
-            prs = crate_sections[crate]
-            print_section(crate, changelog_from_prs(prs, crate))
-    print()
+            print_section(crate, changelog_from_prs(crate_sections[crate], crate))
     print_section("Unsorted PRs", "\n".join([f"* {item}" for item in unsorted_prs]))
-    print()
     print_section(
         "Unsorted commits", "\n".join([f"* {item}" for item in unsorted_commits])
     )
diff --git a/scripts/generate_example_screenshots.sh b/scripts/generate_example_screenshots.sh
index 91e338d31..e2ed2361e 100755
--- a/scripts/generate_example_screenshots.sh
+++ b/scripts/generate_example_screenshots.sh
@@ -7,10 +7,12 @@ cd "$script_path/.."
 
 cd examples
 for EXAMPLE_NAME in $(ls -1d */ | sed 's/\/$//'); do
-    if [ ${EXAMPLE_NAME} != "hello_world_par" ] && # screenshot not implemented for wgpu backend
+    if [ ${EXAMPLE_NAME} != "external_eventloop_async" ] &&
+       [ ${EXAMPLE_NAME} != "hello_android" ] &&
+       [ ${EXAMPLE_NAME} != "hello_world_par" ] && # screenshot not implemented for wgpu backend
        [ ${EXAMPLE_NAME} != "multiple_viewports" ] &&
-       [ ${EXAMPLE_NAME} != "screenshot" ] &&
        [ ${EXAMPLE_NAME} != "puffin_viewer" ] &&
+       [ ${EXAMPLE_NAME} != "screenshot" ] &&
        [ ${EXAMPLE_NAME} != "serial_windows" ];
     then
         echo ""
diff --git a/scripts/publish_crates.sh b/scripts/publish_crates.sh
new file mode 100755
index 000000000..a8fb54c53
--- /dev/null
+++ b/scripts/publish_crates.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+(cd crates/emath                && cargo publish --quiet)  &&  echo "✅ emath"
+(cd crates/ecolor               && cargo publish --quiet)  &&  echo "✅ ecolor"
+(cd crates/epaint_default_fonts && cargo publish --quiet)  &&  echo "✅ epaint_default_fonts"
+(cd crates/epaint               && cargo publish --quiet)  &&  echo "✅ epaint"
+(cd crates/egui                 && cargo publish --quiet)  &&  echo "✅ egui"
+(cd crates/egui-winit           && cargo publish --quiet)  &&  echo "✅ egui-winit"
+(cd crates/egui_glow            && cargo publish --quiet)  &&  echo "✅ egui_glow"
+(cd crates/egui-wgpu            && cargo publish --quiet)  &&  echo "✅ egui-wgpu"
+(cd crates/eframe               && cargo publish --quiet)  &&  echo "✅ eframe"
+(cd crates/egui_extras          && cargo publish --quiet)  &&  echo "✅ egui_extras"
+(cd crates/egui_kittest         && cargo publish --quiet)  &&  echo "✅ egui_kittest"
+(cd crates/egui_demo_lib        && cargo publish --quiet)  &&  echo "✅ egui_demo_lib"
diff --git a/scripts/setup_web.sh b/scripts/setup_web.sh
index a49f82059..f51258855 100755
--- a/scripts/setup_web.sh
+++ b/scripts/setup_web.sh
@@ -9,6 +9,7 @@ set -x
 rustup target add wasm32-unknown-unknown
 
 # For generating JS bindings:
-if ! cargo install --list | grep -q 'wasm-bindgen-cli v0.2.97'; then
-    cargo install --force --quiet wasm-bindgen-cli --version 0.2.97
+# Keep wasm-bindgen version in sync in: setup_web.sh, Cargo.toml, Cargo.lock, rust.yml
+if ! cargo install --list | grep -q 'wasm-bindgen-cli v0.2.100'; then
+    cargo install --force --quiet wasm-bindgen-cli --version 0.2.100
 fi
diff --git a/scripts/update_snapshots_from_ci.sh b/scripts/update_snapshots_from_ci.sh
new file mode 100755
index 000000000..46262d727
--- /dev/null
+++ b/scripts/update_snapshots_from_ci.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# This script searches for the last CI run with your branch name, downloads the test_results artifact
+# and replaces your existing snapshots with the new ones.
+# Make sure you have the gh cli installed and authenticated before running this script.
+# If prompted to select a default repo, choose the emilk/egui one
+
+set -eu
+
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+if [ -z "${RUN_ID:-}" ]; then
+    RUN_ID=$(gh run list --branch "$BRANCH" --workflow "Rust" --json databaseId -q '.[0].databaseId')
+    echo "Downloading test results from run $RUN_ID from branch $BRANCH"
+else
+    echo "Using provided RUN_ID: $RUN_ID"
+fi
+
+# remove any existing .new.png that might have been left behind
+find . -type d -path "*/tests/snapshots*" | while read dir; do
+    find "$dir" -type f -name "*.new.png" | while read file; do
+        rm "$file"
+    done
+done
+
+
+gh run download "$RUN_ID" --name "test-results" --dir tmp_artefacts
+
+# move the snapshots to the correct location, overwriting the existing ones
+rsync -a tmp_artefacts/ .
+
+rm -r tmp_artefacts
+
+./scripts/accept_snapshots.sh
diff --git a/taplo.toml b/taplo.toml
new file mode 100644
index 000000000..06c7290b0
--- /dev/null
+++ b/taplo.toml
@@ -0,0 +1,13 @@
+# https://github.com/tamasfe/taplo
+
+include = [
+  "*.toml",
+  "crates/**/*.toml",
+  "examples/**/*.toml",
+  "scripts/**/*.toml",
+  "tests/**/*.toml",
+]
+
+[formatting]
+align_comments = false # causes unnecessary churn
+column_width = 100
diff --git a/tests/egui_tests/Cargo.toml b/tests/egui_tests/Cargo.toml
new file mode 100644
index 000000000..8c09042b1
--- /dev/null
+++ b/tests/egui_tests/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "egui_tests"
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dev-dependencies]
+egui = { workspace = true, default-features = true }
+egui_kittest = { workspace = true, features = ["snapshot", "wgpu"] }
+egui_extras = { workspace = true, features = ["image"] }
+image = { workspace = true, features = ["png"] }
+
+[lints]
+workspace = true
diff --git a/tests/egui_tests/tests/regression_tests.rs b/tests/egui_tests/tests/regression_tests.rs
new file mode 100644
index 000000000..9e76394cb
--- /dev/null
+++ b/tests/egui_tests/tests/regression_tests.rs
@@ -0,0 +1,120 @@
+use egui::accesskit::Role;
+use egui::{Align, Color32, Image, Label, Layout, RichText, Sense, TextWrapMode, include_image};
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable as _;
+
+#[test]
+fn image_button_should_have_alt_text() {
+    let harness = Harness::new_ui(|ui| {
+        _ = ui.button(
+            Image::new(include_image!("../../../crates/eframe/data/icon.png")).alt_text("Egui"),
+        );
+    });
+
+    harness.get_by_label("Egui");
+}
+
+#[test]
+fn hovering_should_preserve_text_format() {
+    let mut harness = Harness::builder().with_size((200.0, 70.0)).build_ui(|ui| {
+        ui.add(
+            Label::new(
+                RichText::new("Long text that should be elided and has lots of styling and is long enough to have multiple lines.")
+                    .italics()
+                    .underline()
+                    .color(Color32::LIGHT_BLUE),
+            )
+            .wrap_mode(TextWrapMode::Truncate),
+        );
+    });
+
+    harness.get_by_label_contains("Long text").hover();
+
+    harness.run_steps(5);
+
+    harness.snapshot("hovering_should_preserve_text_format");
+}
+
+#[test]
+fn text_edit_rtl() {
+    let mut text = "hello ".to_owned();
+    let mut harness = Harness::builder().with_size((200.0, 50.0)).build_ui(|ui| {
+        ui.with_layout(Layout::right_to_left(Align::Min), |ui| {
+            _ = ui.button("right");
+            ui.add(
+                egui::TextEdit::singleline(&mut text)
+                    .desired_width(10.0)
+                    .clip_text(false),
+            );
+            _ = ui.button("left");
+        });
+    });
+
+    harness.get_by_role(Role::TextInput).focus();
+    harness.step();
+    harness.snapshot("text_edit_rtl_0");
+
+    harness.get_by_role(Role::TextInput).type_text("world");
+
+    for i in 1..3 {
+        harness.step();
+        harness.snapshot(format!("text_edit_rtl_{i}"));
+    }
+}
+
+#[test]
+fn combobox_should_have_value() {
+    let harness = Harness::new_ui(|ui| {
+        egui::ComboBox::from_label("Select an option")
+            .selected_text("Option 1")
+            .show_ui(ui, |_ui| {});
+    });
+
+    assert_eq!(
+        harness.get_by_label("Select an option").value().as_deref(),
+        Some("Option 1")
+    );
+}
+
+/// This test ensures that `ui.response().interact(...)` works correctly.
+///
+/// This was broken, because there was an optimization in [`egui::Response::interact`]
+/// which caused the [`Sense`] of the original response to flip-flop between `click` and `hover`
+/// between frames.
+///
+/// See <https://github.com/emilk/egui/pull/7713> for more details.
+#[test]
+fn interact_on_ui_response_should_be_stable() {
+    let mut first_frame = true;
+    let mut click_count = 0;
+    let mut harness = Harness::new_ui(|ui| {
+        let ui_response = ui.response();
+        if !first_frame {
+            assert!(
+                ui_response.sense.contains(Sense::click()),
+                "ui.response() didn't have click sense even though we called interact(Sense::click()) last frame"
+            );
+        }
+
+        // Add a label so we have something to click with kittest
+        ui.add(
+            Label::new("senseless label")
+                .sense(Sense::hover())
+                .selectable(false),
+        );
+
+        let click_response = ui_response.interact(Sense::click());
+        if click_response.clicked() {
+            click_count += 1;
+        }
+        first_frame = false;
+    });
+
+    for i in 0..=10 {
+        harness.run_steps(i);
+        harness.get_by_label("senseless label").click();
+    }
+
+    drop(harness);
+    assert_eq!(click_count, 10, "We missed some clicks!");
+}
diff --git a/tests/egui_tests/tests/snapshots/button_shortcut.png b/tests/egui_tests/tests/snapshots/button_shortcut.png
new file mode 100644
index 000000000..7f39196b8
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/button_shortcut.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5befd84158b582c79a968f36e43c7017187b364824eb4470b048d133e62f9360
+size 1600
diff --git a/tests/egui_tests/tests/snapshots/grow_all.png b/tests/egui_tests/tests/snapshots/grow_all.png
new file mode 100644
index 000000000..373889987
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/grow_all.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:469a1b1faa71da472c07bcc7103933db9964440a4c49dc596220f070e9b483f5
+size 14375
diff --git a/tests/egui_tests/tests/snapshots/hovering_should_preserve_text_format.png b/tests/egui_tests/tests/snapshots/hovering_should_preserve_text_format.png
new file mode 100644
index 000000000..2b3ac7a50
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/hovering_should_preserve_text_format.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cac533a01c65c8eef093efcd4c9036da50f898ea2436612990f4c2365c98ad83
+size 12126
diff --git a/tests/egui_tests/tests/snapshots/layout/atoms_image.png b/tests/egui_tests/tests/snapshots/layout/atoms_image.png
new file mode 100644
index 000000000..bf98d3d2d
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/atoms_image.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:070638cd5c174200161498123a612e4a58d58517b539e91e289d1e3dd38670bb
+size 388531
diff --git a/tests/egui_tests/tests/snapshots/layout/atoms_minimal.png b/tests/egui_tests/tests/snapshots/layout/atoms_minimal.png
new file mode 100644
index 000000000..ae17dff6a
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/atoms_minimal.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac8885d6e5325b5f1f0ccb11f185df5c4937b66c80159aa8cf53930f5c8045e2
+size 395599
diff --git a/tests/egui_tests/tests/snapshots/layout/atoms_multi_grow.png b/tests/egui_tests/tests/snapshots/layout/atoms_multi_grow.png
new file mode 100644
index 000000000..97c181c70
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/atoms_multi_grow.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05b891dd999050150f4cd4226a1c68673b352f04d08d405751d66c698c7711c5
+size 309736
diff --git a/tests/egui_tests/tests/snapshots/layout/button.png b/tests/egui_tests/tests/snapshots/layout/button.png
new file mode 100644
index 000000000..e53754f51
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/button.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e8a7835e3fd22aafc22b6c536051367e2c27c8607fbe5d8b6b6cf6d0ba3d54f
+size 332771
diff --git a/tests/egui_tests/tests/snapshots/layout/button_image.png b/tests/egui_tests/tests/snapshots/layout/button_image.png
new file mode 100644
index 000000000..ece6568e9
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/button_image.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59cbb416865f8bede12b449d8e65baddb6949df017face2782a3492de7a058e3
+size 355276
diff --git a/tests/egui_tests/tests/snapshots/layout/button_image_shortcut.png b/tests/egui_tests/tests/snapshots/layout/button_image_shortcut.png
new file mode 100644
index 000000000..13f860b83
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/button_image_shortcut.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cad07a16b6f0eb8c7647c7d0500ea99c68dddf2eef892b4df48aa20f581e8a85
+size 438837
diff --git a/tests/egui_tests/tests/snapshots/layout/checkbox.png b/tests/egui_tests/tests/snapshots/layout/checkbox.png
new file mode 100644
index 000000000..18ebbdb7c
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/checkbox.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4747efdf758e7e8e2d7f3954d9595dfd45d3b4b86923b8ff39c8a96002bb4825
+size 408726
diff --git a/tests/egui_tests/tests/snapshots/layout/checkbox_checked.png b/tests/egui_tests/tests/snapshots/layout/checkbox_checked.png
new file mode 100644
index 000000000..127aa7f30
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/checkbox_checked.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a3ca4b3a47ff516f9b05799cdf5f92845ae1e058728d635986cc61b7317f110
+size 437102
diff --git a/tests/egui_tests/tests/snapshots/layout/drag_value.png b/tests/egui_tests/tests/snapshots/layout/drag_value.png
new file mode 100644
index 000000000..471d3b867
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/drag_value.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c168f197bec3bc780553db0a47f464f8d76afc606e28e2545ecd91f174abe551
+size 249781
diff --git a/tests/egui_tests/tests/snapshots/layout/radio.png b/tests/egui_tests/tests/snapshots/layout/radio.png
new file mode 100644
index 000000000..07e20176d
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/radio.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39f1985a3a975b1b9a179d3b1bd5832e0b4c30d10232babf2e4736f55b43989f
+size 350051
diff --git a/tests/egui_tests/tests/snapshots/layout/radio_checked.png b/tests/egui_tests/tests/snapshots/layout/radio_checked.png
new file mode 100644
index 000000000..2163011e6
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/radio_checked.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18a38fe66d5ac8f2cf5c109f1cd9c29951e5bf8428b6bf0d4587dfc8f8c5c890
+size 370205
diff --git a/tests/egui_tests/tests/snapshots/layout/selectable_value.png b/tests/egui_tests/tests/snapshots/layout/selectable_value.png
new file mode 100644
index 000000000..2ee7f7d0e
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/selectable_value.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfc900ea84b408564652df487e705311b164d9bd3ff5631c3cebb83b06497a7b
+size 410131
diff --git a/tests/egui_tests/tests/snapshots/layout/selectable_value_selected.png b/tests/egui_tests/tests/snapshots/layout/selectable_value_selected.png
new file mode 100644
index 000000000..7e3dd6319
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/selectable_value_selected.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9d08ce85c9210a7d9046480ab208040e5ba399c40acaecf5cb43f807534bce9
+size 423523
diff --git a/tests/egui_tests/tests/snapshots/layout/slider.png b/tests/egui_tests/tests/snapshots/layout/slider.png
new file mode 100644
index 000000000..b8cc394c4
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/slider.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b402195e54bdbd09985e4b30a025083298f29ab747b809fbb864c8dfef0975eb
+size 289714
diff --git a/tests/egui_tests/tests/snapshots/layout/text_edit.png b/tests/egui_tests/tests/snapshots/layout/text_edit.png
new file mode 100644
index 000000000..8b53899dd
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/text_edit.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ed6af3a92790e07b71e71637b5d6bb45d55a7d26738d438714aca64d7f4534c
+size 245394
diff --git a/tests/egui_tests/tests/snapshots/layout/text_edit_clip.png b/tests/egui_tests/tests/snapshots/layout/text_edit_clip.png
new file mode 100644
index 000000000..0c4327b58
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/text_edit_clip.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f107d95fee9a5fb5fbfd2422452e1820738a84c81774587dbfa8153e91e4c73
+size 414552
diff --git a/tests/egui_tests/tests/snapshots/layout/text_edit_no_clip.png b/tests/egui_tests/tests/snapshots/layout/text_edit_no_clip.png
new file mode 100644
index 000000000..ecc6efa8b
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/text_edit_no_clip.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c1aebada9349f8cb4046469b0a6f9796a21f88b6724bd85cd832a40b8007409
+size 540527
diff --git a/tests/egui_tests/tests/snapshots/layout/text_edit_placeholder_clip.png b/tests/egui_tests/tests/snapshots/layout/text_edit_placeholder_clip.png
new file mode 100644
index 000000000..780fec82f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/layout/text_edit_placeholder_clip.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:685de2e33ff26aafa87426bcda18bb9963c2deb2a811cd0aae4450af0e245a06
+size 390735
diff --git a/tests/egui_tests/tests/snapshots/max_width.png b/tests/egui_tests/tests/snapshots/max_width.png
new file mode 100644
index 000000000..a10284911
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/max_width.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e2dc33b2d4caddac86dd8649d09ff3d57187a0152240f824a6aa170a35dd719
+size 8570
diff --git a/tests/egui_tests/tests/snapshots/max_width_and_grow.png b/tests/egui_tests/tests/snapshots/max_width_and_grow.png
new file mode 100644
index 000000000..b0d5c134f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/max_width_and_grow.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36ab2c05eade94dcfe524651a0954c122aea754976af94a73a7efd950055c9eb
+size 8574
diff --git a/tests/egui_tests/tests/snapshots/shrink_first_text.png b/tests/egui_tests/tests/snapshots/shrink_first_text.png
new file mode 100644
index 000000000..7bae217bb
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/shrink_first_text.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2ba53264abcaa2ee79858ddbd475ed35aa28d146b846cbc080c26911d373ea6
+size 11881
diff --git a/tests/egui_tests/tests/snapshots/shrink_last_text.png b/tests/egui_tests/tests/snapshots/shrink_last_text.png
new file mode 100644
index 000000000..821490e52
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/shrink_last_text.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:082d80ae144338dce45169c02038b6dc5b75d7b6d93c2a8213ddbb2a8784cc92
+size 12435
diff --git a/tests/egui_tests/tests/snapshots/sides/default_long.png b/tests/egui_tests/tests/snapshots/sides/default_long.png
new file mode 100644
index 000000000..452ed723a
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/default_long.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e455b08f4674a9326682771f12456a71cc22dfd733ee965fdbbb5582cba0380
+size 8176
diff --git a/tests/egui_tests/tests/snapshots/sides/default_long_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/default_long_fit_contents.png
new file mode 100644
index 000000000..ce5996d2f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/default_long_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36600579bd2b5a9f255c9d843ccb76e74c622bc7d206962f52e3519e21dc2cfc
+size 8963
diff --git a/tests/egui_tests/tests/snapshots/sides/default_short.png b/tests/egui_tests/tests/snapshots/sides/default_short.png
new file mode 100644
index 000000000..2d7ccae52
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/default_short.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad4ffb19388aeafd11891f487953525c335b0d10bceb455274df532582733c8
+size 1700
diff --git a/tests/egui_tests/tests/snapshots/sides/default_short_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/default_short_fit_contents.png
new file mode 100644
index 000000000..9c5635e19
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/default_short_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a2985caf40b9bacf9f18c84240181f84bea04cc413a009d5ca68c8d544ffa35
+size 1305
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_left_long.png b/tests/egui_tests/tests/snapshots/sides/shrink_left_long.png
new file mode 100644
index 000000000..cc17a1c48
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_left_long.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d36fb3c42b7f74e0b6dd8e73b9f8455e7fac035f5979cb93769e6a3f5453fdbc
+size 7239
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_left_long_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/shrink_left_long_fit_contents.png
new file mode 100644
index 000000000..ce5996d2f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_left_long_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36600579bd2b5a9f255c9d843ccb76e74c622bc7d206962f52e3519e21dc2cfc
+size 8963
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_left_short.png b/tests/egui_tests/tests/snapshots/sides/shrink_left_short.png
new file mode 100644
index 000000000..2d7ccae52
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_left_short.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad4ffb19388aeafd11891f487953525c335b0d10bceb455274df532582733c8
+size 1700
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_left_short_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/shrink_left_short_fit_contents.png
new file mode 100644
index 000000000..9c5635e19
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_left_short_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a2985caf40b9bacf9f18c84240181f84bea04cc413a009d5ca68c8d544ffa35
+size 1305
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_right_long.png b/tests/egui_tests/tests/snapshots/sides/shrink_right_long.png
new file mode 100644
index 000000000..03ca0a66e
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_right_long.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89d9445d7aaff34ace5322af6efc308f261cf5becfdd11aa7fec016236ecfa84
+size 7064
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_right_long_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/shrink_right_long_fit_contents.png
new file mode 100644
index 000000000..ce5996d2f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_right_long_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36600579bd2b5a9f255c9d843ccb76e74c622bc7d206962f52e3519e21dc2cfc
+size 8963
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_right_short.png b/tests/egui_tests/tests/snapshots/sides/shrink_right_short.png
new file mode 100644
index 000000000..2d7ccae52
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_right_short.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad4ffb19388aeafd11891f487953525c335b0d10bceb455274df532582733c8
+size 1700
diff --git a/tests/egui_tests/tests/snapshots/sides/shrink_right_short_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/shrink_right_short_fit_contents.png
new file mode 100644
index 000000000..9c5635e19
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/shrink_right_short_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a2985caf40b9bacf9f18c84240181f84bea04cc413a009d5ca68c8d544ffa35
+size 1305
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_left_long.png b/tests/egui_tests/tests/snapshots/sides/wrap_left_long.png
new file mode 100644
index 000000000..48332d65b
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_left_long.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7487a1b77fd2db2493bca7d42128aad7a0049962599c8b5add2b7b25376a37d
+size 9381
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_left_long_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/wrap_left_long_fit_contents.png
new file mode 100644
index 000000000..ce5996d2f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_left_long_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36600579bd2b5a9f255c9d843ccb76e74c622bc7d206962f52e3519e21dc2cfc
+size 8963
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_left_short.png b/tests/egui_tests/tests/snapshots/sides/wrap_left_short.png
new file mode 100644
index 000000000..2d7ccae52
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_left_short.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad4ffb19388aeafd11891f487953525c335b0d10bceb455274df532582733c8
+size 1700
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_left_short_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/wrap_left_short_fit_contents.png
new file mode 100644
index 000000000..9c5635e19
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_left_short_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a2985caf40b9bacf9f18c84240181f84bea04cc413a009d5ca68c8d544ffa35
+size 1305
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_right_long.png b/tests/egui_tests/tests/snapshots/sides/wrap_right_long.png
new file mode 100644
index 000000000..fa65ff9db
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_right_long.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f614fb9b2aba8cc5a6997a519ca92083fb4378a36f335570d9e870159267f40
+size 9495
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_right_long_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/wrap_right_long_fit_contents.png
new file mode 100644
index 000000000..ce5996d2f
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_right_long_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36600579bd2b5a9f255c9d843ccb76e74c622bc7d206962f52e3519e21dc2cfc
+size 8963
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_right_short.png b/tests/egui_tests/tests/snapshots/sides/wrap_right_short.png
new file mode 100644
index 000000000..2d7ccae52
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_right_short.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad4ffb19388aeafd11891f487953525c335b0d10bceb455274df532582733c8
+size 1700
diff --git a/tests/egui_tests/tests/snapshots/sides/wrap_right_short_fit_contents.png b/tests/egui_tests/tests/snapshots/sides/wrap_right_short_fit_contents.png
new file mode 100644
index 000000000..9c5635e19
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/sides/wrap_right_short_fit_contents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a2985caf40b9bacf9f18c84240181f84bea04cc413a009d5ca68c8d544ffa35
+size 1305
diff --git a/tests/egui_tests/tests/snapshots/size_max_size.png b/tests/egui_tests/tests/snapshots/size_max_size.png
new file mode 100644
index 000000000..9c5ac8be3
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/size_max_size.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5230bd00a43990b30e523528b609e04916dab3cf87a59d56e39dcd5926f47aa5
+size 8838
diff --git a/tests/egui_tests/tests/snapshots/text_edit_rtl_0.png b/tests/egui_tests/tests/snapshots/text_edit_rtl_0.png
new file mode 100644
index 000000000..d93540222
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/text_edit_rtl_0.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:336581facb1ec989a43291ed76bd8ddb552c46137a75601f466e6dc4dae77278
+size 2395
diff --git a/tests/egui_tests/tests/snapshots/text_edit_rtl_1.png b/tests/egui_tests/tests/snapshots/text_edit_rtl_1.png
new file mode 100644
index 000000000..2ae957da9
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/text_edit_rtl_1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b0684c53a20eaa90a9dccef8ac3eaa2a6eede7c770e7bbbba6d995f43584d99
+size 2353
diff --git a/tests/egui_tests/tests/snapshots/text_edit_rtl_2.png b/tests/egui_tests/tests/snapshots/text_edit_rtl_2.png
new file mode 100644
index 000000000..b9235740d
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/text_edit_rtl_2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38f325f2e741f18f897502c176f9a7efe276e9adab41a144511121dd8b8a3073
+size 3079
diff --git a/tests/egui_tests/tests/snapshots/visuals/button.png b/tests/egui_tests/tests/snapshots/visuals/button.png
new file mode 100644
index 000000000..4c81f62fc
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/button.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c05992e16c1abf6d174fed73d19cad6bb2266e0adb87b8232e765d75fcf3f14
+size 10310
diff --git a/tests/egui_tests/tests/snapshots/visuals/button_image.png b/tests/egui_tests/tests/snapshots/visuals/button_image.png
new file mode 100644
index 000000000..00582f3ae
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/button_image.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7681d33a5a764187c084c966a4e47063136e2832094c44f62718447b1b3027ec
+size 11292
diff --git a/tests/egui_tests/tests/snapshots/visuals/button_image_shortcut.png b/tests/egui_tests/tests/snapshots/visuals/button_image_shortcut.png
new file mode 100644
index 000000000..1429bfd2d
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/button_image_shortcut.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b99a82e9f3dfa24c079545272d680b55c4285c276befa0efc492fe273422f541
+size 14195
diff --git a/tests/egui_tests/tests/snapshots/visuals/button_image_shortcut_selected.png b/tests/egui_tests/tests/snapshots/visuals/button_image_shortcut_selected.png
new file mode 100644
index 000000000..c73effead
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/button_image_shortcut_selected.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdf079228b762949dbc67308103f8fe1328b6c0175f312ccc492d4e86d42127b
+size 13868
diff --git a/tests/egui_tests/tests/snapshots/visuals/checkbox.png b/tests/egui_tests/tests/snapshots/visuals/checkbox.png
new file mode 100644
index 000000000..16d88e546
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/checkbox.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bafe4c157696bfb52940b69501416d4da0b4eab52f34f52220d2e9ed01357cf
+size 12901
diff --git a/tests/egui_tests/tests/snapshots/visuals/checkbox_checked.png b/tests/egui_tests/tests/snapshots/visuals/checkbox_checked.png
new file mode 100644
index 000000000..fd85297ac
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/checkbox_checked.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72175bf108135b422d978b701d29e6d9a5348c536e25abc924234bc11b6b7f21
+size 14016
diff --git a/tests/egui_tests/tests/snapshots/visuals/drag_value.png b/tests/egui_tests/tests/snapshots/visuals/drag_value.png
new file mode 100644
index 000000000..5411009f0
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/drag_value.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:129121534b5f1a2a668898ebb3560820fe50aa4d3546ef46cc764d5513787e9e
+size 7529
diff --git a/tests/egui_tests/tests/snapshots/visuals/radio.png b/tests/egui_tests/tests/snapshots/visuals/radio.png
new file mode 100644
index 000000000..e00b42d8c
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/radio.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9999c7921f8b277f456189ce0f1185120b4cde7c9a01485a5a7d83f12e95527
+size 11710
diff --git a/tests/egui_tests/tests/snapshots/visuals/radio_checked.png b/tests/egui_tests/tests/snapshots/visuals/radio_checked.png
new file mode 100644
index 000000000..0021e7d0a
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/radio_checked.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fec1fd9f80e5fa17b1cda690c0856e7e5fd674d113a10b1d60b14f5a6c6dd6b
+size 12401
diff --git a/tests/egui_tests/tests/snapshots/visuals/selectable_value.png b/tests/egui_tests/tests/snapshots/visuals/selectable_value.png
new file mode 100644
index 000000000..a0b480be4
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/selectable_value.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac18e2eef000a80858b2d0811f9ee31304c6ff96f7a91dc60cc1a404ae28ce38
+size 13246
diff --git a/tests/egui_tests/tests/snapshots/visuals/selectable_value_selected.png b/tests/egui_tests/tests/snapshots/visuals/selectable_value_selected.png
new file mode 100644
index 000000000..291263c44
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/selectable_value_selected.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c11fe0399c85db5a618580ec4c1f2fe76176c6ea0ead3710a430d9a2bf8acc5d
+size 13352
diff --git a/tests/egui_tests/tests/snapshots/visuals/slider.png b/tests/egui_tests/tests/snapshots/visuals/slider.png
new file mode 100644
index 000000000..67b0b365b
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/slider.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a41bf44780feefa108a230ae617830445791bde16d712ac35530350d5d009481
+size 9045
diff --git a/tests/egui_tests/tests/snapshots/visuals/text_edit.png b/tests/egui_tests/tests/snapshots/visuals/text_edit.png
new file mode 100644
index 000000000..d8e56eb2a
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/text_edit.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a103b51df184d5480438e8b537106432205a6d86f2927ab1bd507fe8ed3bb29b
+size 7656
diff --git a/tests/egui_tests/tests/snapshots/visuals/text_edit_clip.png b/tests/egui_tests/tests/snapshots/visuals/text_edit_clip.png
new file mode 100644
index 000000000..f44900fa5
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/text_edit_clip.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf4236b1a8f63d184cd780c334d9f996e4d47817a96a29f0d81658d2d897597f
+size 10529
diff --git a/tests/egui_tests/tests/snapshots/visuals/text_edit_no_clip.png b/tests/egui_tests/tests/snapshots/visuals/text_edit_no_clip.png
new file mode 100644
index 000000000..7329c49cf
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/text_edit_no_clip.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7a63953853f526b83f80d63335b03e60258ea9a3416d19f8ed57d746b5c551d
+size 21557
diff --git a/tests/egui_tests/tests/snapshots/visuals/text_edit_placeholder_clip.png b/tests/egui_tests/tests/snapshots/visuals/text_edit_placeholder_clip.png
new file mode 100644
index 000000000..e1a15cf7d
--- /dev/null
+++ b/tests/egui_tests/tests/snapshots/visuals/text_edit_placeholder_clip.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f7d802a4de7e30f8d254cab6d9ca127866c104c1738103bc4a579917e8f42d3
+size 9850
diff --git a/tests/egui_tests/tests/test_atoms.rs b/tests/egui_tests/tests/test_atoms.rs
new file mode 100644
index 000000000..6f4b694e6
--- /dev/null
+++ b/tests/egui_tests/tests/test_atoms.rs
@@ -0,0 +1,121 @@
+use egui::{Align, AtomExt as _, Button, Layout, TextWrapMode, Ui, Vec2};
+use egui_kittest::{HarnessBuilder, SnapshotResult, SnapshotResults};
+
+#[test]
+fn test_atoms() {
+    let mut results = SnapshotResults::new();
+
+    results.add(single_test("max_width", |ui| {
+        ui.add(Button::new((
+            "max width not grow".atom_max_width(30.0),
+            "other text",
+        )));
+    }));
+    results.add(single_test("max_width_and_grow", |ui| {
+        ui.add(Button::new((
+            "max width and grow".atom_max_width(30.0).atom_grow(true),
+            "other text",
+        )));
+    }));
+    results.add(single_test("shrink_first_text", |ui| {
+        ui.style_mut().wrap_mode = Some(TextWrapMode::Truncate);
+        ui.add(Button::new(("this should shrink", "this shouldn't")));
+    }));
+    results.add(single_test("shrink_last_text", |ui| {
+        ui.style_mut().wrap_mode = Some(TextWrapMode::Truncate);
+        ui.add(Button::new((
+            "this shouldn't shrink",
+            "this should".atom_shrink(true),
+        )));
+    }));
+    results.add(single_test("grow_all", |ui| {
+        ui.style_mut().wrap_mode = Some(TextWrapMode::Truncate);
+        ui.add(Button::new((
+            "I grow".atom_grow(true),
+            "I also grow".atom_grow(true),
+            "I grow as well".atom_grow(true),
+        )));
+    }));
+    results.add(single_test("size_max_size", |ui| {
+        ui.style_mut().wrap_mode = Some(TextWrapMode::Truncate);
+        ui.add(Button::new((
+            "size and max size"
+                .atom_size(Vec2::new(80.0, 80.0))
+                .atom_max_size(Vec2::new(20.0, 20.0)),
+            "other text".atom_grow(true),
+        )));
+    }));
+}
+
+fn single_test(name: &str, mut f: impl FnMut(&mut Ui)) -> SnapshotResult {
+    let mut harness = HarnessBuilder::default()
+        .with_size(Vec2::new(400.0, 200.0))
+        .build_ui(move |ui| {
+            ui.label("Normal");
+            let normal_width = ui.horizontal(&mut f).response.rect.width();
+
+            ui.label("Justified");
+            ui.with_layout(
+                Layout::left_to_right(Align::Min).with_main_justify(true),
+                &mut f,
+            );
+
+            ui.label("Shrunk");
+            ui.scope(|ui| {
+                ui.set_max_width(normal_width / 2.0);
+                f(ui);
+            });
+        });
+
+    harness.try_snapshot(name)
+}
+
+#[test]
+fn test_intrinsic_size() {
+    let widgets = [Ui::button, Ui::label];
+
+    for widget in widgets {
+        let mut intrinsic_size = None;
+        for wrapping in [
+            TextWrapMode::Extend,
+            TextWrapMode::Wrap,
+            TextWrapMode::Truncate,
+        ] {
+            _ = HarnessBuilder::default()
+                .with_size(Vec2::new(100.0, 100.0))
+                .build_ui(|ui| {
+                    ui.style_mut().wrap_mode = Some(wrapping);
+                    let response = widget(
+                        ui,
+                        "Hello world this is a long text that should be wrapped.",
+                    );
+                    if let Some(current_intrinsic_size) = intrinsic_size {
+                        assert_eq!(
+                            Some(current_intrinsic_size),
+                            response.intrinsic_size,
+                            "For wrapping: {wrapping:?}"
+                        );
+                    }
+                    assert!(
+                        response.intrinsic_size.is_some(),
+                        "intrinsic_size should be set for `Button`"
+                    );
+                    intrinsic_size = response.intrinsic_size;
+                    if wrapping == TextWrapMode::Extend {
+                        assert_eq!(Some(response.rect.size()), response.intrinsic_size);
+                    }
+                });
+        }
+    }
+}
+
+#[test]
+fn test_button_shortcut_text() {
+    let mut harness = HarnessBuilder::default().build_ui(|ui| {
+        ui.add(egui::Button::new("Click me").shortcut_text(("1", "2", "3")));
+    });
+    harness.run();
+    harness.fit_contents();
+
+    harness.snapshot("button_shortcut");
+}
diff --git a/tests/egui_tests/tests/test_sides.rs b/tests/egui_tests/tests/test_sides.rs
new file mode 100644
index 000000000..52d35db4c
--- /dev/null
+++ b/tests/egui_tests/tests/test_sides.rs
@@ -0,0 +1,76 @@
+use egui::{TextWrapMode, Vec2, containers::Sides};
+use egui_kittest::{Harness, SnapshotResults};
+
+#[test]
+fn sides_container_tests() {
+    let mut results = SnapshotResults::new();
+
+    test_variants("default", |sides| sides, &mut results);
+
+    test_variants(
+        "shrink_left",
+        |sides| sides.shrink_left().truncate(),
+        &mut results,
+    );
+
+    test_variants(
+        "shrink_right",
+        |sides| sides.shrink_right().truncate(),
+        &mut results,
+    );
+
+    test_variants(
+        "wrap_left",
+        |sides| sides.shrink_left().wrap_mode(TextWrapMode::Wrap),
+        &mut results,
+    );
+
+    test_variants(
+        "wrap_right",
+        |sides| sides.shrink_right().wrap_mode(TextWrapMode::Wrap),
+        &mut results,
+    );
+}
+
+fn test_variants(
+    name: &str,
+    mut create_sides: impl FnMut(Sides) -> Sides,
+    results: &mut SnapshotResults,
+) {
+    for (variant_name, left_text, right_text, fit_contents) in [
+        ("short", "Left", "Right", false),
+        (
+            "long",
+            "Very long left content that should not fit.",
+            "Very long right text that should also not fit.",
+            false,
+        ),
+        ("short_fit_contents", "Left", "Right", true),
+        (
+            "long_fit_contents",
+            "Very long left content that should not fit.",
+            "Very long right text that should also not fit.",
+            true,
+        ),
+    ] {
+        let mut harness = Harness::builder()
+            .with_size(Vec2::new(400.0, 50.0))
+            .build_ui(|ui| {
+                create_sides(Sides::new()).show(
+                    ui,
+                    |left| {
+                        left.label(left_text);
+                    },
+                    |right| {
+                        right.label(right_text);
+                    },
+                );
+            });
+
+        if fit_contents {
+            harness.fit_contents();
+        }
+
+        results.add(harness.try_snapshot(format!("sides/{name}_{variant_name}")));
+    }
+}
diff --git a/tests/egui_tests/tests/test_widgets.rs b/tests/egui_tests/tests/test_widgets.rs
new file mode 100644
index 000000000..440b1939b
--- /dev/null
+++ b/tests/egui_tests/tests/test_widgets.rs
@@ -0,0 +1,419 @@
+use egui::accesskit::Role;
+use egui::load::SizedTexture;
+use egui::{
+    Align, AtomExt as _, AtomLayout, Button, Color32, ColorImage, Direction, DragValue, Event,
+    Grid, IntoAtoms as _, Layout, PointerButton, Response, Slider, Stroke, StrokeKind, TextEdit,
+    TextWrapMode, TextureHandle, TextureOptions, Ui, UiBuilder, Vec2, Widget as _, include_image,
+};
+use egui_kittest::kittest::{Queryable as _, by};
+use egui_kittest::{Harness, Node, SnapshotResult, SnapshotResults};
+
+#[test]
+fn widget_tests() {
+    let mut results = SnapshotResults::new();
+
+    test_widget("button", |ui| ui.button("Button"), &mut results);
+    test_widget(
+        "button_image",
+        |ui| {
+            Button::image_and_text(
+                include_image!("../../../crates/eframe/data/icon.png"),
+                "Button",
+            )
+            .ui(ui)
+        },
+        &mut results,
+    );
+    test_widget(
+        "button_image_shortcut",
+        |ui| {
+            Button::image_and_text(
+                include_image!("../../../crates/eframe/data/icon.png"),
+                "Open",
+            )
+            .shortcut_text("⌘O")
+            .ui(ui)
+        },
+        &mut results,
+    );
+    results.add(VisualTests::test("button_image_shortcut_selected", |ui| {
+        Button::image_and_text(
+            include_image!("../../../crates/eframe/data/icon.png"),
+            "Open",
+        )
+        .shortcut_text("⌘O")
+        .selected(true)
+        .ui(ui)
+    }));
+
+    test_widget(
+        "selectable_value",
+        |ui| ui.selectable_label(false, "Selectable"),
+        &mut results,
+    );
+    test_widget(
+        "selectable_value_selected",
+        |ui| ui.selectable_label(true, "Selectable"),
+        &mut results,
+    );
+
+    test_widget(
+        "checkbox",
+        |ui| ui.checkbox(&mut false, "Checkbox"),
+        &mut results,
+    );
+    test_widget(
+        "checkbox_checked",
+        |ui| ui.checkbox(&mut true, "Checkbox"),
+        &mut results,
+    );
+    test_widget("radio", |ui| ui.radio(false, "Radio"), &mut results);
+    test_widget("radio_checked", |ui| ui.radio(true, "Radio"), &mut results);
+
+    test_widget(
+        "drag_value",
+        |ui| DragValue::new(&mut 12.0).ui(ui),
+        &mut results,
+    );
+
+    test_widget(
+        "text_edit",
+        |ui| {
+            ui.spacing_mut().text_edit_width = 45.0;
+            ui.text_edit_singleline(&mut "Hi!".to_owned())
+        },
+        &mut results,
+    );
+    test_widget(
+        "text_edit_clip",
+        |ui| {
+            ui.spacing_mut().text_edit_width = 45.0;
+            TextEdit::singleline(&mut "This is a very very long text".to_owned())
+                .clip_text(true)
+                .ui(ui)
+        },
+        &mut results,
+    );
+    test_widget(
+        "text_edit_no_clip",
+        |ui| {
+            ui.spacing_mut().text_edit_width = 45.0;
+            TextEdit::singleline(&mut "This is a very very long text".to_owned())
+                .clip_text(false)
+                .ui(ui)
+        },
+        &mut results,
+    );
+    test_widget(
+        "text_edit_placeholder_clip",
+        |ui| {
+            ui.spacing_mut().text_edit_width = 45.0;
+            TextEdit::singleline(&mut String::new())
+                .hint_text("This is a very very long placeholder")
+                .clip_text(true)
+                .ui(ui)
+        },
+        &mut results,
+    );
+
+    test_widget(
+        "slider",
+        |ui| {
+            ui.spacing_mut().slider_width = 45.0;
+            Slider::new(&mut 12.0, 0.0..=100.0).ui(ui)
+        },
+        &mut results,
+    );
+
+    let source = include_image!("../../../crates/eframe/data/icon.png");
+    let interesting_atoms = vec![
+        ("minimal", ("Hello World!").into_atoms()),
+        (
+            "image",
+            (source.clone().atom_max_height(12.0), "With Image").into_atoms(),
+        ),
+        (
+            "multi_grow",
+            ("g".atom_grow(true), "2", "g".atom_grow(true), "4").into_atoms(),
+        ),
+    ];
+
+    for atoms in interesting_atoms {
+        results.add(test_widget_layout(&format!("atoms_{}", atoms.0), |ui| {
+            AtomLayout::new(atoms.1.clone()).ui(ui)
+        }));
+    }
+}
+
+fn test_widget(name: &str, mut w: impl FnMut(&mut Ui) -> Response, results: &mut SnapshotResults) {
+    results.add(test_widget_layout(name, &mut w));
+    results.add(VisualTests::test(name, &mut w));
+}
+
+fn test_widget_layout(name: &str, mut w: impl FnMut(&mut Ui) -> Response) -> SnapshotResult {
+    let test_size = Vec2::new(110.0, 45.0);
+
+    struct Row {
+        main_dir: Direction,
+        main_align: Align,
+        main_justify: bool,
+    }
+
+    struct Col {
+        cross_align: Align,
+        cross_justify: bool,
+    }
+
+    let mut rows = Vec::new();
+    let mut cols = Vec::new();
+
+    for main_justify in [false, true] {
+        for main_dir in [
+            Direction::LeftToRight,
+            Direction::TopDown,
+            Direction::RightToLeft,
+            Direction::BottomUp,
+        ] {
+            for main_align in [Align::Min, Align::Center, Align::Max] {
+                rows.push(Row {
+                    main_dir,
+                    main_align,
+                    main_justify,
+                });
+            }
+        }
+    }
+
+    for cross_justify in [false, true] {
+        for cross_align in [Align::Min, Align::Center, Align::Max] {
+            cols.push(Col {
+                cross_align,
+                cross_justify,
+            });
+        }
+    }
+
+    let mut harness = Harness::builder().build_ui(|ui| {
+        egui_extras::install_image_loaders(ui.ctx());
+
+        {
+            let mut wrap_test_size = test_size;
+            wrap_test_size.x /= 3.0;
+            ui.heading("Wrapping");
+
+            let modes = [
+                TextWrapMode::Extend,
+                TextWrapMode::Truncate,
+                TextWrapMode::Wrap,
+            ];
+            Grid::new("wrapping")
+                .spacing(Vec2::new(test_size.x / 2.0, 4.0))
+                .show(ui, |ui| {
+                    for mode in &modes {
+                        ui.label(format!("{mode:?}"));
+                    }
+                    ui.end_row();
+
+                    for mode in &modes {
+                        let (_, rect) = ui.allocate_space(wrap_test_size);
+
+                        let mut child_ui = ui.new_child(UiBuilder::new().max_rect(rect));
+                        child_ui.style_mut().wrap_mode = Some(*mode);
+                        w(&mut child_ui);
+
+                        ui.painter().rect_stroke(
+                            rect,
+                            0.0,
+                            Stroke::new(1.0, Color32::WHITE),
+                            StrokeKind::Outside,
+                        );
+                    }
+                });
+        }
+
+        ui.heading("Layout");
+        Grid::new("layout").striped(true).show(ui, |ui| {
+            ui.label("");
+            for col in &cols {
+                ui.label(format!(
+                    "cross_align: {:?}\ncross_justify:{:?}",
+                    col.cross_align, col.cross_justify
+                ));
+            }
+            ui.end_row();
+
+            for row in &rows {
+                ui.label(format!(
+                    "main_dir: {:?}\nmain_align: {:?}\nmain_justify: {:?}",
+                    row.main_dir, row.main_align, row.main_justify
+                ));
+                for col in &cols {
+                    let layout = Layout {
+                        main_dir: row.main_dir,
+                        main_align: row.main_align,
+                        main_justify: row.main_justify,
+                        cross_align: col.cross_align,
+                        cross_justify: col.cross_justify,
+                        main_wrap: false,
+                    };
+
+                    let (_, rect) = ui.allocate_space(test_size);
+
+                    let mut child_ui = ui.new_child(UiBuilder::new().layout(layout).max_rect(rect));
+                    w(&mut child_ui);
+
+                    ui.painter().rect_stroke(
+                        rect,
+                        0.0,
+                        Stroke::new(1.0, Color32::WHITE),
+                        StrokeKind::Outside,
+                    );
+                }
+
+                ui.end_row();
+            }
+        });
+    });
+
+    harness.fit_contents();
+    harness.try_snapshot(format!("layout/{name}"))
+}
+
+/// Utility to create a snapshot test of the different states of a egui widget.
+/// This renders each state to a texture to work around the fact only a single widget can be
+/// hovered / pressed / focused at a time.
+struct VisualTests<'a> {
+    name: String,
+    w: &'a mut dyn FnMut(&mut Ui) -> Response,
+    results: Vec<(String, ColorImage)>,
+}
+
+impl<'a> VisualTests<'a> {
+    pub fn test(name: &str, mut w: impl FnMut(&mut Ui) -> Response) -> SnapshotResult {
+        let mut vis = VisualTests::new(name, &mut w);
+        vis.add_default_states();
+        vis.render()
+    }
+
+    pub fn new(name: &str, w: &'a mut dyn FnMut(&mut Ui) -> Response) -> Self {
+        Self {
+            name: name.to_owned(),
+            w,
+            results: Vec::new(),
+        }
+    }
+
+    fn add_default_states(&mut self) {
+        self.add("idle", |_| {});
+        self.add_node("hover", |node| {
+            node.hover();
+        });
+        self.add("pressed", |harness| {
+            harness.get_next_widget().hover();
+            let rect = harness.get_next_widget().rect();
+            harness.input_mut().events.push(Event::PointerButton {
+                button: PointerButton::Primary,
+                pos: rect.center(),
+                pressed: true,
+                modifiers: Default::default(),
+            });
+        });
+        self.add_node("focussed", |node| {
+            node.focus();
+        });
+        self.add_disabled();
+    }
+
+    fn single_test(&mut self, f: impl FnOnce(&mut Harness<'_>), enabled: bool) -> ColorImage {
+        let mut harness = Harness::builder().with_step_dt(0.05).build_ui(|ui| {
+            egui_extras::install_image_loaders(ui.ctx());
+            ui.add_enabled_ui(enabled, |ui| {
+                (self.w)(ui);
+            });
+        });
+
+        harness.fit_contents();
+
+        // Wait for images to load
+        harness.try_run_realtime().ok();
+
+        f(&mut harness);
+
+        harness.step();
+
+        let image = harness.render().expect("Failed to render harness");
+
+        ColorImage::from_rgba_unmultiplied(
+            [image.width() as usize, image.height() as usize],
+            image.as_ref(),
+        )
+    }
+
+    pub fn add(&mut self, name: &str, test: impl FnOnce(&mut Harness<'_>)) {
+        let image = self.single_test(test, true);
+        self.results.push((name.to_owned(), image));
+    }
+
+    pub fn add_disabled(&mut self) {
+        let image = self.single_test(|_| {}, false);
+        self.results.push(("disabled".to_owned(), image));
+    }
+
+    pub fn add_node(&mut self, name: &str, test: impl FnOnce(&Node<'_>)) {
+        self.add(name, |harness| {
+            let node = harness.get_next_widget();
+            test(&node);
+        });
+    }
+
+    pub fn render(self) -> SnapshotResult {
+        let mut results = Some(self.results);
+        let mut images: Option<Vec<(String, TextureHandle, SizedTexture)>> = None;
+
+        let mut harness = Harness::new_ui(|ui| {
+            let results = images.get_or_insert_with(|| {
+                results
+                    .take()
+                    .unwrap()
+                    .into_iter()
+                    .map(|(name, image)| {
+                        let size = Vec2::new(image.width() as f32, image.height() as f32);
+                        let texture_handle =
+                            ui.ctx()
+                                .load_texture(name.clone(), image, TextureOptions::default());
+                        let texture = SizedTexture::new(texture_handle.id(), size);
+                        (name.clone(), texture_handle, texture)
+                    })
+                    .collect()
+            });
+
+            Grid::new("results").show(ui, |ui| {
+                for (name, _, image) in results {
+                    ui.label(&*name);
+
+                    ui.scope(|ui| {
+                        ui.image(*image);
+                    });
+
+                    ui.end_row();
+                }
+            });
+        });
+
+        harness.fit_contents();
+
+        harness.try_snapshot(format!("visuals/{}", self.name))
+    }
+}
+
+trait HarnessExt {
+    fn get_next_widget(&self) -> Node<'_>;
+}
+
+impl HarnessExt for Harness<'_> {
+    fn get_next_widget(&self) -> Node<'_> {
+        self.get_all(by().predicate(|node| node.role() != Role::GenericContainer))
+            .next()
+            .unwrap()
+    }
+}
diff --git a/tests/test_egui_extras_compilation/Cargo.toml b/tests/test_egui_extras_compilation/Cargo.toml
index 9f1aeca52..1e812f1e4 100644
--- a/tests/test_egui_extras_compilation/Cargo.toml
+++ b/tests/test_egui_extras_compilation/Cargo.toml
@@ -2,19 +2,16 @@
 name = "test_egui_extras_compilation"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
 workspace = true
 
 [package.metadata.cargo-machete]
-ignored = [
-    "eframe",
-    "egui_extras",
-] # We don't use them, just check that things compile
+ignored = ["eframe", "egui_extras"] # We don't use them, just check that things compile
 
 [dependencies]
 eframe = { workspace = true, features = ["default", "persistence"] }
-egui_extras = { workspace = true }
+egui_extras.workspace = true
diff --git a/tests/test_inline_glow_paint/Cargo.toml b/tests/test_inline_glow_paint/Cargo.toml
index 15cb21640..6a72df652 100644
--- a/tests/test_inline_glow_paint/Cargo.toml
+++ b/tests/test_inline_glow_paint/Cargo.toml
@@ -3,8 +3,8 @@ name = "test_inline_glow_paint"
 version = "0.1.0"
 authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -14,10 +14,7 @@ workspace = true
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/tests/test_inline_glow_paint/src/main.rs b/tests/test_inline_glow_paint/src/main.rs
index 125696526..3245af348 100644
--- a/tests/test_inline_glow_paint/src/main.rs
+++ b/tests/test_inline_glow_paint/src/main.rs
@@ -29,7 +29,7 @@ impl eframe::App for MyTestApp {
         use glow::HasContext as _;
         let gl = frame.gl().unwrap();
 
-        #[allow(unsafe_code)]
+        #[expect(unsafe_code)]
         unsafe {
             gl.disable(glow::SCISSOR_TEST);
             gl.viewport(0, 0, 100, 100);
diff --git a/tests/test_size_pass/Cargo.toml b/tests/test_size_pass/Cargo.toml
index a44f2cc0b..a9cd1494c 100644
--- a/tests/test_size_pass/Cargo.toml
+++ b/tests/test_size_pass/Cargo.toml
@@ -3,8 +3,8 @@ name = "test_size_pass"
 version = "0.1.0"
 authors = ["Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -15,10 +15,7 @@ wgpu = ["eframe/wgpu"]
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/tests/test_ui_stack/Cargo.toml b/tests/test_ui_stack/Cargo.toml
index dd8bdb5de..c0e5ffbd2 100644
--- a/tests/test_ui_stack/Cargo.toml
+++ b/tests/test_ui_stack/Cargo.toml
@@ -3,8 +3,8 @@ name = "test_ui_stack"
 version = "0.1.0"
 authors = ["Antoine Beyeler <abeyeler@gmail.com>"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -21,7 +21,4 @@ eframe = { workspace = true, features = [
 # For image support:
 egui_extras = { workspace = true, features = ["default", "image", "serde"] }
 
-env_logger = { version = "0.10", default-features = false, features = [
-  "auto-color",
-  "humantime",
-] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/tests/test_viewports/Cargo.toml b/tests/test_viewports/Cargo.toml
index 2636b5177..ae396709d 100644
--- a/tests/test_viewports/Cargo.toml
+++ b/tests/test_viewports/Cargo.toml
@@ -3,8 +3,8 @@ name = "test_viewports"
 version = "0.1.0"
 authors = ["konkitoman"]
 license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 publish = false
 
 [lints]
@@ -15,10 +15,7 @@ wgpu = ["eframe/wgpu"]
 
 [dependencies]
 eframe = { workspace = true, features = [
-    "default",
-    "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
-] }
-env_logger = { version = "0.10", default-features = false, features = [
-    "auto-color",
-    "humantime",
+  "default",
+  "__screenshot", # __screenshot is so we can dump a screenshot using EFRAME_SCREENSHOT_TO
 ] }
+env_logger = { workspace = true, features = ["auto-color", "humantime"] }
diff --git a/tests/test_viewports/src/main.rs b/tests/test_viewports/src/main.rs
index 3f9964c94..ab31a4ece 100644
--- a/tests/test_viewports/src/main.rs
+++ b/tests/test_viewports/src/main.rs
@@ -4,7 +4,7 @@
 use std::sync::Arc;
 
 use eframe::egui;
-use egui::{mutex::RwLock, Id, InnerResponse, UiBuilder, ViewportBuilder, ViewportId};
+use egui::{Id, InnerResponse, UiBuilder, ViewportBuilder, ViewportId, mutex::RwLock};
 
 // Drag-and-drop between windows is not yet implemented, but if you wanna work on it, enable this:
 pub const DRAG_AND_DROP_TEST: bool = false;
@@ -247,8 +247,12 @@ fn generic_ui(ui: &mut egui::Ui, children: &[Arc<RwLock<ViewportState>>], close_
         if let Some(monitor_size) = ctx.input(|i| i.viewport().monitor_size) {
             ui.label(format!("monitor_size: {monitor_size:?} (points)"));
         }
-        if let Some(screen_rect) = ui.input(|i| i.raw.screen_rect) {
-            ui.label(format!("Screen rect size: Pos: {:?}", screen_rect.size()));
+        if let Some(viewport_rect) = ui.input(|i| i.raw.screen_rect) {
+            ui.label(format!(
+                "Viewport Rect: Pos: {:?}, Size: {:?} (points)",
+                viewport_rect.min,
+                viewport_rect.size()
+            ));
         }
         if let Some(inner_rect) = ctx.input(|i| i.viewport().inner_rect) {
             ui.label(format!(
@@ -367,6 +371,7 @@ fn drag_and_drop_test(ui: &mut egui::Ui) {
             assert!(col <= COLS, "The col should be less then: {COLS}");
 
             // Should be a better way to do this!
+            #[expect(clippy::iter_over_hash_type)]
             for container_data in self.containers_data.values_mut() {
                 for ids in container_data {
                     ids.retain(|i| *i != id);
diff --git a/web_demo/README.md b/web_demo/README.md
index 62ac7a0fe..553fa871a 100644
--- a/web_demo/README.md
+++ b/web_demo/README.md
@@ -6,4 +6,4 @@ This folder contains the files required for the egui web demo hosted at <https:/
 * Open <http://localhost:8765/index.html>
 
 ## Deploying egui.rs
-Each merge into `master` will trigger a new deploy
+Each merge into `main` will trigger a new deploy
diff --git a/xtask/src/utils.rs b/xtask/src/utils.rs
index afefa6054..b45295aea 100644
--- a/xtask/src/utils.rs
+++ b/xtask/src/utils.rs
@@ -32,7 +32,7 @@ pub fn ask_to_run(mut cmd: Command, ask: bool, reason: &str) -> Result<(), DynEr
             "" | "y" | "yes" => {}
             "n" | "no" => return Err("Aborting as per your request".into()),
             a => return Err(format!("Invalid answer `{a}`").into()),
-        };
+        }
     } else {
         println!("Running `{cmd:?}` to {reason}.");
     }