diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 8aaa18faa36..44cabf9a8cd 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -108,7 +108,7 @@ jobs:
       - name: wasm-bindgen
         uses: jetli/wasm-bindgen-action@v0.1.0
         with:
-          version: "0.2.92"
+          version: "0.2.90"
 
       - run: ./scripts/wasm_bindgen_check.sh --skip-setup
 
diff --git a/Cargo.lock b/Cargo.lock
index b3722fdddec..c536538b39f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -144,7 +144,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "052ad56e336bcc615a214bffbeca6c181ee9550acec193f0327e0b103b033a4d"
 dependencies = [
  "android-properties",
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "cc",
  "cesu8",
  "jni",
@@ -510,9 +510,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
 dependencies = [
  "serde",
 ]
@@ -649,7 +649,7 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b50b5a44d59a98c55a9eeb518f39bf7499ba19fd98ee7d22618687f3f10adbf"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "log",
  "polling 3.3.0",
  "rustix 0.38.21",
@@ -879,9 +879,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation"
-version = "0.9.4"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -889,9 +889,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
 
 [[package]]
 name = "core-graphics"
@@ -908,9 +908,9 @@ dependencies = [
 
 [[package]]
 name = "core-graphics-types"
-version = "0.1.3"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
+checksum = "2bb142d41022986c1d8ff29103a1411c8a3dfad3552f87a4f8dc50d61d4f4e33"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation",
@@ -1172,6 +1172,7 @@ dependencies = [
 name = "eframe"
 version = "0.27.2"
 dependencies = [
+ "ahash",
  "bytemuck",
  "directories-next",
  "document-features",
@@ -1227,6 +1228,7 @@ dependencies = [
 name = "egui-wgpu"
 version = "0.27.2"
 dependencies = [
+ "ahash",
  "bytemuck",
  "document-features",
  "egui",
@@ -1245,6 +1247,7 @@ name = "egui-winit"
 version = "0.27.2"
 dependencies = [
  "accesskit_winit",
+ "ahash",
  "arboard",
  "document-features",
  "egui",
@@ -1302,6 +1305,7 @@ dependencies = [
 name = "egui_extras"
 version = "0.27.2"
 dependencies = [
+ "ahash",
  "chrono",
  "document-features",
  "egui",
@@ -1320,6 +1324,7 @@ dependencies = [
 name = "egui_glow"
 version = "0.27.2"
 dependencies = [
+ "ahash",
  "bytemuck",
  "document-features",
  "egui",
@@ -1340,6 +1345,7 @@ dependencies = [
 name = "egui_plot"
 version = "0.27.2"
 dependencies = [
+ "ahash",
  "document-features",
  "egui",
  "serde",
@@ -1785,7 +1791,7 @@ version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "005459a22af86adc706522d78d360101118e2638ec21df3852fcc626e0dbb212"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "cfg_aliases",
  "cgl",
  "core-foundation",
@@ -1861,7 +1867,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "gpu-alloc-types",
 ]
 
@@ -1871,7 +1877,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
 ]
 
 [[package]]
@@ -1889,22 +1895,22 @@ dependencies = [
 
 [[package]]
 name = "gpu-descriptor"
-version = "0.3.0"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c08c1f623a8d0b722b8b99f821eb0ba672a1618f0d3b16ddbee1cedd2dd8557"
+checksum = "cc11df1ace8e7e564511f53af41f3e42ddc95b56fd07b3f4445d2a6048bc682c"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "gpu-descriptor-types",
  "hashbrown",
 ]
 
 [[package]]
 name = "gpu-descriptor-types"
-version = "0.2.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"
+checksum = "6bf0b36e6f090b7e1d8a4b49c0cb81c1f8376f72198c65dd3ad9ff3556b8b78c"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
 ]
 
 [[package]]
@@ -1947,7 +1953,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af2a7e73e1f34c48da31fb668a907f250794837e08faa144fd24f0b8b741e890"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "com",
  "libc",
  "libloading 0.8.0",
@@ -2183,9 +2189,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "9a1d36f1235bc969acba30b7f5990b864423a6068a10f7c90ae8f0112e3a59d1"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -2346,11 +2352,11 @@ dependencies = [
 
 [[package]]
 name = "metal"
-version = "0.28.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5637e166ea14be6063a3f8ba5ccb9a4159df7d8f6d61c02fc3d480b1f90dcfcb"
+checksum = "c43f73953f8cbe511f021b58f18c3ce1c3d1ae13fe953293e13345bf83217f25"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "block",
  "core-graphics-types",
  "foreign-types",
@@ -2407,13 +2413,12 @@ dependencies = [
 
 [[package]]
 name = "naga"
-version = "0.20.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e536ae46fcab0876853bd4a632ede5df4b1c2527a58f6c5a4150fe86be858231"
+checksum = "8878eb410fc90853da3908aebfe61d73d26d4437ef850b70050461f939509899"
 dependencies = [
- "arrayvec",
  "bit-set",
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "codespan-reporting",
  "hexf-parse",
  "indexmap",
@@ -2432,7 +2437,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "jni-sys",
  "log",
  "ndk-sys",
@@ -2522,6 +2527,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
 dependencies = [
  "malloc_buf",
+ "objc_exception",
 ]
 
 [[package]]
@@ -2632,6 +2638,15 @@ dependencies = [
  "objc2 0.5.1",
 ]
 
+[[package]]
+name = "objc_exception"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "objc_id"
 version = "0.1.1"
@@ -3088,9 +3103,9 @@ checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
 
 [[package]]
 name = "renderdoc-sys"
-version = "1.1.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
+checksum = "216080ab382b992234dda86873c18d4c48358f5cfcb70fd693d7f6f2131b628b"
 
 [[package]]
 name = "resvg"
@@ -3160,7 +3175,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
 dependencies = [
  "base64",
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "serde",
  "serde_derive",
 ]
@@ -3203,7 +3218,7 @@ version = "0.38.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "errno",
  "libc",
  "linux-raw-sys 0.4.11",
@@ -3432,7 +3447,7 @@ version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60e3d9941fa3bacf7c2bf4b065304faa14164151254cd16ce1b1bc8fc381600f"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "calloop",
  "calloop-wayland-source",
  "cursor-icon",
@@ -3493,7 +3508,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.5.0",
+ "bitflags 2.4.0",
 ]
 
 [[package]]
@@ -3613,6 +3628,14 @@ dependencies = [
  "env_logger",
 ]
 
+[[package]]
+name = "test_size_pass"
+version = "0.1.0"
+dependencies = [
+ "eframe",
+ "env_logger",
+]
+
 [[package]]
 name = "test_viewports"
 version = "0.1.0"
@@ -3623,18 +3646,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.59"
+version = "1.0.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0126ad08bff79f29fc3ae6a55cc72352056dfff61e3ff8bb7129476d44b23aa"
+checksum = "d54378c645627613241d077a3a79db965db602882668f9136ac42af9ecb730ad"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.59"
+version = "1.0.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1cd413b5d558b4c5bf3680e324a6fa5014e7b7c067a51e69dbdf47eb7148b66"
+checksum = "fa0faa943b50f3db30a20aa7e265dbc66076993efed8463e8de414e5d06d3471"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3993,9 +4016,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "b1223296a201415c7fad14792dbefaace9bd52b62d33453ade1c5b5f07555406"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -4003,9 +4026,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "fcdc935b63408d58a32f8cc9738a0bffd8f05cc7c002086c6ef20b7312ad9dcd"
 dependencies = [
  "bumpalo",
  "log",
@@ -4018,9 +4041,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.42"
+version = "0.4.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+checksum = "bde2032aeb86bdfaecc8b261eef3cba735cc426c1f3a3416d1e0791be95fc461"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -4030,9 +4053,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "3e4c238561b2d428924c49815533a8b9121c664599558a5d9ec51f8a1740a999"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4040,9 +4063,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4053,9 +4076,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "4d91413b1c31d7539ba5ef2451af3f0b833a005eb27a631cec32bc0635a8602b"
 
 [[package]]
 name = "wayland-backend"
@@ -4077,7 +4100,7 @@ version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ca7d52347346f5473bf2f56705f360e8440873052e575e55890c4fa57843ed3"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "nix",
  "wayland-backend",
  "wayland-scanner",
@@ -4089,7 +4112,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "cursor-icon",
  "wayland-backend",
 ]
@@ -4111,7 +4134,7 @@ version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e253d7107ba913923dc253967f35e8561a3c65f914543e46843c88ddd729e21c"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "wayland-backend",
  "wayland-client",
  "wayland-scanner",
@@ -4123,7 +4146,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23803551115ff9ea9bce586860c5c5a971e360825a0309264102a9495a5ff479"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "wayland-backend",
  "wayland-client",
  "wayland-protocols",
@@ -4136,7 +4159,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ad1f61b76b6c2d8742e10f9ba5c3737f6530b4c243132c2a2ccc8aa96fe25cd6"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "wayland-backend",
  "wayland-client",
  "wayland-protocols",
@@ -4168,9 +4191,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.69"
+version = "0.3.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+checksum = "58cd2333b6e0be7a39605f0e255892fd7418a682d8da8fe042fe25128794d2ed"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4212,14 +4235,13 @@ checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
 
 [[package]]
 name = "wgpu"
-version = "0.20.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32ff1bfee408e1028e2e3acbf6d32d98b08a5a059ccbf5f33305534453ba5d3e"
+checksum = "0bfe9a310dcf2e6b85f00c46059aaeaf4184caa8e29a1ecd4b7a704c3482332d"
 dependencies = [
  "arrayvec",
  "cfg-if",
  "cfg_aliases",
- "document-features",
  "js-sys",
  "log",
  "naga",
@@ -4238,16 +4260,15 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core"
-version = "0.20.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac6a86eaa5e763e59c73cf9e97d55fffd4dfda69fd8bda19589fcf851ddfef1f"
+checksum = "6b15e451d4060ada0d99a64df44e4d590213496da7c4f245572d51071e8e30ed"
 dependencies = [
  "arrayvec",
  "bit-vec",
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "cfg_aliases",
  "codespan-reporting",
- "document-features",
  "indexmap",
  "log",
  "naga",
@@ -4265,14 +4286,14 @@ dependencies = [
 
 [[package]]
 name = "wgpu-hal"
-version = "0.20.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d71c8ae05170583049b65ee562fd839fdc0b3e9ddb84f4e40c9d5f8ea0d4c8c"
+checksum = "11f259ceb56727fb097da108d92f8a5cbdb5b74a77f9e396bd43626f67299d61"
 dependencies = [
  "android_system_properties",
  "arrayvec",
  "ash",
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "block",
  "cfg_aliases",
  "core-graphics-types",
@@ -4289,7 +4310,6 @@ dependencies = [
  "log",
  "metal",
  "naga",
- "ndk-sys",
  "objc",
  "once_cell",
  "parking_lot",
@@ -4307,11 +4327,11 @@ dependencies = [
 
 [[package]]
 name = "wgpu-types"
-version = "0.20.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1353d9a46bff7f955a680577f34c69122628cc2076e1d6f3a9be6ef00ae793ef"
+checksum = "895fcbeb772bfb049eb80b2d6e47f6c9af235284e9703c96fc0218a42ffd5af2"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "js-sys",
  "web-sys",
 ]
@@ -4619,7 +4639,7 @@ dependencies = [
  "ahash",
  "android-activity",
  "atomic-waker",
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "bytemuck",
  "calloop",
  "cfg_aliases",
@@ -4725,7 +4745,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6924668544c48c0133152e7eec86d644a056ca3d09275eb8d5cdb9855f9d8699"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.4.0",
  "dlib",
  "log",
  "once_cell",
diff --git a/Cargo.toml b/Cargo.toml
index a42033c0efb..07e83a4e9c6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,7 @@ members = [
     "crates/epaint",
 
     "examples/*",
+    "tests/*",
 
     "xtask",
 ]
@@ -87,7 +88,7 @@ web-time = "0.2" # Timekeeping for native and web
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 web-sys = "0.3.58"
-wgpu = { version = "0.20.0", default-features = false, features = [
+wgpu = { version = "0.19.1", default-features = false, features = [
     # Make the renderer `Sync` even on wasm32, because it makes the code simpler:
     "fragile-send-sync-non-atomic-wasm",
 ] }
diff --git a/crates/eframe/Cargo.toml b/crates/eframe/Cargo.toml
index f992c5c66a2..acd7600f6e6 100644
--- a/crates/eframe/Cargo.toml
+++ b/crates/eframe/Cargo.toml
@@ -129,6 +129,7 @@ egui = { workspace = true, default-features = false, features = [
   "log",
 ] }
 
+ahash.workspace = true
 document-features.workspace = true
 log.workspace = true
 parking_lot.workspace = true
@@ -236,7 +237,14 @@ web-sys = { workspace = true, features = [
   "MediaQueryListEvent",
   "MouseEvent",
   "Navigator",
+  "Node",
+  "NodeList",
   "Performance",
+  "ResizeObserver",
+  "ResizeObserverEntry",
+  "ResizeObserverBoxOptions",
+  "ResizeObserverOptions",
+  "ResizeObserverSize",
   "Storage",
   "Touch",
   "TouchEvent",
diff --git a/crates/eframe/src/epi.rs b/crates/eframe/src/epi.rs
index db39a08b15b..ac6585c3d18 100644
--- a/crates/eframe/src/epi.rs
+++ b/crates/eframe/src/epi.rs
@@ -41,10 +41,12 @@ pub type EventLoopBuilderHook = Box<dyn FnOnce(&mut EventLoopBuilder<UserEvent>)
 #[cfg(any(feature = "glow", feature = "wgpu"))]
 pub type WindowBuilderHook = Box<dyn FnOnce(egui::ViewportBuilder) -> egui::ViewportBuilder>;
 
+type DynError = Box<dyn std::error::Error + Send + Sync>;
+
 /// This is how your app is created.
 ///
 /// You can use the [`CreationContext`] to setup egui, restore state, setup OpenGL things, etc.
-pub type AppCreator = Box<dyn FnOnce(&CreationContext<'_>) -> Box<dyn App>>;
+pub type AppCreator = Box<dyn FnOnce(&CreationContext<'_>) -> Result<Box<dyn App>, DynError>>;
 
 /// Data that is passed to [`AppCreator`] that can be used to setup and initialize your app.
 pub struct CreationContext<'s> {
@@ -150,6 +152,7 @@ pub trait App {
     /// On web the state is stored to "Local Storage".
     ///
     /// On native the path is picked using [`crate::storage_dir`].
+    /// The path can be customized via [`NativeOptions::persistence_path`].
     fn save(&mut self, _storage: &mut dyn Storage) {}
 
     /// Called once on shutdown, after [`Self::save`].
@@ -362,6 +365,10 @@ pub struct NativeOptions {
     /// Controls whether or not the native window position and size will be
     /// persisted (only if the "persistence" feature is enabled).
     pub persist_window: bool,
+
+    /// The folder where `eframe` will store the app state. If not set, eframe will get the paths
+    /// from [directories_next].
+    pub persistence_path: Option<std::path::PathBuf>,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -379,6 +386,8 @@ impl Clone for NativeOptions {
             #[cfg(feature = "wgpu")]
             wgpu_options: self.wgpu_options.clone(),
 
+            persistence_path: self.persistence_path.clone(),
+
             ..*self
         }
     }
@@ -418,6 +427,8 @@ impl Default for NativeOptions {
             wgpu_options: egui_wgpu::WgpuConfiguration::default(),
 
             persist_window: true,
+
+            persistence_path: None,
         }
     }
 }
@@ -455,11 +466,6 @@ pub struct WebOptions {
     /// Configures wgpu instance/device/adapter/surface creation and renderloop.
     #[cfg(feature = "wgpu")]
     pub wgpu_options: egui_wgpu::WgpuConfiguration,
-
-    /// The size limit of the web app canvas.
-    ///
-    /// By default the max size is [`egui::Vec2::INFINITY`], i.e. unlimited.
-    pub max_size_points: egui::Vec2,
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -475,8 +481,6 @@ impl Default for WebOptions {
 
             #[cfg(feature = "wgpu")]
             wgpu_options: egui_wgpu::WgpuConfiguration::default(),
-
-            max_size_points: egui::Vec2::INFINITY,
         }
     }
 }
diff --git a/crates/eframe/src/lib.rs b/crates/eframe/src/lib.rs
index e1df19a8b0b..9f9f3a4c807 100644
--- a/crates/eframe/src/lib.rs
+++ b/crates/eframe/src/lib.rs
@@ -30,7 +30,7 @@
 //!
 //! fn main() {
 //!     let native_options = eframe::NativeOptions::default();
-//!     eframe::run_native("My egui App", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))));
+//!     eframe::run_native("My egui App", native_options, Box::new(|cc| Ok(Box::new(MyEguiApp::new(cc)))));
 //! }
 //!
 //! #[derive(Default)]
@@ -90,7 +90,7 @@
 //!             .start(
 //!                 canvas_id,
 //!                 eframe::WebOptions::default(),
-//!                 Box::new(|cc| Box::new(MyEguiApp::new(cc))),
+//!                 Box::new(|cc| Ok(Box::new(MyEguiApp::new(cc))),)
 //!             )
 //!             .await
 //!     }
@@ -199,7 +199,7 @@ pub mod icon_data;
 ///
 /// fn main() -> eframe::Result<()> {
 ///     let native_options = eframe::NativeOptions::default();
-///     eframe::run_native("MyApp", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))))
+///     eframe::run_native("MyApp", native_options, Box::new(|cc| Ok(Box::new(MyEguiApp::new(cc)))))
 /// }
 ///
 /// #[derive(Default)]
@@ -324,7 +324,7 @@ pub fn run_simple_native(
     run_native(
         app_name,
         native_options,
-        Box::new(|_cc| Box::new(SimpleApp { update_fun })),
+        Box::new(|_cc| Ok(Box::new(SimpleApp { update_fun }))),
     )
 }
 
@@ -333,6 +333,9 @@ pub fn run_simple_native(
 /// The different problems that can occur when trying to run `eframe`.
 #[derive(Debug)]
 pub enum Error {
+    /// Something went wrong in user code when creating the app.
+    AppCreation(Box<dyn std::error::Error + Send + Sync>),
+
     /// An error from [`winit`].
     #[cfg(not(target_arch = "wasm32"))]
     Winit(winit::error::OsError),
@@ -403,6 +406,8 @@ impl From<egui_wgpu::WgpuError> for Error {
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Self::AppCreation(err) => write!(f, "app creation error: {err}"),
+
             #[cfg(not(target_arch = "wasm32"))]
             Self::Winit(err) => {
                 write!(f, "winit error: {err}")
diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
index 827b9ec249c..46ad66817ae 100644
--- a/crates/eframe/src/native/epi_integration.rs
+++ b/crates/eframe/src/native/epi_integration.rs
@@ -1,6 +1,8 @@
 //! Common tools used by [`super::glow_integration`] and [`super::wgpu_integration`].
 
 use web_time::Instant;
+
+use std::path::PathBuf;
 use winit::event_loop::EventLoopWindowTarget;
 
 use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
@@ -132,6 +134,16 @@ pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
     None
 }
 
+#[allow(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(
+        super::file_storage::FileStorage::from_ron_filepath(_file),
+    ));
+    #[cfg(not(feature = "persistence"))]
+    None
+}
+
 // ----------------------------------------------------------------------------
 
 /// Everything needed to make a winit-based integration for [`epi`].
diff --git a/crates/eframe/src/native/file_storage.rs b/crates/eframe/src/native/file_storage.rs
index 51c668abdeb..970c35a4f41 100644
--- a/crates/eframe/src/native/file_storage.rs
+++ b/crates/eframe/src/native/file_storage.rs
@@ -41,7 +41,7 @@ impl Drop for FileStorage {
 
 impl FileStorage {
     /// Store the state in this .ron file.
-    fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
+    pub(crate) fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
         crate::profile_function!();
         let ron_filepath: PathBuf = ron_filepath.into();
         log::debug!("Loading app state from {:?}…", ron_filepath);
diff --git a/crates/eframe/src/native/glow_integration.rs b/crates/eframe/src/native/glow_integration.rs
index 0fbb48a09c7..bfdee21d8d9 100644
--- a/crates/eframe/src/native/glow_integration.rs
+++ b/crates/eframe/src/native/glow_integration.rs
@@ -26,10 +26,10 @@ use winit::{
     window::{Window, WindowId},
 };
 
+use ahash::{HashMap, HashSet};
 use egui::{
-    ahash::HashSet, epaint::ahash::HashMap, DeferredViewportUiCallback, ImmediateViewport,
-    ViewportBuilder, ViewportClass, ViewportId, ViewportIdMap, ViewportIdPair, ViewportInfo,
-    ViewportOutput,
+    DeferredViewportUiCallback, ImmediateViewport, ViewportBuilder, ViewportClass, ViewportId,
+    ViewportIdMap, ViewportIdPair, ViewportInfo, ViewportOutput,
 };
 #[cfg(feature = "accesskit")]
 use egui_winit::accesskit_winit;
@@ -195,13 +195,17 @@ impl GlowWinitApp {
     ) -> Result<&mut GlowWinitRunning> {
         crate::profile_function!();
 
-        let storage = epi_integration::create_storage(
-            self.native_options
-                .viewport
-                .app_id
-                .as_ref()
-                .unwrap_or(&self.app_name),
-        );
+        let storage = if let Some(file) = &self.native_options.persistence_path {
+            epi_integration::create_storage_with_file(file)
+        } else {
+            epi_integration::create_storage(
+                self.native_options
+                    .viewport
+                    .app_id
+                    .as_ref()
+                    .unwrap_or(&self.app_name),
+            )
+        };
 
         let egui_ctx = create_egui_context(storage.as_deref());
 
@@ -309,7 +313,7 @@ impl GlowWinitApp {
                 raw_window_handle: window.window_handle().map(|h| h.as_raw()),
             };
             crate::profile_scope!("app_creator");
-            app_creator(&cc)
+            app_creator(&cc).map_err(crate::Error::AppCreation)?
         };
 
         let glutin = Rc::new(RefCell::new(glutin));
diff --git a/crates/eframe/src/native/run.rs b/crates/eframe/src/native/run.rs
index 3ee249edf76..7087ed6ae71 100644
--- a/crates/eframe/src/native/run.rs
+++ b/crates/eframe/src/native/run.rs
@@ -2,7 +2,7 @@ use std::{cell::RefCell, time::Instant};
 
 use winit::event_loop::{EventLoop, EventLoopBuilder};
 
-use egui::epaint::ahash::HashMap;
+use ahash::HashMap;
 
 use crate::{
     epi,
diff --git a/crates/eframe/src/native/wgpu_integration.rs b/crates/eframe/src/native/wgpu_integration.rs
index f365d74ad93..28f149f0b3f 100644
--- a/crates/eframe/src/native/wgpu_integration.rs
+++ b/crates/eframe/src/native/wgpu_integration.rs
@@ -15,8 +15,8 @@ use winit::{
     window::{Window, WindowId},
 };
 
+use ahash::{HashMap, HashSet, HashSetExt};
 use egui::{
-    ahash::{HashMap, HashSet, HashSetExt},
     DeferredViewportUiCallback, FullOutput, ImmediateViewport, ViewportBuilder, ViewportClass,
     ViewportId, ViewportIdMap, ViewportIdPair, ViewportIdSet, ViewportInfo, ViewportOutput,
 };
@@ -182,7 +182,7 @@ impl WgpuWinitApp {
         storage: Option<Box<dyn Storage>>,
         window: Window,
         builder: ViewportBuilder,
-    ) -> Result<&mut WgpuWinitRunning, egui_wgpu::WgpuError> {
+    ) -> crate::Result<&mut WgpuWinitRunning> {
         crate::profile_function!();
 
         #[allow(unsafe_code, unused_mut, unused_unsafe)]
@@ -272,7 +272,7 @@ impl WgpuWinitApp {
         };
         let app = {
             crate::profile_scope!("user_app_creator");
-            app_creator(&cc)
+            app_creator(&cc).map_err(crate::Error::AppCreation)?
         };
 
         let mut viewport_from_window = HashMap::default();
@@ -406,13 +406,17 @@ impl WinitApp for WgpuWinitApp {
                     self.recreate_window(event_loop, running);
                     running
                 } else {
-                    let storage = epi_integration::create_storage(
-                        self.native_options
-                            .viewport
-                            .app_id
-                            .as_ref()
-                            .unwrap_or(&self.app_name),
-                    );
+                    let storage = if let Some(file) = &self.native_options.persistence_path {
+                        epi_integration::create_storage_with_file(file)
+                    } else {
+                        epi_integration::create_storage(
+                            self.native_options
+                                .viewport
+                                .app_id
+                                .as_ref()
+                                .unwrap_or(&self.app_name),
+                        )
+                    };
                     let egui_ctx = winit_integration::create_egui_context(storage.as_deref());
                     let (window, builder) = create_window(
                         &egui_ctx,
diff --git a/crates/eframe/src/web/app_runner.rs b/crates/eframe/src/web/app_runner.rs
index 620fe86fd62..f8b7f14a9da 100644
--- a/crates/eframe/src/web/app_runner.rs
+++ b/crates/eframe/src/web/app_runner.rs
@@ -2,9 +2,10 @@ use egui::TexturesDelta;
 
 use crate::{epi, App};
 
-use super::{now_sec, web_painter::WebPainter, NeedRepaint};
+use super::{now_sec, text_agent::TextAgent, web_painter::WebPainter, NeedRepaint};
 
 pub struct AppRunner {
+    #[allow(dead_code)]
     web_options: crate::WebOptions,
     pub(crate) frame: epi::Frame,
     egui_ctx: egui::Context,
@@ -13,7 +14,7 @@ pub struct AppRunner {
     app: Box<dyn epi::App>,
     pub(crate) needs_repaint: std::sync::Arc<NeedRepaint>,
     last_save_time: f64,
-    pub(crate) ime: Option<egui::output::IMEOutput>,
+    pub(crate) text_agent: TextAgent,
     pub(crate) mutable_text_under_cursor: bool,
 
     // Output for the last run:
@@ -29,11 +30,12 @@ impl Drop for AppRunner {
 
 impl AppRunner {
     /// # Errors
-    /// Failure to initialize WebGL renderer.
+    /// Failure to initialize WebGL renderer, or failure to create app.
     pub async fn new(
         canvas_id: &str,
         web_options: crate::WebOptions,
         app_creator: epi::AppCreator,
+        text_agent: TextAgent,
     ) -> Result<Self, String> {
         let painter = super::ActiveWebPainter::new(canvas_id, &web_options).await?;
 
@@ -70,7 +72,7 @@ impl AppRunner {
         let theme = system_theme.unwrap_or(web_options.default_theme);
         egui_ctx.set_visuals(theme.egui_visuals());
 
-        let app = app_creator(&epi::CreationContext {
+        let cc = epi::CreationContext {
             egui_ctx: egui_ctx.clone(),
             integration_info: info.clone(),
             storage: Some(&storage),
@@ -85,7 +87,8 @@ impl AppRunner {
             wgpu_render_state: painter.render_state(),
             #[cfg(all(feature = "wgpu", feature = "glow"))]
             wgpu_render_state: None,
-        });
+        };
+        let app = app_creator(&cc).map_err(|err| err.to_string())?;
 
         let frame = epi::Frame {
             info,
@@ -117,7 +120,7 @@ impl AppRunner {
             app,
             needs_repaint,
             last_save_time: now_sec(),
-            ime: None,
+            text_agent,
             mutable_text_under_cursor: false,
             textures_delta: Default::default(),
             clipped_primitives: None,
@@ -184,7 +187,6 @@ impl AppRunner {
     ///
     /// The result can be painted later with a call to [`Self::run_and_paint`] or [`Self::paint`].
     pub fn logic(&mut self) {
-        super::resize_canvas_to_screen_size(self.canvas(), self.web_options.max_size_points);
         let canvas_size = super::canvas_size_in_points(self.canvas(), self.egui_ctx());
         let raw_input = self.input.new_frame(canvas_size);
 
@@ -269,9 +271,11 @@ impl AppRunner {
 
         self.mutable_text_under_cursor = mutable_text_under_cursor;
 
-        if self.ime != ime {
-            super::text_agent::move_text_cursor(ime, self.canvas());
-            self.ime = ime;
+        if let Err(err) = self.text_agent.move_to(ime, self.canvas()) {
+            log::error!(
+                "failed to update text agent position: {}",
+                super::string_from_js_value(&err)
+            );
         }
     }
 }
diff --git a/crates/eframe/src/web/events.rs b/crates/eframe/src/web/events.rs
index 56d3fdf071a..b2f371bde3e 100644
--- a/crates/eframe/src/web/events.rs
+++ b/crates/eframe/src/web/events.rs
@@ -94,8 +94,8 @@ pub(crate) fn install_document_events(runner_ref: &WebRunner) -> Result<(), JsVa
             if !modifiers.ctrl
                 && !modifiers.command
                 && !should_ignore_key(&key)
-                // When text agent is shown, it sends text event instead.
-                && text_agent::text_agent().hidden()
+                // When text agent is focused, it is responsible for handling input events
+                && !runner.text_agent.has_focus()
             {
                 runner.input.raw.events.push(egui::Event::Text(key));
             }
@@ -247,7 +247,8 @@ pub(crate) fn install_window_events(runner_ref: &WebRunner) -> Result<(), JsValu
         runner.save();
     })?;
 
-    for event_name in &["load", "pagehide", "pageshow", "resize"] {
+    // NOTE: resize is handled by `ResizeObserver` below
+    for event_name in &["load", "pagehide", "pageshow"] {
         runner_ref.add_event_listener(&window, event_name, move |_: web_sys::Event, runner| {
             // log::debug!("{event_name:?}");
             runner.needs_repaint.repaint_asap();
@@ -374,10 +375,12 @@ pub(crate) fn install_canvas_events(runner_ref: &WebRunner) -> Result<(), JsValu
                 // event callback, which is why we run the app logic here and now:
                 runner.logic();
 
+                runner
+                    .text_agent
+                    .set_focus(runner.mutable_text_under_cursor);
+
                 // Make sure we paint the output of the above logic call asap:
                 runner.needs_repaint.repaint_asap();
-
-                text_agent::update_text_agent(runner);
             }
             event.stop_propagation();
             event.prevent_default();
@@ -466,13 +469,15 @@ pub(crate) fn install_canvas_events(runner_ref: &WebRunner) -> Result<(), JsValu
                 runner.input.raw.events.push(egui::Event::PointerGone);
 
                 push_touches(runner, egui::TouchPhase::End, &event);
+
+                runner
+                    .text_agent
+                    .set_focus(runner.mutable_text_under_cursor);
+
                 runner.needs_repaint.repaint_asap();
                 event.stop_propagation();
                 event.prevent_default();
             }
-
-            // Finally, focus or blur text agent to toggle mobile keyboard:
-            text_agent::update_text_agent(runner);
         },
     )?;
 
@@ -590,3 +595,79 @@ pub(crate) fn install_canvas_events(runner_ref: &WebRunner) -> Result<(), JsValu
 
     Ok(())
 }
+
+pub(crate) fn install_resize_observer(runner_ref: &WebRunner) -> Result<(), JsValue> {
+    let closure = Closure::wrap(Box::new({
+        let runner_ref = runner_ref.clone();
+        move |entries: js_sys::Array| {
+            // Only call the wrapped closure if the egui code has not panicked
+            if let Some(mut runner_lock) = runner_ref.try_lock() {
+                let canvas = runner_lock.canvas();
+                let (width, height) = match get_display_size(&entries) {
+                    Ok(v) => v,
+                    Err(err) => {
+                        log::error!("{}", super::string_from_js_value(&err));
+                        return;
+                    }
+                };
+                canvas.set_width(width);
+                canvas.set_height(height);
+
+                // force an immediate repaint
+                runner_lock.needs_repaint.repaint_asap();
+                paint_if_needed(&mut runner_lock);
+            }
+        }
+    }) as Box<dyn FnMut(js_sys::Array)>);
+
+    let observer = web_sys::ResizeObserver::new(closure.as_ref().unchecked_ref())?;
+    let mut options = web_sys::ResizeObserverOptions::new();
+    options.box_(web_sys::ResizeObserverBoxOptions::ContentBox);
+    if let Some(runner_lock) = runner_ref.try_lock() {
+        observer.observe_with_options(runner_lock.canvas(), &options);
+        drop(runner_lock);
+        runner_ref.set_resize_observer(observer, closure);
+    }
+
+    Ok(())
+}
+
+// Code ported to Rust from:
+// https://webglfundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
+fn get_display_size(resize_observer_entries: &js_sys::Array) -> Result<(u32, u32), JsValue> {
+    let width;
+    let height;
+    let mut dpr = web_sys::window().unwrap().device_pixel_ratio();
+
+    let entry: web_sys::ResizeObserverEntry = resize_observer_entries.at(0).dyn_into()?;
+    if JsValue::from_str("devicePixelContentBoxSize").js_in(entry.as_ref()) {
+        // NOTE: Only this path gives the correct answer for most browsers.
+        // Unfortunately this doesn't work perfectly everywhere.
+        let size: web_sys::ResizeObserverSize =
+            entry.device_pixel_content_box_size().at(0).dyn_into()?;
+        width = size.inline_size();
+        height = size.block_size();
+        dpr = 1.0; // no need to apply
+    } else if JsValue::from_str("contentBoxSize").js_in(entry.as_ref()) {
+        let content_box_size = entry.content_box_size();
+        let idx0 = content_box_size.at(0);
+        if !idx0.is_undefined() {
+            let size: web_sys::ResizeObserverSize = idx0.dyn_into()?;
+            width = size.inline_size();
+            height = size.block_size();
+        } else {
+            // legacy
+            let size = JsValue::clone(content_box_size.as_ref());
+            let size: web_sys::ResizeObserverSize = size.dyn_into()?;
+            width = size.inline_size();
+            height = size.block_size();
+        }
+    } else {
+        // legacy
+        let content_rect = entry.content_rect();
+        width = content_rect.width();
+        height = content_rect.height();
+    }
+
+    Ok(((width.round() * dpr) as u32, (height.round() * dpr) as u32))
+}
diff --git a/crates/eframe/src/web/mod.rs b/crates/eframe/src/web/mod.rs
index 566c9b03c8d..50e7aeb363e 100644
--- a/crates/eframe/src/web/mod.rs
+++ b/crates/eframe/src/web/mod.rs
@@ -40,7 +40,6 @@ pub(crate) type ActiveWebPainter = web_painter_wgpu::WebPainterWgpu;
 
 pub use backend::*;
 
-use egui::Vec2;
 use wasm_bindgen::prelude::*;
 use web_sys::MediaQueryList;
 
@@ -54,6 +53,29 @@ pub(crate) fn string_from_js_value(value: &JsValue) -> String {
     value.as_string().unwrap_or_else(|| format!("{value:#?}"))
 }
 
+/// Returns the `Element` with active focus.
+///
+/// Elements can only be focused if they are:
+/// - `<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 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()?;
+        Some(element == &focused_element)
+    }
+    try_has_focus(element).unwrap_or(false)
+}
+
 /// Current time in seconds (since undefined point in time).
 ///
 /// Monotonically increasing.
@@ -124,56 +146,6 @@ fn canvas_size_in_points(canvas: &web_sys::HtmlCanvasElement, ctx: &egui::Contex
     )
 }
 
-fn resize_canvas_to_screen_size(
-    canvas: &web_sys::HtmlCanvasElement,
-    max_size_points: egui::Vec2,
-) -> Option<()> {
-    let parent = canvas.parent_element()?;
-
-    // In this function we use "pixel" to mean physical pixel,
-    // and "point" to mean "logical CSS pixel".
-    let pixels_per_point = native_pixels_per_point();
-
-    // Prefer the client width and height so that if the parent
-    // element is resized that the egui canvas resizes appropriately.
-    let parent_size_points = Vec2 {
-        x: parent.client_width() as f32,
-        y: parent.client_height() as f32,
-    };
-
-    if parent_size_points.x <= 0.0 || parent_size_points.y <= 0.0 {
-        log::error!("The parent element of the egui canvas is {}x{}. Try adding `html, body {{ height: 100%; width: 100% }}` to your CSS!", parent_size_points.x, parent_size_points.y);
-    }
-
-    // We take great care here to ensure the rendered canvas aligns
-    // perfectly to the physical pixel grid, lest we get blurry text.
-    // At the time of writing, we get pixel perfection on Chromium and Firefox on Mac,
-    // but Desktop Safari will be blurry on most zoom levels.
-    // See https://github.com/emilk/egui/issues/4241 for more.
-
-    let canvas_size_pixels = pixels_per_point * parent_size_points.min(max_size_points);
-
-    // Make sure that the size is always an even number of pixels,
-    // otherwise, the page renders blurry on some platforms.
-    // See https://github.com/emilk/egui/issues/103
-    let canvas_size_pixels = (canvas_size_pixels / 2.0).round() * 2.0;
-
-    let canvas_size_points = canvas_size_pixels / pixels_per_point;
-
-    canvas
-        .style()
-        .set_property("width", &format!("{}px", canvas_size_points.x))
-        .ok()?;
-    canvas
-        .style()
-        .set_property("height", &format!("{}px", canvas_size_points.y))
-        .ok()?;
-    canvas.set_width(canvas_size_pixels.x as u32);
-    canvas.set_height(canvas_size_pixels.y as u32);
-
-    Some(())
-}
-
 // ----------------------------------------------------------------------------
 
 /// Set the cursor icon.
diff --git a/crates/eframe/src/web/text_agent.rs b/crates/eframe/src/web/text_agent.rs
index 5cfec81bf30..68c150f1b0c 100644
--- a/crates/eframe/src/web/text_agent.rs
+++ b/crates/eframe/src/web/text_agent.rs
@@ -1,237 +1,178 @@
-//! The text agent is an `<input>` element used to trigger
-//! mobile keyboard and IME input.
-//!
-use std::{cell::Cell, rc::Rc};
+//! The text agent is a hidden `<input>` element used to capture
+//! IME and mobile keyboard input events.
+
+use std::cell::Cell;
 
 use wasm_bindgen::prelude::*;
 
 use super::{AppRunner, WebRunner};
 
-static AGENT_ID: &str = "egui_text_agent";
-
-pub fn text_agent() -> web_sys::HtmlInputElement {
-    web_sys::window()
-        .unwrap()
-        .document()
-        .unwrap()
-        .get_element_by_id(AGENT_ID)
-        .unwrap()
-        .dyn_into()
-        .unwrap()
+pub struct TextAgent {
+    input: web_sys::HtmlInputElement,
+    prev_ime_output: Cell<Option<egui::output::IMEOutput>>,
 }
 
-/// Text event handler,
-pub fn install_text_agent(runner_ref: &WebRunner) -> Result<(), JsValue> {
-    let window = web_sys::window().unwrap();
-    let document = window.document().unwrap();
-    let body = document.body().expect("document should have a body");
-    let input = document
-        .create_element("input")?
-        .dyn_into::<web_sys::HtmlInputElement>()?;
-    let input = std::rc::Rc::new(input);
-    input.set_id(AGENT_ID);
-    let is_composing = Rc::new(Cell::new(false));
-    {
-        let style = input.style();
-        // Transparent
-        style.set_property("opacity", "0").unwrap();
-        // Hide under canvas
-        style.set_property("z-index", "-1").unwrap();
-    }
-    // Set size as small as possible, in case user may click on it.
-    input.set_size(1);
-    input.set_autofocus(true);
-    input.set_hidden(true);
-
-    // When IME is off
-    runner_ref.add_event_listener(&input, "input", {
-        let input_clone = input.clone();
-        let is_composing = is_composing.clone();
-
-        move |_event: web_sys::InputEvent, runner| {
-            let text = input_clone.value();
-            if !text.is_empty() && !is_composing.get() {
-                input_clone.set_value("");
-                runner.input.raw.events.push(egui::Event::Text(text));
-                runner.needs_repaint.repaint_asap();
-            }
-        }
-    })?;
-
-    {
-        // When IME is on, handle composition event
-        runner_ref.add_event_listener(&input, "compositionstart", {
-            let input_clone = input.clone();
-            let is_composing = is_composing.clone();
+impl TextAgent {
+    /// Attach the agent to the document.
+    pub fn attach(runner_ref: &WebRunner) -> Result<Self, JsValue> {
+        let document = web_sys::window().unwrap().document().unwrap();
 
-            move |_event: web_sys::CompositionEvent, runner: &mut AppRunner| {
-                is_composing.set(true);
-                input_clone.set_value("");
+        // create an `<input>` element
+        let input = document
+            .create_element("input")?
+            .dyn_into::<web_sys::HtmlInputElement>()?;
+        input.set_type("text");
 
-                let egui_event = egui::Event::Ime(egui::ImeEvent::Enabled);
-                runner.input.raw.events.push(egui_event);
+        // append it to `<body>` and hide it outside of the viewport
+        let style = input.style();
+        style.set_property("opacity", "0")?;
+        style.set_property("width", "1px")?;
+        style.set_property("height", "1px")?;
+        style.set_property("position", "absolute")?;
+        style.set_property("top", "0")?;
+        style.set_property("left", "0")?;
+        document.body().unwrap().append_child(&input)?;
+
+        // attach event listeners
+
+        let on_input = {
+            let input = input.clone();
+            move |event: web_sys::InputEvent, runner: &mut AppRunner| {
+                let text = input.value();
+                // if `is_composing` is true, then user is using IME, for example: emoji, pinyin, kanji, hangul, etc.
+                // In that case, the browser emits both `input` and `compositionupdate` events,
+                // and we need to ignore the `input` event.
+                if !text.is_empty() && !event.is_composing() {
+                    input.set_value("");
+                    let event = egui::Event::Text(text);
+                    runner.input.raw.events.push(event);
+                    runner.needs_repaint.repaint_asap();
+                }
+            }
+        };
+
+        let on_composition_start = {
+            let input = input.clone();
+            move |_: web_sys::CompositionEvent, runner: &mut AppRunner| {
+                input.set_value("");
+                let event = egui::Event::Ime(egui::ImeEvent::Enabled);
+                runner.input.raw.events.push(event);
+                // Repaint moves the text agent into place,
+                // see `move_to` in `AppRunner::handle_platform_output`.
                 runner.needs_repaint.repaint_asap();
             }
-        })?;
+        };
 
-        runner_ref.add_event_listener(
-            &input,
-            "compositionupdate",
+        let on_composition_update = {
             move |event: web_sys::CompositionEvent, runner: &mut AppRunner| {
-                if let Some(text) = event.data() {
-                    let egui_event = egui::Event::Ime(egui::ImeEvent::Preedit(text));
-                    runner.input.raw.events.push(egui_event);
-                    runner.needs_repaint.repaint_asap();
-                }
-            },
-        )?;
-
-        runner_ref.add_event_listener(&input, "compositionend", {
-            let input_clone = input.clone();
+                let Some(text) = event.data() else { return };
+                let event = egui::Event::Ime(egui::ImeEvent::Preedit(text));
+                runner.input.raw.events.push(event);
+                runner.needs_repaint.repaint_asap();
+            }
+        };
 
+        let on_composition_end = {
+            let input = input.clone();
             move |event: web_sys::CompositionEvent, runner: &mut AppRunner| {
-                is_composing.set(false);
-                input_clone.set_value("");
-
-                if let Some(text) = event.data() {
-                    let egui_event = egui::Event::Ime(egui::ImeEvent::Commit(text));
-                    runner.input.raw.events.push(egui_event);
-                    runner.needs_repaint.repaint_asap();
-                }
+                let Some(text) = event.data() else { return };
+                input.set_value("");
+                let event = egui::Event::Ime(egui::ImeEvent::Commit(text));
+                runner.input.raw.events.push(event);
+                runner.needs_repaint.repaint_asap();
             }
-        })?;
-    }
+        };
 
-    // When input lost focus, focus on it again.
-    // It is useful when user click somewhere outside canvas.
-    let input_refocus = input.clone();
-    runner_ref.add_event_listener(&input, "focusout", move |_event: web_sys::MouseEvent, _| {
-        // Delay 10 ms, and focus again.
-        let input_refocus = input_refocus.clone();
-        call_after_delay(std::time::Duration::from_millis(10), move || {
-            input_refocus.focus().ok();
-        });
-    })?;
+        runner_ref.add_event_listener(&input, "input", on_input)?;
+        runner_ref.add_event_listener(&input, "compositionstart", on_composition_start)?;
+        runner_ref.add_event_listener(&input, "compositionupdate", on_composition_update)?;
+        runner_ref.add_event_listener(&input, "compositionend", on_composition_end)?;
 
-    body.append_child(&input)?;
+        Ok(Self {
+            input,
+            prev_ime_output: Default::default(),
+        })
+    }
 
-    Ok(())
-}
+    pub fn move_to(
+        &self,
+        ime: Option<egui::output::IMEOutput>,
+        canvas: &web_sys::HtmlCanvasElement,
+    ) -> Result<(), JsValue> {
+        // Mobile keyboards don't follow the text input it's writing to,
+        // instead typically being fixed in place on the bottom of the screen,
+        // so don't bother moving the text agent on mobile.
+        if is_mobile() {
+            return Ok(());
+        }
 
-/// Focus or blur text agent to toggle mobile keyboard.
-pub fn update_text_agent(runner: &AppRunner) -> Option<()> {
-    use web_sys::HtmlInputElement;
-    let window = web_sys::window()?;
-    let document = window.document()?;
-    let input: HtmlInputElement = document.get_element_by_id(AGENT_ID)?.dyn_into().unwrap();
-    let canvas_style = runner.canvas().style();
+        // Don't move the text agent unless the position actually changed:
+        if self.prev_ime_output.get() == ime {
+            return Ok(());
+        }
+        self.prev_ime_output.set(ime);
 
-    if runner.mutable_text_under_cursor {
-        let is_already_editing = input.hidden();
-        if is_already_editing {
-            input.set_hidden(false);
-            input.focus().ok()?;
+        let Some(ime) = ime else { return Ok(()) };
 
-            // Move up canvas so that text edit is shown at ~30% of screen height.
-            // Only on touch screens, when keyboard popups.
-            if let Some(latest_touch_pos) = runner.input.latest_touch_pos {
-                let window_height = window.inner_height().ok()?.as_f64()? as f32;
-                let current_rel = latest_touch_pos.y / window_height;
+        let ime_pos = ime.cursor_rect.left_top();
+        let canvas_rect = canvas.get_bounding_client_rect();
+        let new_pos = ime_pos + egui::vec2(canvas_rect.left() as f32, canvas_rect.top() as f32);
 
-                // estimated amount of screen covered by keyboard
-                let keyboard_fraction = 0.5;
+        let style = self.input.style();
+        style.set_property("top", &format!("{}px", new_pos.y))?;
+        style.set_property("left", &format!("{}px", new_pos.x))?;
 
-                if current_rel > keyboard_fraction {
-                    // below the keyboard
+        Ok(())
+    }
 
-                    let target_rel = 0.3;
+    pub fn set_focus(&self, on: bool) {
+        if on {
+            self.focus();
+        } else {
+            self.blur();
+        }
+    }
 
-                    // Note: `delta` is negative, since we are moving the canvas UP
-                    let delta = target_rel - current_rel;
+    pub fn has_focus(&self) -> bool {
+        super::has_focus(&self.input)
+    }
 
-                    let delta = delta.max(-keyboard_fraction); // Don't move it crazy much
+    fn focus(&self) {
+        if self.has_focus() {
+            return;
+        }
 
-                    let new_pos_percent = format!("{}%", (delta * 100.0).round());
+        if let Err(err) = self.input.focus() {
+            log::error!("failed to set focus: {}", super::string_from_js_value(&err));
+        };
+    }
 
-                    canvas_style.set_property("position", "absolute").ok()?;
-                    canvas_style.set_property("top", &new_pos_percent).ok()?;
-                }
-            }
+    fn blur(&self) {
+        if !self.has_focus() {
+            return;
         }
-    } else {
-        // Holding the runner lock while calling input.blur() causes a panic.
-        // This is most probably caused by the browser running the event handler
-        // for the triggered blur event synchronously, meaning that the mutex
-        // lock does not get dropped by the time another event handler is called.
-        //
-        // Why this didn't exist before #1290 is a mystery to me, but it exists now
-        // and this apparently is the fix for it
-        //
-        // ¯\_(ツ)_/¯ - @DusterTheFirst
-
-        // So since we are inside a runner lock here, we just postpone the blur/hide:
-
-        call_after_delay(std::time::Duration::from_millis(0), move || {
-            input.blur().ok();
-            input.set_hidden(true);
-            canvas_style.set_property("position", "absolute").ok();
-            canvas_style.set_property("top", "0%").ok(); // move back to normal position
-        });
+
+        if let Err(err) = self.input.blur() {
+            log::error!("failed to set focus: {}", super::string_from_js_value(&err));
+        };
     }
-    Some(())
 }
 
-fn call_after_delay(delay: std::time::Duration, f: impl FnOnce() + 'static) {
-    use wasm_bindgen::prelude::*;
-    let window = web_sys::window().unwrap();
-    let closure = Closure::once(f);
-    let delay_ms = delay.as_millis() as _;
-    window
-        .set_timeout_with_callback_and_timeout_and_arguments_0(
-            closure.as_ref().unchecked_ref(),
-            delay_ms,
-        )
-        .unwrap();
-    closure.forget(); // We must forget it, or else the callback is canceled on drop
+impl Drop for TextAgent {
+    fn drop(&mut self) {
+        self.input.remove();
+    }
 }
 
-/// If context is running under mobile device?
-fn is_mobile() -> Option<bool> {
-    const MOBILE_DEVICE: [&str; 6] = ["Android", "iPhone", "iPad", "iPod", "webOS", "BlackBerry"];
-
-    let user_agent = web_sys::window()?.navigator().user_agent().ok()?;
-    let is_mobile = MOBILE_DEVICE.iter().any(|&name| user_agent.contains(name));
-    Some(is_mobile)
-}
+/// Returns `true` if the app is likely running on a mobile device.
+fn is_mobile() -> bool {
+    fn try_is_mobile() -> Option<bool> {
+        const MOBILE_DEVICE: [&str; 6] =
+            ["Android", "iPhone", "iPad", "iPod", "webOS", "BlackBerry"];
 
-// Move text agent to text cursor's position, on desktop/laptop,
-// candidate window moves following text element (agent),
-// so it appears that the IME candidate window moves with text cursor.
-// On mobile devices, there is no need to do that.
-pub fn move_text_cursor(
-    ime: Option<egui::output::IMEOutput>,
-    canvas: &web_sys::HtmlCanvasElement,
-) -> Option<()> {
-    let style = text_agent().style();
-    // Note: moving agent on mobile devices will lead to unpredictable scroll.
-    if is_mobile() == Some(false) {
-        ime.as_ref().and_then(|ime| {
-            let egui::Pos2 { x, y } = ime.cursor_rect.left_top();
-
-            let bounding_rect = text_agent().get_bounding_client_rect();
-            let y = (y + (canvas.scroll_top() + canvas.offset_top()) as f32)
-                .min(canvas.client_height() as f32 - bounding_rect.height() as f32);
-            let x = x + (canvas.scroll_left() + canvas.offset_left()) as f32;
-            // Canvas is translated 50% horizontally in html.
-            let x = (x - canvas.offset_width() as f32 / 2.0)
-                .min(canvas.client_width() as f32 - bounding_rect.width() as f32);
-            style.set_property("position", "absolute").ok()?;
-            style.set_property("top", &format!("{y}px")).ok()?;
-            style.set_property("left", &format!("{x}px")).ok()
-        })
-    } else {
-        style.set_property("position", "absolute").ok()?;
-        style.set_property("top", "0px").ok()?;
-        style.set_property("left", "0px").ok()
+        let user_agent = web_sys::window()?.navigator().user_agent().ok()?;
+        let is_mobile = MOBILE_DEVICE.iter().any(|&name| user_agent.contains(name));
+        Some(is_mobile)
     }
+    try_is_mobile().unwrap_or(false)
 }
diff --git a/crates/eframe/src/web/web_runner.rs b/crates/eframe/src/web/web_runner.rs
index f39fc0dcace..9c97b6a73dd 100644
--- a/crates/eframe/src/web/web_runner.rs
+++ b/crates/eframe/src/web/web_runner.rs
@@ -1,13 +1,10 @@
-use std::{
-    cell::{Cell, RefCell},
-    rc::Rc,
-};
+use std::{cell::RefCell, rc::Rc};
 
 use wasm_bindgen::prelude::*;
 
 use crate::{epi, App};
 
-use super::{events, AppRunner, PanicHandler};
+use super::{events, text_agent::TextAgent, AppRunner, PanicHandler};
 
 /// This is how `eframe` runs your wepp application
 ///
@@ -28,8 +25,10 @@ pub struct WebRunner {
     /// the panic handler, since they aren't `Send`.
     events_to_unsubscribe: Rc<RefCell<Vec<EventToUnsubscribe>>>,
 
-    /// Used in `destroy` to cancel a pending frame.
-    request_animation_frame_id: Cell<Option<i32>>,
+    /// Current animation frame in flight.
+    frame: Rc<RefCell<Option<AnimationFrameRequest>>>,
+
+    resize_observer: Rc<RefCell<Option<ResizeObserverContext>>>,
 }
 
 impl WebRunner {
@@ -47,14 +46,15 @@ impl WebRunner {
             panic_handler,
             runner: Rc::new(RefCell::new(None)),
             events_to_unsubscribe: Rc::new(RefCell::new(Default::default())),
-            request_animation_frame_id: Cell::new(None),
+            frame: Default::default(),
+            resize_observer: Default::default(),
         }
     }
 
     /// Create the application, install callbacks, and start running the app.
     ///
     /// # Errors
-    /// Failing to initialize graphics.
+    /// Failing to initialize graphics, or failure to create app.
     pub async fn start(
         &self,
         canvas_id: &str,
@@ -65,19 +65,22 @@ impl WebRunner {
 
         let follow_system_theme = web_options.follow_system_theme;
 
-        let runner = AppRunner::new(canvas_id, web_options, app_creator).await?;
+        let text_agent = TextAgent::attach(self)?;
+
+        let runner = AppRunner::new(canvas_id, web_options, app_creator, text_agent).await?;
         self.runner.replace(Some(runner));
 
         {
             events::install_canvas_events(self)?;
             events::install_document_events(self)?;
             events::install_window_events(self)?;
-            super::text_agent::install_text_agent(self)?;
 
             if follow_system_theme {
                 events::install_color_scheme_change_event(self)?;
             }
 
+            events::install_resize_observer(self)?;
+
             self.request_animation_frame()?;
         }
 
@@ -109,15 +112,20 @@ impl WebRunner {
                 }
             }
         }
+
+        if let Some(context) = self.resize_observer.take() {
+            context.resize_observer.disconnect();
+            drop(context.closure);
+        }
     }
 
     /// Shut down eframe and clean up resources.
     pub fn destroy(&self) {
         self.unsubscribe_from_all_events();
 
-        if let Some(id) = self.request_animation_frame_id.get() {
+        if let Some(frame) = self.frame.take() {
             let window = web_sys::window().unwrap();
-            window.cancel_animation_frame(id).ok();
+            window.cancel_animation_frame(frame.id).ok();
         }
 
         if let Some(runner) = self.runner.replace(None) {
@@ -192,21 +200,68 @@ impl WebRunner {
         Ok(())
     }
 
+    /// Request an animation frame from the browser in which we can perform a paint.
+    ///
+    /// It is safe to call `request_animation_frame` multiple times in quick succession,
+    /// this function guarantees that only one animation frame is scheduled at a time.
     pub(crate) fn request_animation_frame(&self) -> Result<(), wasm_bindgen::JsValue> {
+        if self.frame.borrow().is_some() {
+            // there is already an animation frame in flight
+            return Ok(());
+        }
+
         let window = web_sys::window().unwrap();
         let closure = Closure::once({
             let runner_ref = self.clone();
-            move || events::paint_and_schedule(&runner_ref)
+            move || {
+                // We can paint now, so clear the animation frame.
+                // This drops the `closure` and allows another
+                // animation frame to be scheduled
+                let _ = runner_ref.frame.take();
+                events::paint_and_schedule(&runner_ref)
+            }
         });
+
         let id = window.request_animation_frame(closure.as_ref().unchecked_ref())?;
-        self.request_animation_frame_id.set(Some(id));
-        closure.forget(); // We must forget it, or else the callback is canceled on drop
+        self.frame.borrow_mut().replace(AnimationFrameRequest {
+            id,
+            _closure: closure,
+        });
+
         Ok(())
     }
+
+    pub(crate) fn set_resize_observer(
+        &self,
+        resize_observer: web_sys::ResizeObserver,
+        closure: Closure<dyn FnMut(js_sys::Array)>,
+    ) {
+        self.resize_observer
+            .borrow_mut()
+            .replace(ResizeObserverContext {
+                resize_observer,
+                closure,
+            });
+    }
 }
 
 // ----------------------------------------------------------------------------
 
+// https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/closure/struct.Closure.html#using-fnonce-and-closureonce-with-requestanimationframe
+struct AnimationFrameRequest {
+    /// Represents the ID of a frame in flight.
+    id: i32,
+
+    /// The callback given to `request_animation_frame`, stored here both to prevent it
+    /// from being canceled, and from having to `.forget()` it.
+    _closure: Closure<dyn FnMut() -> Result<(), JsValue>>,
+}
+
+struct ResizeObserverContext {
+    resize_observer: web_sys::ResizeObserver,
+    closure: Closure<dyn FnMut(js_sys::Array)>,
+}
+
 struct TargetEvent {
     target: web_sys::EventTarget,
     event_name: String,
diff --git a/crates/egui-wgpu/Cargo.toml b/crates/egui-wgpu/Cargo.toml
index 1de7d1446ef..3eaac2e92f5 100644
--- a/crates/egui-wgpu/Cargo.toml
+++ b/crates/egui-wgpu/Cargo.toml
@@ -50,6 +50,7 @@ x11 = ["winit?/x11"]
 egui = { workspace = true, default-features = false }
 epaint = { workspace = true, default-features = false, features = ["bytemuck"] }
 
+ahash.workspace = true
 bytemuck.workspace = true
 document-features.workspace = true
 log.workspace = true
diff --git a/crates/egui-wgpu/src/renderer.rs b/crates/egui-wgpu/src/renderer.rs
index 49397c9af89..5853f563ff1 100644
--- a/crates/egui-wgpu/src/renderer.rs
+++ b/crates/egui-wgpu/src/renderer.rs
@@ -2,7 +2,8 @@
 
 use std::{borrow::Cow, num::NonZeroU64, ops::Range};
 
-use epaint::{ahash::HashMap, emath::NumExt, PaintCallbackInfo, Primitive, Vertex};
+use ahash::HashMap;
+use epaint::{emath::NumExt, PaintCallbackInfo, Primitive, Vertex};
 
 use wgpu::util::DeviceExt as _;
 
@@ -293,7 +294,6 @@ impl Renderer {
                         // 2: uint color
                         attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2, 2 => Uint32],
                     }],
-                    compilation_options: wgpu::PipelineCompilationOptions::default()
                 },
                 primitive: wgpu::PrimitiveState {
                     topology: wgpu::PrimitiveTopology::TriangleList,
@@ -335,7 +335,6 @@ impl Renderer {
                         }),
                         write_mask: wgpu::ColorWrites::ALL,
                     })],
-                    compilation_options: wgpu::PipelineCompilationOptions::default()
                 }),
                 multiview: None,
             }
diff --git a/crates/egui-winit/Cargo.toml b/crates/egui-winit/Cargo.toml
index 6354b7a439f..0cf9bf9403a 100644
--- a/crates/egui-winit/Cargo.toml
+++ b/crates/egui-winit/Cargo.toml
@@ -59,6 +59,8 @@ x11 = ["winit/x11", "bytemuck"]
 
 [dependencies]
 egui = { workspace = true, default-features = false, features = ["log"] }
+
+ahash.workspace = true
 log.workspace = true
 raw-window-handle.workspace = true
 web-time.workspace = true
diff --git a/crates/egui-winit/src/lib.rs b/crates/egui-winit/src/lib.rs
index 7b40f92b773..9a57359887b 100644
--- a/crates/egui-winit/src/lib.rs
+++ b/crates/egui-winit/src/lib.rs
@@ -14,9 +14,7 @@ pub use accesskit_winit;
 pub use egui;
 #[cfg(feature = "accesskit")]
 use egui::accesskit;
-use egui::{
-    ahash::HashSet, Pos2, Rect, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo,
-};
+use egui::{Pos2, Rect, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo};
 pub use winit;
 
 pub mod clipboard;
@@ -24,6 +22,7 @@ mod window_settings;
 
 pub use window_settings::WindowSettings;
 
+use ahash::HashSet;
 use raw_window_handle::HasDisplayHandle;
 
 #[allow(unused_imports)]
diff --git a/crates/egui/src/containers/area.rs b/crates/egui/src/containers/area.rs
index 857569da3ac..1bb15483541 100644
--- a/crates/egui/src/containers/area.rs
+++ b/crates/egui/src/containers/area.rs
@@ -4,25 +4,43 @@
 
 use crate::*;
 
-/// State that is persisted between frames.
-// TODO(emilk): this is not currently stored in `Memory::data`, but maybe it should be?
+/// State of an [`Area`] that is persisted between frames.
+///
+/// Areas back [`crate::Window`]s and other floating containers,
+/// like tooltips and the popups of [`crate::ComboBox`].
+///
+/// Area state is intentionally NOT persisted between sessions,
+/// so that a bad tooltip or menu size won't be remembered forever.
+/// A resizable [`Window`] remembers the size the user picked using
+/// the state in the [`Resize`] container.
 #[derive(Clone, Copy, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub(crate) struct State {
-    /// Last known pos of the pivot
+pub struct AreaState {
+    /// Last known position of the pivot.
     pub pivot_pos: Pos2,
 
+    /// The anchor point of the area, i.e. where on the area the [`Self::pivot_pos`] refers to.
     pub pivot: Align2,
 
-    /// Last know size. Used for catching clicks.
+    /// Last known size.
     pub size: Vec2,
 
-    /// If false, clicks goes straight through to what is behind us.
-    /// Good for tooltips etc.
+    /// If false, clicks goes straight through to what is behind us. Useful for tooltips etc.
     pub interactable: bool,
+
+    /// At what time was this area first shown?
+    ///
+    /// Used to fade in the area.
+    pub last_became_visible_at: f64,
 }
 
-impl State {
+impl AreaState {
+    /// Load the state of an [`Area`] from memory.
+    pub fn load(ctx: &Context, id: Id) -> Option<Self> {
+        // TODO(emilk): Area state is not currently stored in `Memory::data`, but maybe it should be?
+        ctx.memory(|mem| mem.areas().get(id).copied())
+    }
+
+    /// The left top positions of the area.
     pub fn left_top_pos(&self) -> Pos2 {
         pos2(
             self.pivot_pos.x - self.pivot.x().to_factor() * self.size.x,
@@ -30,6 +48,7 @@ impl State {
         )
     }
 
+    /// Move the left top positions of the area.
     pub fn set_left_top_pos(&mut self, pos: Pos2) {
         self.pivot_pos = pos2(
             pos.x + self.pivot.x().to_factor() * self.size.x,
@@ -37,6 +56,7 @@ impl State {
         );
     }
 
+    /// Where the area is on screen.
     pub fn rect(&self) -> Rect {
         Rect::from_min_size(self.left_top_pos(), self.size)
     }
@@ -69,9 +89,15 @@ pub struct Area {
     constrain_rect: Option<Rect>,
     order: Order,
     default_pos: Option<Pos2>,
+    default_size: Vec2,
     pivot: Align2,
     anchor: Option<(Align2, Vec2)>,
     new_pos: Option<Pos2>,
+    fade_in: bool,
+}
+
+impl WidgetWithState for Area {
+    type State = AreaState;
 }
 
 impl Area {
@@ -82,14 +108,16 @@ impl Area {
             sense: None,
             movable: true,
             interactable: true,
-            constrain: false,
+            constrain: true,
             constrain_rect: None,
             enabled: true,
             order: Order::Middle,
             default_pos: None,
+            default_size: Vec2::NAN,
             new_pos: None,
             pivot: Align2::LEFT_TOP,
             anchor: None,
+            fade_in: true,
         }
     }
 
@@ -163,6 +191,35 @@ impl Area {
         self
     }
 
+    /// The size used for the [`Ui::max_rect`] the first frame.
+    ///
+    /// Text will wrap at this width, and images that expand to fill the available space
+    /// will expand to this size.
+    ///
+    /// If the contents are smaller than this size, the area will shrink to fit the contents.
+    /// If the contents overflow, the area will grow.
+    ///
+    /// If not set, [`style::Spacing::default_area_size`] will be used.
+    #[inline]
+    pub fn default_size(mut self, default_size: impl Into<Vec2>) -> Self {
+        self.default_size = default_size.into();
+        self
+    }
+
+    /// See [`Self::default_size`].
+    #[inline]
+    pub fn default_width(mut self, default_width: f32) -> Self {
+        self.default_size.x = default_width;
+        self
+    }
+
+    /// See [`Self::default_size`].
+    #[inline]
+    pub fn default_height(mut self, default_height: f32) -> Self {
+        self.default_size.y = default_height;
+        self
+    }
+
     /// Positions the window and prevents it from being moved
     #[inline]
     pub fn fixed_pos(mut self, fixed_pos: impl Into<Pos2>) -> Self {
@@ -171,7 +228,9 @@ impl Area {
         self
     }
 
-    /// Constrains this area to the screen bounds.
+    /// Constrains this area to [`Context::screen_rect`]?
+    ///
+    /// Default: `true`.
     #[inline]
     pub fn constrain(mut self, constrain: bool) -> Self {
         self.constrain = constrain;
@@ -232,22 +291,33 @@ impl Area {
             Align2::LEFT_TOP
         }
     }
+
+    /// If `true`, quickly fade in the area.
+    ///
+    /// Default: `true`.
+    #[inline]
+    pub fn fade_in(mut self, fade_in: bool) -> Self {
+        self.fade_in = fade_in;
+        self
+    }
 }
 
 pub(crate) struct Prepared {
     layer_id: LayerId,
-    state: State,
+    state: AreaState,
     move_response: Response,
     enabled: bool,
     constrain: bool,
-    constrain_rect: Option<Rect>,
+    constrain_rect: Rect,
 
     /// We always make windows invisible the first frame to hide "first-frame-jitters".
     ///
     /// This is so that we use the first frame to calculate the window size,
     /// and then can correctly position the window and its contents the next frame,
     /// without having one frame where the window is wrongly positioned or sized.
-    temporarily_invisible: bool,
+    sizing_pass: bool,
+
+    fade_in: bool,
 }
 
 impl Area {
@@ -272,39 +342,68 @@ impl Area {
             interactable,
             enabled,
             default_pos,
+            default_size,
             new_pos,
             pivot,
             anchor,
             constrain,
             constrain_rect,
+            fade_in,
         } = self;
 
+        let constrain_rect = constrain_rect.unwrap_or_else(|| ctx.screen_rect());
+
         let layer_id = LayerId::new(order, id);
 
-        let state = ctx
-            .memory(|mem| mem.areas().get(id).copied())
-            .map(|mut state| {
-                // override the saved state with the correct value
-                state.pivot = pivot;
-                state
-            });
+        let state = AreaState::load(ctx, id).map(|mut state| {
+            // override the saved state with the correct value
+            state.pivot = pivot;
+            state
+        });
         let is_new = state.is_none();
         if is_new {
             ctx.request_repaint(); // if we don't know the previous size we are likely drawing the area in the wrong place
         }
-        let mut state = state.unwrap_or_else(|| State {
-            pivot_pos: default_pos.unwrap_or_else(|| automatic_area_position(ctx)),
-            pivot,
-            size: Vec2::ZERO,
-            interactable,
+        let mut state = state.unwrap_or_else(|| {
+            // during the sizing pass we will use this as the max size
+            let mut size = default_size;
+
+            let default_area_size = ctx.style().spacing.default_area_size;
+            if size.x.is_nan() {
+                size.x = default_area_size.x;
+            }
+            if size.y.is_nan() {
+                size.y = default_area_size.y;
+            }
+
+            if constrain {
+                size = size.at_most(constrain_rect.size());
+            }
+
+            AreaState {
+                pivot_pos: default_pos.unwrap_or_else(|| automatic_area_position(ctx)),
+                pivot,
+                size,
+                interactable,
+                last_became_visible_at: ctx.input(|i| i.time),
+            }
         });
         state.pivot_pos = new_pos.unwrap_or(state.pivot_pos);
         state.interactable = interactable;
 
+        // TODO(emilk): if last frame was sizing pass, it should be considered invisible for smmother fade-in
+        let visible_last_frame = ctx.memory(|mem| mem.areas().visible_last_frame(&layer_id));
+
+        if !visible_last_frame {
+            state.last_became_visible_at = ctx.input(|i| i.time);
+        }
+
         if let Some((anchor, offset)) = anchor {
-            let screen = ctx.available_rect();
             state.set_left_top_pos(
-                anchor.align_size_within_rect(state.size, screen).left_top() + offset,
+                anchor
+                    .align_size_within_rect(state.size, constrain_rect)
+                    .left_top()
+                    + offset,
             );
         }
 
@@ -354,7 +453,7 @@ impl Area {
 
         state.set_left_top_pos(ctx.round_pos_to_pixels(state.left_top_pos()));
 
-        // Update responsbe with posisbly moved/constrained rect:
+        // Update response with possibly moved/constrained rect:
         move_response.rect = state.rect();
         move_response.interact_rect = state.rect();
 
@@ -365,45 +464,18 @@ impl Area {
             enabled,
             constrain,
             constrain_rect,
-            temporarily_invisible: is_new,
-        }
-    }
-
-    pub fn show_open_close_animation(&self, ctx: &Context, frame: &Frame, is_open: bool) {
-        // must be called first so animation managers know the latest state
-        let visibility_factor = ctx.animate_bool(self.id.with("close_animation"), is_open);
-
-        if is_open {
-            // we actually only show close animations.
-            // when opening a window we show it right away.
-            return;
-        }
-        if visibility_factor <= 0.0 {
-            return;
-        }
-
-        let layer_id = LayerId::new(self.order, self.id);
-        let area_rect = ctx.memory(|mem| mem.areas().get(self.id).map(|area| area.rect()));
-        if let Some(area_rect) = area_rect {
-            let clip_rect = Rect::EVERYTHING;
-            let painter = Painter::new(ctx.clone(), layer_id, clip_rect);
-
-            // shrinkage: looks kinda a bad on its own
-            // let area_rect =
-            //     Rect::from_center_size(area_rect.center(), visibility_factor * area_rect.size());
-
-            let frame = frame.multiply_with_opacity(visibility_factor);
-            painter.add(frame.paint(area_rect));
+            sizing_pass: is_new,
+            fade_in,
         }
     }
 }
 
 impl Prepared {
-    pub(crate) fn state(&self) -> &State {
+    pub(crate) fn state(&self) -> &AreaState {
         &self.state
     }
 
-    pub(crate) fn state_mut(&mut self) -> &mut State {
+    pub(crate) fn state_mut(&mut self) -> &mut AreaState {
         &mut self.state
     }
 
@@ -411,34 +483,14 @@ impl Prepared {
         self.constrain
     }
 
-    pub(crate) fn constrain_rect(&self) -> Option<Rect> {
+    pub(crate) fn constrain_rect(&self) -> Rect {
         self.constrain_rect
     }
 
     pub(crate) fn content_ui(&self, ctx: &Context) -> Ui {
-        let screen_rect = ctx.screen_rect();
-
-        let constrain_rect = if let Some(constrain_rect) = self.constrain_rect {
-            constrain_rect.intersect(screen_rect) // protect against infinite bounds
-        } else {
-            let central_area = ctx.available_rect();
-
-            let is_within_central_area = central_area.contains_rect(self.state.rect().shrink(1.0));
-            if is_within_central_area {
-                central_area // let's try to not cover side panels
-            } else {
-                screen_rect
-            }
-        };
-
-        let max_rect = Rect::from_min_max(
-            self.state.left_top_pos(),
-            constrain_rect
-                .max
-                .at_least(self.state.left_top_pos() + Vec2::splat(32.0)),
-        );
+        let max_rect = Rect::from_min_size(self.state.left_top_pos(), self.state.size);
 
-        let clip_rect = constrain_rect; // Don't paint outside our bounds
+        let clip_rect = self.constrain_rect; // Don't paint outside our bounds
 
         let mut ui = Ui::new(
             ctx.clone(),
@@ -447,8 +499,21 @@ impl Prepared {
             max_rect,
             clip_rect,
         );
+
+        if self.fade_in {
+            let age =
+                ctx.input(|i| (i.time - self.state.last_became_visible_at) as f32 + i.predicted_dt);
+            let opacity = crate::remap_clamp(age, 0.0..=ctx.style().animation_time, 0.0..=1.0);
+            ui.multiply_opacity(opacity);
+            if opacity < 1.0 {
+                ctx.request_repaint();
+            }
+        }
+
         ui.set_enabled(self.enabled);
-        ui.set_visible(!self.temporarily_invisible);
+        if self.sizing_pass {
+            ui.set_sizing_pass();
+        }
         ui
     }
 
@@ -458,10 +523,7 @@ impl Prepared {
             layer_id,
             mut state,
             move_response,
-            enabled: _,
-            constrain: _,
-            constrain_rect: _,
-            temporarily_invisible: _,
+            ..
         } = self;
 
         state.size = content_ui.min_size();
@@ -486,11 +548,13 @@ fn automatic_area_position(ctx: &Context) -> Pos2 {
         mem.areas()
             .visible_windows()
             .into_iter()
-            .map(State::rect)
+            .map(AreaState::rect)
             .collect()
     });
     existing.sort_by_key(|r| r.left().round() as i32);
 
+    // NOTE: for the benefit of the egui demo, we position the windows so they don't
+    // cover the side panels, which means we use `available_rect` here instead of `constrain_rect` or `screen_rect`.
     let available_rect = ctx.available_rect();
 
     let spacing = 16.0;
diff --git a/crates/egui/src/containers/collapsing_header.rs b/crates/egui/src/containers/collapsing_header.rs
index 7c541a1a2f7..87754adfbf8 100644
--- a/crates/egui/src/containers/collapsing_header.rs
+++ b/crates/egui/src/containers/collapsing_header.rs
@@ -506,8 +506,12 @@ impl CollapsingHeader {
         let available = ui.available_rect_before_wrap();
         let text_pos = available.min + vec2(ui.spacing().indent, 0.0);
         let wrap_width = available.right() - text_pos.x;
-        let wrap = Some(false);
-        let galley = text.into_galley(ui, wrap, wrap_width, TextStyle::Button);
+        let galley = text.into_galley(
+            ui,
+            Some(TextWrapMode::Extend),
+            wrap_width,
+            TextStyle::Button,
+        );
         let text_max_x = text_pos.x + galley.size().x;
 
         let mut desired_width = text_max_x + button_padding.x - available.left();
diff --git a/crates/egui/src/containers/combo_box.rs b/crates/egui/src/containers/combo_box.rs
index 828ee140aa5..b4c7bbca7d3 100644
--- a/crates/egui/src/containers/combo_box.rs
+++ b/crates/egui/src/containers/combo_box.rs
@@ -5,7 +5,7 @@ use crate::{style::WidgetVisuals, *};
 #[allow(unused_imports)] // Documentation
 use crate::style::Spacing;
 
-/// Indicate whether or not a popup will be shown above or below the box.
+/// Indicate whether a popup will be shown above or below the box.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AboveOrBelow {
     Above,
@@ -40,7 +40,7 @@ pub struct ComboBox {
     width: Option<f32>,
     height: Option<f32>,
     icon: Option<IconPainter>,
-    wrap_enabled: bool,
+    wrap_mode: Option<TextWrapMode>,
 }
 
 impl ComboBox {
@@ -53,7 +53,7 @@ impl ComboBox {
             width: None,
             height: None,
             icon: None,
-            wrap_enabled: false,
+            wrap_mode: None,
         }
     }
 
@@ -67,7 +67,7 @@ impl ComboBox {
             width: None,
             height: None,
             icon: None,
-            wrap_enabled: false,
+            wrap_mode: None,
         }
     }
 
@@ -80,7 +80,7 @@ impl ComboBox {
             width: None,
             height: None,
             icon: None,
-            wrap_enabled: false,
+            wrap_mode: None,
         }
     }
 
@@ -148,10 +148,29 @@ impl ComboBox {
         self
     }
 
-    /// Controls whether text wrap is used for the selected text
+    /// Controls the wrap mode used for the selected text.
+    ///
+    /// By default, [`Ui::wrap_mode`] will be used, which can be overridden with [`Style::wrap_mode`].
+    ///
+    /// 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
+    }
+
+    /// Set [`Self::wrap_mode`] to [`TextWrapMode::Wrap`].
     #[inline]
-    pub fn wrap(mut self, wrap: bool) -> Self {
-        self.wrap_enabled = wrap;
+    pub fn wrap(mut self) -> Self {
+        self.wrap_mode = Some(TextWrapMode::Wrap);
+
+        self
+    }
+
+    /// Set [`Self::wrap_mode`] to [`TextWrapMode::Truncate`].
+    #[inline]
+    pub fn truncate(mut self) -> Self {
+        self.wrap_mode = Some(TextWrapMode::Truncate);
         self
     }
 
@@ -178,7 +197,7 @@ impl ComboBox {
             width,
             height,
             icon,
-            wrap_enabled,
+            wrap_mode,
         } = self;
 
         let button_id = ui.make_persistent_id(id_source);
@@ -190,7 +209,7 @@ impl ComboBox {
                 selected_text,
                 menu_contents,
                 icon,
-                wrap_enabled,
+                wrap_mode,
                 (width, height),
             );
             if let Some(label) = label {
@@ -251,18 +270,29 @@ impl ComboBox {
         }
         response
     }
+
+    /// 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)))
+    }
+
+    /// Convert a [`ComboBox`] id to the id used to store it's popup state.
+    fn widget_to_popup_id(widget_id: Id) -> Id {
+        widget_id.with("popup")
+    }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn combo_box_dyn<'c, R>(
     ui: &mut Ui,
     button_id: Id,
     selected_text: WidgetText,
     menu_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
     icon: Option<IconPainter>,
-    wrap_enabled: bool,
+    wrap_mode: Option<TextWrapMode>,
     (width, height): (Option<f32>, Option<f32>),
 ) -> InnerResponse<Option<R>> {
-    let popup_id = button_id.with("popup");
+    let popup_id = ComboBox::widget_to_popup_id(button_id);
 
     let is_popup_open = ui.memory(|m| m.is_popup_open(popup_id));
 
@@ -277,45 +307,33 @@ fn combo_box_dyn<'c, R>(
             AboveOrBelow::Above
         };
 
+    let wrap_mode = wrap_mode.unwrap_or_else(|| ui.wrap_mode());
+
     let margin = ui.spacing().button_padding;
     let button_response = button_frame(ui, button_id, is_popup_open, Sense::click(), |ui| {
         let icon_spacing = ui.spacing().icon_spacing;
-        // We don't want to change width when user selects something new
-        let full_minimum_width = if wrap_enabled {
-            // Currently selected value's text will be wrapped if needed, so occupy the available width.
-            ui.available_width()
-        } else {
-            // Occupy at least the minimum width assigned to ComboBox.
-            let width = width.unwrap_or_else(|| ui.spacing().combo_width);
-            width - 2.0 * margin.x
-        };
         let icon_size = Vec2::splat(ui.spacing().icon_width);
-        let wrap_width = if wrap_enabled {
-            // Use the available width, currently selected value's text will be wrapped if exceeds this value.
-            ui.available_width() - icon_spacing - icon_size.x
-        } else {
-            // Use all the width necessary to display the currently selected value's text.
-            f32::INFINITY
-        };
 
-        let galley =
-            selected_text.into_galley(ui, Some(wrap_enabled), wrap_width, TextStyle::Button);
+        // The combo box selected text will always have this minimum width.
+        // Note: the `ComboBox::width()` if set or `Spacing::combo_width` are considered as the
+        // minimum overall width, regardless of the wrap mode.
+        let minimum_width = width.unwrap_or_else(|| ui.spacing().combo_width) - 2.0 * margin.x;
 
-        // The width necessary to contain the whole widget with the currently selected value's text.
-        let width = if wrap_enabled {
-            full_minimum_width
+        // width against which to lay out the selected text
+        let wrap_width = if wrap_mode == TextWrapMode::Extend {
+            // Use all the width necessary to display the currently selected value's text.
+            f32::INFINITY
         } else {
-            // Occupy at least the minimum width needed to contain the widget with the currently selected value's text.
-            galley.size().x + icon_spacing + icon_size.x
+            // Use the available width, currently selected value's text will be wrapped if exceeds this value.
+            ui.available_width() - icon_spacing - icon_size.x
         };
 
-        // Case : wrap_enabled : occupy all the available width.
-        // Case : !wrap_enabled : occupy at least the minimum width assigned to Slider and ComboBox,
-        // increase if the currently selected value needs additional horizontal space to fully display its text (up to wrap_width (f32::INFINITY)).
-        let width = width.at_least(full_minimum_width);
-        let height = galley.size().y.max(icon_size.y);
+        let galley = selected_text.into_galley(ui, Some(wrap_mode), wrap_width, TextStyle::Button);
+
+        let actual_width = (galley.size().x + icon_spacing + icon_size.x).at_least(minimum_width);
+        let actual_height = galley.size().y.max(icon_size.y);
 
-        let (_, rect) = ui.allocate_space(Vec2::new(width, height));
+        let (_, rect) = ui.allocate_space(Vec2::new(actual_width, actual_height));
         let button_rect = ui.min_rect().expand2(ui.spacing().button_padding);
         let response = ui.interact(button_rect, button_id, Sense::click());
         // response.active |= is_popup_open;
@@ -371,7 +389,7 @@ fn combo_box_dyn<'c, R>(
                     // result in labels that wrap very early.
                     // Instead, we turn it off by default so that the labels
                     // expand the width of the menu.
-                    ui.style_mut().wrap = Some(false);
+                    ui.style_mut().wrap_mode = Some(TextWrapMode::Extend);
                     menu_contents(ui)
                 })
                 .inner
diff --git a/crates/egui/src/containers/frame.rs b/crates/egui/src/containers/frame.rs
index 40bd17d3c4d..8568a8f0b9b 100644
--- a/crates/egui/src/containers/frame.rs
+++ b/crates/egui/src/containers/frame.rs
@@ -266,7 +266,8 @@ impl Frame {
         self.show_dyn(ui, Box::new(add_contents))
     }
 
-    fn show_dyn<'c, R>(
+    /// Show using dynamic dispatch.
+    pub fn show_dyn<'c, R>(
         self,
         ui: &mut Ui,
         add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
diff --git a/crates/egui/src/containers/mod.rs b/crates/egui/src/containers/mod.rs
index 53e8e7e2ce0..2e5903239d6 100644
--- a/crates/egui/src/containers/mod.rs
+++ b/crates/egui/src/containers/mod.rs
@@ -13,7 +13,7 @@ pub mod scroll_area;
 pub(crate) mod window;
 
 pub use {
-    area::Area,
+    area::{Area, AreaState},
     collapsing_header::{CollapsingHeader, CollapsingResponse},
     combo_box::*,
     frame::Frame,
diff --git a/crates/egui/src/containers/popup.rs b/crates/egui/src/containers/popup.rs
index 9643a8eee31..661de610712 100644
--- a/crates/egui/src/containers/popup.rs
+++ b/crates/egui/src/containers/popup.rs
@@ -1,49 +1,8 @@
 //! Show popup windows, tooltips, context menus etc.
 
-use crate::*;
-
-// ----------------------------------------------------------------------------
-
-/// Same state for all tooltips.
-#[derive(Clone, Debug, Default)]
-pub(crate) struct TooltipState {
-    last_common_id: Option<Id>,
-    individual_ids_and_sizes: ahash::HashMap<usize, (Id, Vec2)>,
-}
-
-impl TooltipState {
-    pub fn load(ctx: &Context) -> Option<Self> {
-        ctx.data_mut(|d| d.get_temp(Id::NULL))
-    }
+use frame_state::PerWidgetTooltipState;
 
-    fn store(self, ctx: &Context) {
-        ctx.data_mut(|d| d.insert_temp(Id::NULL, self));
-    }
-
-    fn individual_tooltip_size(&self, common_id: Id, index: usize) -> Option<Vec2> {
-        if self.last_common_id == Some(common_id) {
-            Some(self.individual_ids_and_sizes.get(&index)?.1)
-        } else {
-            None
-        }
-    }
-
-    fn set_individual_tooltip(
-        &mut self,
-        common_id: Id,
-        index: usize,
-        individual_id: Id,
-        size: Vec2,
-    ) {
-        if self.last_common_id != Some(common_id) {
-            self.last_common_id = Some(common_id);
-            self.individual_ids_and_sizes.clear();
-        }
-
-        self.individual_ids_and_sizes
-            .insert(index, (individual_id, size));
-    }
-}
+use crate::*;
 
 // ----------------------------------------------------------------------------
 
@@ -66,10 +25,10 @@ impl TooltipState {
 /// ```
 pub fn show_tooltip<R>(
     ctx: &Context,
-    id: Id,
+    widget_id: Id,
     add_contents: impl FnOnce(&mut Ui) -> R,
 ) -> Option<R> {
-    show_tooltip_at_pointer(ctx, id, add_contents)
+    show_tooltip_at_pointer(ctx, widget_id, add_contents)
 }
 
 /// Show a tooltip at the current pointer position (if any).
@@ -91,13 +50,12 @@ pub fn show_tooltip<R>(
 /// ```
 pub fn show_tooltip_at_pointer<R>(
     ctx: &Context,
-    id: Id,
+    widget_id: Id,
     add_contents: impl FnOnce(&mut Ui) -> R,
 ) -> Option<R> {
-    let suggested_pos = ctx
-        .input(|i| i.pointer.hover_pos())
-        .map(|pointer_pos| pointer_pos + vec2(16.0, 16.0));
-    show_tooltip_at(ctx, id, suggested_pos, add_contents)
+    ctx.input(|i| i.pointer.hover_pos()).map(|pointer_pos| {
+        show_tooltip_at(ctx, widget_id, pointer_pos + vec2(16.0, 16.0), add_contents)
+    })
 }
 
 /// Show a tooltip under the given area.
@@ -105,22 +63,17 @@ pub fn show_tooltip_at_pointer<R>(
 /// If the tooltip does not fit under the area, it tries to place it above it instead.
 pub fn show_tooltip_for<R>(
     ctx: &Context,
-    id: Id,
-    rect: &Rect,
+    widget_id: Id,
+    widget_rect: &Rect,
     add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    let expanded_rect = rect.expand2(vec2(2.0, 4.0));
-    let (above, position) = if ctx.input(|i| i.any_touches()) {
-        (true, expanded_rect.left_top())
-    } else {
-        (false, expanded_rect.left_bottom())
-    };
+) -> 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_avoid_dyn(
         ctx,
-        id,
-        Some(position),
-        above,
-        expanded_rect,
+        widget_id,
+        allow_placing_below,
+        widget_rect,
         Box::new(add_contents),
     )
 }
@@ -130,102 +83,125 @@ pub fn show_tooltip_for<R>(
 /// Returns `None` if the tooltip could not be placed.
 pub fn show_tooltip_at<R>(
     ctx: &Context,
-    id: Id,
-    suggested_position: Option<Pos2>,
+    widget_id: Id,
+    suggested_position: Pos2,
     add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    let above = false;
+) -> R {
+    let allow_placing_below = true;
+    let rect = Rect::from_center_size(suggested_position, Vec2::ZERO);
     show_tooltip_at_avoid_dyn(
         ctx,
-        id,
-        suggested_position,
-        above,
-        Rect::NOTHING,
+        widget_id,
+        allow_placing_below,
+        &rect,
         Box::new(add_contents),
     )
 }
 
 fn show_tooltip_at_avoid_dyn<'c, R>(
     ctx: &Context,
-    individual_id: Id,
-    suggested_position: Option<Pos2>,
-    above: bool,
-    mut avoid_rect: Rect,
+    widget_id: Id,
+    allow_placing_below: bool,
+    widget_rect: &Rect,
     add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
-) -> Option<R> {
-    let spacing = 4.0;
-
+) -> R {
     // if there are multiple tooltips open they should use the same common_id for the `tooltip_size` caching to work.
-    let mut frame_state =
-        ctx.frame_state(|fs| fs.tooltip_state)
-            .unwrap_or(crate::frame_state::TooltipFrameState {
-                common_id: individual_id,
-                rect: Rect::NOTHING,
-                count: 0,
-            });
+    let mut state = ctx.frame_state(|fs| {
+        fs.tooltip_state
+            .widget_tooltips
+            .get(&widget_id)
+            .copied()
+            .unwrap_or(PerWidgetTooltipState {
+                bounding_rect: *widget_rect,
+                tooltip_count: 0,
+            })
+    });
 
-    let mut position = if frame_state.rect.is_positive() {
-        avoid_rect = avoid_rect.union(frame_state.rect);
-        if above {
-            frame_state.rect.left_top() - spacing * Vec2::Y
-        } else {
-            frame_state.rect.left_bottom() + spacing * Vec2::Y
-        }
-    } else if let Some(position) = suggested_position {
-        position
-    } else if ctx.memory(|mem| mem.everything_is_visible()) {
-        Pos2::ZERO
-    } else {
-        return None; // No good place for a tooltip :(
-    };
+    let tooltip_area_id = tooltip_id(widget_id, state.tooltip_count);
+    let expected_tooltip_size =
+        AreaState::load(ctx, tooltip_area_id).map_or(vec2(64.0, 32.0), |area| area.size);
 
-    let mut long_state = TooltipState::load(ctx).unwrap_or_default();
-    let expected_size =
-        long_state.individual_tooltip_size(frame_state.common_id, frame_state.count);
-    let expected_size = expected_size.unwrap_or_else(|| vec2(64.0, 32.0));
+    let screen_rect = ctx.screen_rect();
 
-    if above {
-        position.y -= expected_size.y;
-    }
+    let (pivot, anchor) = find_tooltip_position(
+        screen_rect,
+        state.bounding_rect,
+        allow_placing_below,
+        expected_tooltip_size,
+    );
 
-    position = position.at_most(ctx.screen_rect().max - expected_size);
+    let InnerResponse { inner, response } = Area::new(tooltip_area_id)
+        .order(Order::Tooltip)
+        .pivot(pivot)
+        .fixed_pos(anchor)
+        .default_width(ctx.style().spacing.tooltip_width)
+        .interactable(false)
+        .show(ctx, |ui| {
+            Frame::popup(&ctx.style()).show_dyn(ui, add_contents).inner
+        });
 
-    // check if we intersect the avoid_rect
-    {
-        let new_rect = Rect::from_min_size(position, expected_size);
+    state.tooltip_count += 1;
+    state.bounding_rect = state.bounding_rect.union(response.rect);
+    ctx.frame_state_mut(|fs| fs.tooltip_state.widget_tooltips.insert(widget_id, state));
 
-        // Note: We use shrink so that we don't get false positives when the rects just touch
-        if new_rect.shrink(1.0).intersects(avoid_rect) {
-            if above {
-                // place below instead:
-                position = avoid_rect.left_bottom() + spacing * Vec2::Y;
-            } else {
-                // place above instead:
-                position = Pos2::new(position.x, avoid_rect.min.y - expected_size.y - spacing);
-            }
-        }
-    }
+    inner
+}
 
-    let position = position.at_least(ctx.screen_rect().min);
+fn tooltip_id(widget_id: Id, tooltip_count: usize) -> Id {
+    widget_id.with(tooltip_count)
+}
 
-    let area_id = frame_state.common_id.with(frame_state.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;
 
-    let InnerResponse { inner, response } =
-        show_tooltip_area_dyn(ctx, area_id, position, add_contents);
+    // 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,
+        );
+    }
 
-    long_state.set_individual_tooltip(
-        frame_state.common_id,
-        frame_state.count,
-        individual_id,
-        response.rect.size(),
-    );
-    long_state.store(ctx);
+    // 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,
+        );
+    }
 
-    frame_state.count += 1;
-    frame_state.rect = frame_state.rect.union(response.rect);
-    ctx.frame_state_mut(|fs| fs.tooltip_state = Some(frame_state));
+    // 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,
+        );
+    }
 
-    Some(inner)
+    // 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).
@@ -243,52 +219,19 @@ fn show_tooltip_at_avoid_dyn<'c, R>(
 /// }
 /// # });
 /// ```
-pub fn show_tooltip_text(ctx: &Context, id: Id, text: impl Into<WidgetText>) -> Option<()> {
-    show_tooltip(ctx, id, |ui| {
+pub fn show_tooltip_text(ctx: &Context, widget_id: Id, text: impl Into<WidgetText>) -> Option<()> {
+    show_tooltip(ctx, widget_id, |ui| {
         crate::widgets::Label::new(text).ui(ui);
     })
 }
 
-/// Show a pop-over window.
-fn show_tooltip_area_dyn<'c, R>(
-    ctx: &Context,
-    area_id: Id,
-    window_pos: Pos2,
-    add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
-) -> InnerResponse<R> {
-    use containers::*;
-    Area::new(area_id)
-        .order(Order::Tooltip)
-        .fixed_pos(window_pos)
-        .constrain_to(ctx.screen_rect())
-        .interactable(false)
-        .show(ctx, |ui| {
-            Frame::popup(&ctx.style())
-                .show(ui, |ui| {
-                    ui.set_max_width(ui.spacing().tooltip_width);
-                    add_contents(ui)
-                })
-                .inner
-        })
-}
-
 /// Was this popup visible last frame?
-pub fn was_tooltip_open_last_frame(ctx: &Context, tooltip_id: Id) -> bool {
-    if let Some(state) = TooltipState::load(ctx) {
-        if let Some(common_id) = state.last_common_id {
-            for (count, (individual_id, _size)) in &state.individual_ids_and_sizes {
-                if *individual_id == tooltip_id {
-                    let area_id = common_id.with(count);
-                    let layer_id = LayerId::new(Order::Tooltip, area_id);
-                    if ctx.memory(|mem| mem.areas().visible_last_frame(&layer_id)) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-
-    false
+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))
+    })
 }
 
 /// Helper for [`popup_above_or_below_widget`].
@@ -311,7 +254,7 @@ pub fn popup_below_widget<R>(
 ///
 /// Useful for drop-down menus (combo boxes) or suggestion menus under text fields.
 ///
-/// The opened popup will have the same width as the parent.
+/// The opened popup will have a minimum width matching its parent.
 ///
 /// You must open the popup with [`Memory::open_popup`] or  [`Memory::toggle_popup`].
 ///
@@ -345,18 +288,20 @@ pub fn popup_above_or_below_widget<R>(
             AboveOrBelow::Below => (widget_response.rect.left_bottom(), Align2::LEFT_TOP),
         };
 
+        let frame = Frame::popup(parent_ui.style());
+        let frame_margin = frame.total_margin();
+        let inner_width = widget_response.rect.width() - frame_margin.sum().x;
+
         let inner = Area::new(popup_id)
             .order(Order::Foreground)
-            .constrain(true)
             .fixed_pos(pos)
+            .default_width(inner_width)
             .pivot(pivot)
             .show(parent_ui.ctx(), |ui| {
-                let frame = Frame::popup(parent_ui.style());
-                let frame_margin = frame.total_margin();
                 frame
                     .show(ui, |ui| {
                         ui.with_layout(Layout::top_down_justified(Align::LEFT), |ui| {
-                            ui.set_width(widget_response.rect.width() - frame_margin.sum().x);
+                            ui.set_min_width(inner_width);
                             add_contents(ui)
                         })
                         .inner
diff --git a/crates/egui/src/containers/scroll_area.rs b/crates/egui/src/containers/scroll_area.rs
index 0328835ec44..a2b3c239411 100644
--- a/crates/egui/src/containers/scroll_area.rs
+++ b/crates/egui/src/containers/scroll_area.rs
@@ -783,7 +783,14 @@ impl Prepared {
 
         let content_size = content_ui.min_size();
 
+        let scroll_delta = content_ui
+            .ctx()
+            .frame_state_mut(|state| std::mem::take(&mut state.scroll_delta));
+
         for d in 0..2 {
+            // FrameState::scroll_delta is inverted from the way we apply the delta, so we need to negate it.
+            let mut delta = -scroll_delta[d];
+
             // We always take both scroll targets regardless of which scroll axes are enabled. This
             // is to avoid them leaking to other scroll areas.
             let scroll_target = content_ui
@@ -791,7 +798,7 @@ impl Prepared {
                 .frame_state_mut(|state| state.scroll_target[d].take());
 
             if scroll_enabled[d] {
-                if let Some((target_range, align)) = scroll_target {
+                delta += if let Some((target_range, align)) = scroll_target {
                     let min = content_ui.min_rect().min[d];
                     let clip_rect = content_ui.clip_rect();
                     let visible_range = min..=min + clip_rect.size()[d];
@@ -800,7 +807,7 @@ impl Prepared {
                     let clip_end = clip_rect.max[d];
                     let mut spacing = ui.spacing().item_spacing[d];
 
-                    let delta = if let Some(align) = align {
+                    if let Some(align) = align {
                         let center_factor = align.to_factor();
 
                         let offset =
@@ -817,31 +824,32 @@ impl Prepared {
                     } else {
                         // Ui is already in view, no need to adjust scroll.
                         0.0
-                    };
+                    }
+                } else {
+                    0.0
+                };
 
-                    if delta != 0.0 {
-                        let target_offset = state.offset[d] + delta;
+                if delta != 0.0 {
+                    let target_offset = state.offset[d] + delta;
 
-                        if !animated {
-                            state.offset[d] = target_offset;
-                        } else if let Some(animation) = &mut state.offset_target[d] {
-                            // For instance: the user is continuously calling `ui.scroll_to_cursor`,
-                            // so we don't want to reset the animation, but perhaps update the target:
-                            animation.target_offset = target_offset;
-                        } else {
-                            // The further we scroll, the more time we take.
-                            // TODO(emilk): let users configure this in `Style`.
-                            let now = ui.input(|i| i.time);
-                            let points_per_second = 1000.0;
-                            let animation_duration =
-                                (delta.abs() / points_per_second).clamp(0.1, 0.3);
-                            state.offset_target[d] = Some(ScrollTarget {
-                                animation_time_span: (now, now + animation_duration as f64),
-                                target_offset,
-                            });
-                        }
-                        ui.ctx().request_repaint();
+                    if !animated {
+                        state.offset[d] = target_offset;
+                    } else if let Some(animation) = &mut state.offset_target[d] {
+                        // For instance: the user is continuously calling `ui.scroll_to_cursor`,
+                        // so we don't want to reset the animation, but perhaps update the target:
+                        animation.target_offset = target_offset;
+                    } else {
+                        // The further we scroll, the more time we take.
+                        // TODO(emilk): let users configure this in `Style`.
+                        let now = ui.input(|i| i.time);
+                        let points_per_second = 1000.0;
+                        let animation_duration = (delta.abs() / points_per_second).clamp(0.1, 0.3);
+                        state.offset_target[d] = Some(ScrollTarget {
+                            animation_time_span: (now, now + animation_duration as f64),
+                            target_offset,
+                        });
                     }
+                    ui.ctx().request_repaint();
                 }
             }
         }
diff --git a/crates/egui/src/containers/window.rs b/crates/egui/src/containers/window.rs
index 0b0d0c4b772..70f5b05bebc 100644
--- a/crates/egui/src/containers/window.rs
+++ b/crates/egui/src/containers/window.rs
@@ -40,6 +40,7 @@ pub struct Window<'open> {
     collapsible: bool,
     default_open: bool,
     with_title_bar: bool,
+    fade_out: bool,
 }
 
 impl<'open> Window<'open> {
@@ -48,7 +49,7 @@ impl<'open> Window<'open> {
     /// If you need a changing title, you must call `window.id(…)` with a fixed id.
     pub fn new(title: impl Into<WidgetText>) -> Self {
         let title = title.into().fallback_text_style(TextStyle::Heading);
-        let area = Area::new(Id::new(title.text())).constrain(true);
+        let area = Area::new(Id::new(title.text()));
         Self {
             title,
             open: None,
@@ -59,6 +60,7 @@ impl<'open> Window<'open> {
             collapsible: true,
             default_open: true,
             with_title_bar: true,
+            fade_out: true,
         }
     }
 
@@ -108,6 +110,26 @@ impl<'open> Window<'open> {
         self
     }
 
+    /// If `true`, quickly fade in the `Window` when it first appears.
+    ///
+    /// Default: `true`.
+    #[inline]
+    pub fn fade_in(mut self, fade_in: bool) -> Self {
+        self.area = self.area.fade_in(fade_in);
+        self
+    }
+
+    /// If `true`, quickly fade out the `Window` when it closes.
+    ///
+    /// This only works if you use [`Self::open`] to close the window.
+    ///
+    /// Default: `true`.
+    #[inline]
+    pub fn fade_out(mut self, fade_out: bool) -> Self {
+        self.fade_out = fade_out;
+        self
+    }
+
     /// Usage: `Window::new(…).mutate(|w| w.resize = w.resize.auto_expand_width(true))`
     // TODO(emilk): I'm not sure this is a good interface for this.
     #[inline]
@@ -195,7 +217,7 @@ impl<'open> Window<'open> {
         self
     }
 
-    /// Constrains this window to the screen bounds.
+    /// Constrains this window to [`Context::screen_rect`].
     ///
     /// To change the area to constrain to, use [`Self::constrain_to`].
     ///
@@ -399,6 +421,7 @@ impl<'open> Window<'open> {
             collapsible,
             default_open,
             with_title_bar,
+            fade_out,
         } = self;
 
         let header_color =
@@ -412,9 +435,8 @@ impl<'open> Window<'open> {
 
         let is_explicitly_closed = matches!(open, Some(false));
         let is_open = !is_explicitly_closed || ctx.memory(|mem| mem.everything_is_visible());
-        area.show_open_close_animation(ctx, &window_frame, is_open);
-
-        if !is_open {
+        let opacity = ctx.animate_bool(area.id.with("fade-out"), is_open);
+        if opacity <= 0.0 {
             return None;
         }
 
@@ -447,10 +469,16 @@ impl<'open> Window<'open> {
         resize.is_manually = true;
         let mut resize = resize.id(resize_id);
 
-        // Prevent window from becoming larger than the screen rect.
+        let mut prepared_area = area.begin(ctx);
+        let last_frame_outer_rect = prepared_area.state().rect();
+
         {
-            let screen_rect_size = ctx.screen_rect().size() - margins;
-            resize.max_size = resize.max_size.at_most(screen_rect_size);
+            // Prevent window from becoming larger than the constrain rect.
+            let constrain_rect = prepared_area.constrain_rect();
+            let max_width = constrain_rect.width();
+            let max_height = constrain_rect.height() - title_bar_height;
+            resize.max_size.x = resize.max_size.x.min(max_width);
+            resize.max_size.y = resize.max_size.y.min(max_height);
         }
 
         if let Some(mut resize_state) = resize::State::load(ctx, resize_id) {
@@ -460,26 +488,16 @@ impl<'open> Window<'open> {
                 resize_state.desired_size[d] = match resizable[d] && !scroll_enabled[d] {
                     true => resize_state.desired_size[d],
                     false => 0.0,
-                }
-            }
-            resize_state.store(ctx, resize_id);
-        }
-
-        let mut prepared_area = area.begin(ctx);
-        let last_frame_outer_rect = prepared_area.state().rect();
-
-        if let Some(mut resize_state) = resize::State::load(ctx, resize_id) {
-            let resizable = resize.is_resizable();
-            let scroll_enabled = scroll.scroll_enabled;
-            for d in 0..2 {
+                };
                 resize_state.largest_content_size[d] = match resizable[d] && !scroll_enabled[d] {
                     true => resize_state.largest_content_size[d],
                     false => 0.0,
-                }
+                };
             }
             resize_state.store(ctx, resize_id);
         }
 
+
         // First check for resize to avoid frame delay:
         let resize_interaction =
             resize_interaction(ctx, possible, area_layer_id, last_frame_outer_rect);
@@ -494,6 +512,12 @@ impl<'open> Window<'open> {
         );
 
         let mut area_content_ui = prepared_area.content_ui(ctx);
+        if is_open {
+            // `Area` already takes care of fade-in animations,
+            // so we only need to handle fade-out animations here.
+        } else if fade_out {
+            area_content_ui.multiply_opacity(opacity);
+        }
 
         let content_inner = {
             // BEGIN FRAME --------------------------------
@@ -1052,7 +1076,12 @@ fn show_title_bar(
             collapsing.show_default_button_with_size(ui, button_size);
         }
 
-        let title_galley = title.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Heading);
+        let title_galley = title.into_galley(
+            ui,
+            Some(crate::TextWrapMode::Extend),
+            f32::INFINITY,
+            TextStyle::Heading,
+        );
 
         let minimum_width = if collapsible || show_close_button {
             // If at least one button is shown we make room for both buttons (since title is centered):
diff --git a/crates/egui/src/context.rs b/crates/egui/src/context.rs
index d0dedaa1ac1..9471349999c 100644
--- a/crates/egui/src/context.rs
+++ b/crates/egui/src/context.rs
@@ -2,6 +2,7 @@
 
 use std::{borrow::Cow, cell::RefCell, panic::Location, sync::Arc, time::Duration};
 
+use containers::area::AreaState;
 use epaint::{
     emath::TSTransform, mutex::*, stats::*, text::Fonts, util::OrderedFloat, TessellationOptions, *,
 };
@@ -490,11 +491,12 @@ impl ContextImpl {
         // Ensure we register the background area so panels and background ui can catch clicks:
         self.memory.areas_mut().set_state(
             LayerId::background(),
-            containers::area::State {
+            AreaState {
                 pivot_pos: screen_rect.left_top(),
                 pivot: Align2::LEFT_TOP,
                 size: screen_rect.size(),
                 interactable: true,
+                last_became_visible_at: f64::NEG_INFINITY,
             },
         );
 
@@ -1774,23 +1776,7 @@ impl Context {
     // ---------------------------------------------------------------------
 
     /// Constrain the position of a window/area so it fits within the provided boundary.
-    ///
-    /// If area is `None`, will constrain to [`Self::available_rect`].
-    pub(crate) fn constrain_window_rect_to_area(&self, window: Rect, area: Option<Rect>) -> Rect {
-        let mut area = area.unwrap_or_else(|| self.available_rect());
-
-        if window.width() > area.width() {
-            // Allow overlapping side bars.
-            // This is important for small screens, e.g. mobiles running the web demo.
-            let screen_rect = self.screen_rect();
-            (area.min.x, area.max.x) = (screen_rect.min.x, screen_rect.max.x);
-        }
-        if window.height() > area.height() {
-            // Allow overlapping top/bottom bars:
-            let screen_rect = self.screen_rect();
-            (area.min.y, area.max.y) = (screen_rect.min.y, screen_rect.max.y);
-        }
-
+    pub(crate) fn constrain_window_rect_to_area(&self, window: Rect, area: Rect) -> Rect {
         let mut pos = window.min;
 
         // Constrain to screen, unless window is too large to fit:
@@ -2702,7 +2688,7 @@ impl Context {
             ui.label("Hover to highlight");
             let layers_ids: Vec<LayerId> = self.memory(|mem| mem.areas().order().to_vec());
             for layer_id in layers_ids {
-                let area = self.memory(|mem| mem.areas().get(layer_id.id).copied());
+                let area = AreaState::load(self, layer_id.id);
                 if let Some(area) = area {
                     let is_visible = self.memory(|mem| mem.areas().is_visible(&layer_id));
                     if !is_visible {
diff --git a/crates/egui/src/data/output.rs b/crates/egui/src/data/output.rs
index 97794f4d13e..d3dcc8bfe51 100644
--- a/crates/egui/src/data/output.rs
+++ b/crates/egui/src/data/output.rs
@@ -113,7 +113,7 @@ pub struct PlatformOutput {
     /// Use by `eframe` web to show/hide mobile keyboard and IME agent.
     pub mutable_text_under_cursor: bool,
 
-    /// This is et if, and only if, the user is currently editing text.
+    /// This is set if, and only if, the user is currently editing text.
     ///
     /// Useful for IME.
     pub ime: Option<IMEOutput>,
diff --git a/crates/egui/src/debug_text.rs b/crates/egui/src/debug_text.rs
index b2551de9ddf..672bc20c6a6 100644
--- a/crates/egui/src/debug_text.rs
+++ b/crates/egui/src/debug_text.rs
@@ -12,7 +12,7 @@ use crate::*;
 ///
 /// This is a built-in plugin in egui,
 /// meaning [`Context`] calls this from its `Default` implementation,
-/// so this i marked as `pub(crate)`.
+/// so this is marked as `pub(crate)`.
 pub(crate) fn register(ctx: &Context) {
     ctx.on_end_frame("debug_text", std::sync::Arc::new(State::end_frame));
 }
@@ -105,13 +105,11 @@ impl State {
 
             {
                 // Paint `text` to right of `pos`:
-                let wrap = true;
                 let available_width = ctx.screen_rect().max.x - pos.x;
                 let galley = text.into_galley_impl(
                     ctx,
                     &ctx.style(),
-                    wrap,
-                    available_width,
+                    text::TextWrapping::wrap_at_width(available_width),
                     font_id.clone().into(),
                     Align::TOP,
                 );
diff --git a/crates/egui/src/frame_state.rs b/crates/egui/src/frame_state.rs
index 5f966d117a0..28c8c364b78 100644
--- a/crates/egui/src/frame_state.rs
+++ b/crates/egui/src/frame_state.rs
@@ -1,10 +1,23 @@
 use crate::{id::IdSet, *};
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug, Default)]
 pub(crate) struct TooltipFrameState {
-    pub common_id: Id,
-    pub rect: Rect,
-    pub count: usize,
+    pub widget_tooltips: IdMap<PerWidgetTooltipState>,
+}
+
+impl TooltipFrameState {
+    pub(crate) fn clear(&mut self) {
+        self.widget_tooltips.clear();
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct PerWidgetTooltipState {
+    /// Bounding rectangle for all widget and all previous tooltips.
+    pub bounding_rect: Rect,
+
+    /// How many tooltips have been shown for this widget this frame?
+    pub tooltip_count: usize,
 }
 
 #[cfg(feature = "accesskit")]
@@ -35,12 +48,23 @@ pub(crate) struct FrameState {
 
     /// If a tooltip has been shown this frame, where was it?
     /// This is used to prevent multiple tooltips to cover each other.
-    /// Initialized to `None` at the start of each frame.
-    pub(crate) tooltip_state: Option<TooltipFrameState>,
+    /// Reset at the start of each frame.
+    pub(crate) tooltip_state: TooltipFrameState,
 
-    /// horizontal, vertical
+    /// The current scroll area should scroll to this range (horizontal, vertical).
     pub(crate) scroll_target: [Option<(Rangef, Option<Align>)>; 2],
 
+    /// The current scroll area should scroll by this much.
+    ///
+    /// The delta dictates how the _content_ should move.
+    ///
+    /// A positive X-value indicates the content is being moved right,
+    /// as when swiping right on a touch-screen or track-pad with natural scrolling.
+    ///
+    /// A positive Y-value indicates the content is being moved down,
+    /// as when swiping down on a touch-screen or track-pad with natural scrolling.
+    pub(crate) scroll_delta: Vec2,
+
     #[cfg(feature = "accesskit")]
     pub(crate) accesskit_state: Option<AccessKitFrameState>,
 
@@ -61,8 +85,9 @@ impl Default for FrameState {
             available_rect: Rect::NAN,
             unused_rect: Rect::NAN,
             used_by_panels: Rect::NAN,
-            tooltip_state: None,
+            tooltip_state: Default::default(),
             scroll_target: [None, None],
+            scroll_delta: Vec2::default(),
             #[cfg(feature = "accesskit")]
             accesskit_state: None,
             highlight_this_frame: Default::default(),
@@ -84,6 +109,7 @@ impl FrameState {
             used_by_panels,
             tooltip_state,
             scroll_target,
+            scroll_delta,
             #[cfg(feature = "accesskit")]
             accesskit_state,
             highlight_this_frame,
@@ -97,8 +123,9 @@ impl FrameState {
         *available_rect = screen_rect;
         *unused_rect = screen_rect;
         *used_by_panels = Rect::NOTHING;
-        *tooltip_state = None;
+        tooltip_state.clear();
         *scroll_target = [None, None];
+        *scroll_delta = Vec2::default();
 
         #[cfg(debug_assertions)]
         {
diff --git a/crates/egui/src/id.rs b/crates/egui/src/id.rs
index 0465c32d76c..c5047c26613 100644
--- a/crates/egui/src/id.rs
+++ b/crates/egui/src/id.rs
@@ -52,13 +52,13 @@ impl Id {
 
     /// Generate a new [`Id`] by hashing some source (e.g. a string or integer).
     pub fn new(source: impl std::hash::Hash) -> Self {
-        Self::from_hash(epaint::ahash::RandomState::with_seeds(1, 2, 3, 4).hash_one(source))
+        Self::from_hash(ahash::RandomState::with_seeds(1, 2, 3, 4).hash_one(source))
     }
 
     /// 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};
-        let mut hasher = epaint::ahash::RandomState::with_seeds(1, 2, 3, 4).build_hasher();
+        let mut hasher = ahash::RandomState::with_seeds(1, 2, 3, 4).build_hasher();
         hasher.write_u64(self.0.get());
         child.hash(&mut hasher);
         Self::from_hash(hasher.finish())
diff --git a/crates/egui/src/introspection.rs b/crates/egui/src/introspection.rs
index f71e82194be..d853b1c6196 100644
--- a/crates/egui/src/introspection.rs
+++ b/crates/egui/src/introspection.rs
@@ -129,7 +129,7 @@ impl Widget for &epaint::stats::PaintStats {
 }
 
 fn label(ui: &mut Ui, alloc_info: &epaint::stats::AllocInfo, what: &str) -> Response {
-    ui.add(Label::new(alloc_info.format(what)).wrap(false))
+    ui.add(Label::new(alloc_info.format(what)).wrap_mode(TextWrapMode::Extend))
 }
 
 impl Widget for &mut epaint::TessellationOptions {
diff --git a/crates/egui/src/lib.rs b/crates/egui/src/lib.rs
index c9d9b37ce48..517ee4c8ca5 100644
--- a/crates/egui/src/lib.rs
+++ b/crates/egui/src/lib.rs
@@ -338,6 +338,7 @@
 //! ## Code snippets
 //!
 //! ```
+//! # use egui::TextWrapMode;
 //! # egui::__run_test_ui(|ui| {
 //! # let mut some_bool = true;
 //! // Miscellaneous tips and tricks
@@ -358,7 +359,7 @@
 //! ui.scope(|ui| {
 //!     ui.visuals_mut().override_text_color = Some(egui::Color32::RED);
 //!     ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-//!     ui.style_mut().wrap = Some(false);
+//!     ui.style_mut().wrap_mode = Some(TextWrapMode::Truncate);
 //!
 //!     ui.label("This text will be red, monospace, and won't wrap to a new line");
 //! }); // the temporary settings are reverted here
@@ -451,6 +452,7 @@ pub use {
         Key,
     },
     drag_and_drop::DragAndDrop,
+    epaint::text::TextWrapMode,
     grid::Grid,
     id::{Id, IdMap},
     input_state::{InputState, MultiTouchInfo, PointerState},
diff --git a/crates/egui/src/load/texture_loader.rs b/crates/egui/src/load/texture_loader.rs
index 89d616e4760..26c254d4d0b 100644
--- a/crates/egui/src/load/texture_loader.rs
+++ b/crates/egui/src/load/texture_loader.rs
@@ -28,6 +28,17 @@ impl TextureLoader for DefaultTextureLoader {
                     let handle = ctx.load_texture(uri, image, texture_options);
                     let texture = SizedTexture::from_handle(&handle);
                     cache.insert((uri.into(), texture_options), handle);
+                    let reduce_texture_memory = ctx.options(|o| o.reduce_texture_memory);
+                    if reduce_texture_memory {
+                        let loaders = ctx.loaders();
+                        loaders.include.forget(uri);
+                        for loader in loaders.bytes.lock().iter().rev() {
+                            loader.forget(uri);
+                        }
+                        for loader in loaders.image.lock().iter().rev() {
+                            loader.forget(uri);
+                        }
+                    }
                     Ok(TexturePoll::Ready { texture })
                 }
             }
diff --git a/crates/egui/src/memory.rs b/crates/egui/src/memory.rs
index 8a642adf28e..84925e1cf6e 100644
--- a/crates/egui/src/memory.rs
+++ b/crates/egui/src/memory.rs
@@ -235,6 +235,19 @@ pub struct Options {
 
     /// Controls the speed at which we zoom in when doing ctrl/cmd + scroll.
     pub scroll_zoom_speed: f32,
+
+    /// If `true`, `egui` will discard the loaded image data after
+    /// the texture is loaded onto the GPU to reduce memory usage.
+    ///
+    /// In modern GPU rendering, the texture data is not required after the texture is loaded.
+    ///
+    /// This is beneficial when using a large number or resolution of images and there is no need to
+    /// retain the image data, potentially saving a significant amount of memory.
+    ///
+    /// The drawback is that it becomes impossible to serialize the loaded images or render in non-GPU systems.
+    ///
+    /// Default is `false`.
+    pub reduce_texture_memory: bool,
 }
 
 impl Default for Options {
@@ -260,6 +273,7 @@ impl Default for Options {
             // Input:
             line_scroll_speed,
             scroll_zoom_speed: 1.0 / 200.0,
+            reduce_texture_memory: false,
         }
     }
 }
@@ -279,6 +293,7 @@ impl Options {
 
             line_scroll_speed,
             scroll_zoom_speed,
+            reduce_texture_memory,
         } = self;
 
         use crate::Widget as _;
@@ -297,6 +312,8 @@ impl Options {
                 );
 
                 ui.checkbox(warn_on_id_clash, "Warn if two widgets have the same Id");
+
+                ui.checkbox(reduce_texture_memory, "Reduce texture memory");
             });
 
         use crate::containers::*;
@@ -917,7 +934,10 @@ impl Memory {
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct Areas {
-    areas: IdMap<area::State>,
+    /// Area state is intentionally NOT persisted between sessions,
+    /// so that a bad tooltip or menu size won't be remembered forever.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    areas: IdMap<area::AreaState>,
 
     /// Back-to-front. Top is last.
     order: Vec<LayerId>,
@@ -938,7 +958,7 @@ impl Areas {
         self.areas.len()
     }
 
-    pub(crate) fn get(&self, id: Id) -> Option<&area::State> {
+    pub(crate) fn get(&self, id: Id) -> Option<&area::AreaState> {
         self.areas.get(&id)
     }
 
@@ -956,7 +976,7 @@ impl Areas {
             .collect()
     }
 
-    pub(crate) fn set_state(&mut self, layer_id: LayerId, state: area::State) {
+    pub(crate) fn set_state(&mut self, layer_id: LayerId, state: area::AreaState) {
         self.visible_current_frame.insert(layer_id);
         self.areas.insert(layer_id.id, state);
         if !self.order.iter().any(|x| *x == layer_id) {
@@ -1005,7 +1025,7 @@ impl Areas {
             .collect()
     }
 
-    pub(crate) fn visible_windows(&self) -> Vec<&area::State> {
+    pub(crate) fn visible_windows(&self) -> Vec<&area::AreaState> {
         self.visible_layer_ids()
             .iter()
             .filter(|layer| layer.order == crate::Order::Middle)
diff --git a/crates/egui/src/menu.rs b/crates/egui/src/menu.rs
index 84fd1b2e8e3..09d0e25980c 100644
--- a/crates/egui/src/menu.rs
+++ b/crates/egui/src/menu.rs
@@ -25,16 +25,16 @@ use std::sync::Arc;
 
 /// What is saved between frames.
 #[derive(Clone, Default)]
-pub(crate) struct BarState {
+pub struct BarState {
     open_menu: MenuRootManager,
 }
 
 impl BarState {
-    fn load(ctx: &Context, bar_id: Id) -> Self {
+    pub fn load(ctx: &Context, bar_id: Id) -> Self {
         ctx.data_mut(|d| d.get_temp::<Self>(bar_id).unwrap_or_default())
     }
 
-    fn store(self, ctx: &Context, bar_id: Id) {
+    pub fn store(self, ctx: &Context, bar_id: Id) {
         ctx.data_mut(|d| d.insert_temp(bar_id, self));
     }
 
@@ -133,10 +133,10 @@ pub(crate) fn submenu_button<R>(
 }
 
 /// wrapper for the contents of every menu.
-pub(crate) fn menu_ui<'c, R>(
+fn menu_popup<'c, R>(
     ctx: &Context,
-    menu_id: Id,
     menu_state_arc: &Arc<RwLock<MenuState>>,
+    menu_id: Id,
     add_contents: impl FnOnce(&mut Ui) -> R + 'c,
 ) -> InnerResponse<R> {
     let pos = {
@@ -148,16 +148,19 @@ pub(crate) fn menu_ui<'c, R>(
     let area = Area::new(menu_id.with("__menu"))
         .order(Order::Foreground)
         .fixed_pos(pos)
-        .constrain_to(ctx.screen_rect())
         .interactable(true)
+        .default_width(ctx.style().spacing.menu_width)
         .sense(Sense::hover());
 
+    let mut sizing_pass = false;
+
     let area_response = area.show(ctx, |ui| {
+        sizing_pass = ui.is_sizing_pass();
+
         set_menu_style(ui.style_mut());
 
         Frame::menu(ui.style())
             .show(ui, |ui| {
-                ui.set_max_width(ui.spacing().menu_width);
                 ui.set_menu_state(Some(menu_state_arc.clone()));
                 ui.with_layout(Layout::top_down_justified(Align::LEFT), add_contents)
                     .inner
@@ -165,7 +168,16 @@ pub(crate) fn menu_ui<'c, R>(
             .inner
     });
 
-    menu_state_arc.write().rect = area_response.response.rect;
+    menu_state_arc.write().rect = if sizing_pass {
+        // During the sizing pass we didn't know the size yet,
+        // so we might have just constrained the position unnecessarily.
+        // Therefore keep the original=desired position until the next frame.
+        Rect::from_min_size(pos, area_response.response.rect.size())
+    } else {
+        // We knew the size, and this is where it ended up (potentially constrained to screen).
+        // Remember it for the future:
+        area_response.response.rect
+    };
 
     area_response
 }
@@ -242,7 +254,7 @@ pub(crate) fn context_menu_opened(response: &Response) -> bool {
 
 /// Stores the state for the context menu.
 #[derive(Clone, Default)]
-pub(crate) struct MenuRootManager {
+pub struct MenuRootManager {
     inner: Option<MenuRoot>,
 }
 
@@ -287,7 +299,7 @@ impl std::ops::DerefMut for MenuRootManager {
 
 /// Menu root associated with an Id from a Response
 #[derive(Clone)]
-pub(crate) struct MenuRoot {
+pub struct MenuRoot {
     pub menu_state: Arc<RwLock<MenuState>>,
     pub id: Id,
 }
@@ -306,8 +318,7 @@ impl MenuRoot {
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> (MenuResponse, Option<InnerResponse<R>>) {
         if self.id == button.id {
-            let inner_response =
-                MenuState::show(&button.ctx, &self.menu_state, self.id, add_contents);
+            let inner_response = menu_popup(&button.ctx, &self.menu_state, self.id, add_contents);
             let menu_state = self.menu_state.read();
 
             if menu_state.response.is_close() {
@@ -373,7 +384,7 @@ impl MenuRoot {
     }
 
     /// Interaction with a context menu (secondary click).
-    fn context_interaction(response: &Response, root: &mut Option<Self>) -> MenuResponse {
+    pub fn context_interaction(response: &Response, root: &mut Option<Self>) -> MenuResponse {
         let response = response.interact(Sense::click());
         let hovered = response.hovered();
         let secondary_clicked = response.secondary_clicked();
@@ -399,7 +410,7 @@ impl MenuRoot {
         })
     }
 
-    fn handle_menu_response(root: &mut MenuRootManager, menu_response: MenuResponse) {
+    pub fn handle_menu_response(root: &mut MenuRootManager, menu_response: MenuResponse) {
         match menu_response {
             MenuResponse::Create(pos, id) => {
                 root.inner = Some(Self::new(pos, id));
@@ -422,8 +433,8 @@ impl MenuRoot {
     }
 }
 
-#[derive(Copy, Clone, PartialEq)]
-pub(crate) enum MenuResponse {
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum MenuResponse {
     Close,
     Stay,
     Create(Pos2, Id),
@@ -476,16 +487,26 @@ impl SubMenuButton {
         let text_style = TextStyle::Button;
         let sense = Sense::click();
 
+        let text_icon_gap = ui.spacing().item_spacing.x;
         let button_padding = ui.spacing().button_padding;
         let total_extra = button_padding + button_padding;
         let text_available_width = ui.available_width() - total_extra.x;
-        let text_galley =
-            text.into_galley(ui, Some(true), text_available_width, text_style.clone());
+        let text_galley = text.into_galley(
+            ui,
+            Some(TextWrapMode::Wrap),
+            text_available_width,
+            text_style.clone(),
+        );
 
         let icon_available_width = text_available_width - text_galley.size().x;
-        let icon_galley = icon.into_galley(ui, Some(true), icon_available_width, text_style);
+        let icon_galley = icon.into_galley(
+            ui,
+            Some(TextWrapMode::Wrap),
+            icon_available_width,
+            text_style,
+        );
         let text_and_icon_size = Vec2::new(
-            text_galley.size().x + icon_galley.size().x,
+            text_galley.size().x + text_icon_gap + icon_galley.size().x,
             text_galley.size().y.max(icon_galley.size().y),
         );
         let mut desired_size = text_and_icon_size + 2.0 * button_padding;
@@ -553,7 +574,10 @@ impl SubMenu {
     }
 }
 
-pub(crate) struct MenuState {
+/// Components of menu state, public for advanced usage.
+///
+/// Usually you don't need to use it directly.
+pub struct MenuState {
     /// The opened sub-menu and its [`Id`]
     sub_menu: Option<(Id, Arc<RwLock<MenuState>>)>,
 
@@ -583,15 +607,6 @@ impl MenuState {
         self.response = MenuResponse::Close;
     }
 
-    pub fn show<R>(
-        ctx: &Context,
-        menu_state: &Arc<RwLock<Self>>,
-        id: Id,
-        add_contents: impl FnOnce(&mut Ui) -> R,
-    ) -> InnerResponse<R> {
-        crate::menu::menu_ui(ctx, id, menu_state, add_contents)
-    }
-
     fn show_submenu<R>(
         &mut self,
         ctx: &Context,
@@ -599,7 +614,7 @@ impl MenuState {
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> Option<R> {
         let (sub_response, response) = self.submenu(id).map(|sub| {
-            let inner_response = Self::show(ctx, sub, id, add_contents);
+            let inner_response = menu_popup(ctx, sub, id, add_contents);
             (sub.read().response, inner_response.inner)
         })?;
         self.cascade_close_response(sub_response);
diff --git a/crates/egui/src/painter.rs b/crates/egui/src/painter.rs
index 0935587cc7b..534524e32fe 100644
--- a/crates/egui/src/painter.rs
+++ b/crates/egui/src/painter.rs
@@ -83,12 +83,35 @@ impl Painter {
         self.fade_to_color = fade_to_color;
     }
 
-    pub(crate) fn set_opacity(&mut self, opacity: f32) {
+    /// Set the opacity (alpha multiplier) of everything painted by this painter from this point forward.
+    ///
+    /// `opacity` must be between 0.0 and 1.0, where 0.0 means fully transparent (i.e., invisible)
+    /// and 1.0 means fully opaque.
+    ///
+    /// See also: [`Self::opacity`] and [`Self::multiply_opacity`].
+    pub fn set_opacity(&mut self, opacity: f32) {
         if opacity.is_finite() {
             self.opacity_factor = opacity.clamp(0.0, 1.0);
         }
     }
 
+    /// Like [`Self::set_opacity`], but multiplies the given value with the current opacity.
+    ///
+    /// See also: [`Self::set_opacity`] and [`Self::opacity`].
+    pub fn multiply_opacity(&mut self, opacity: f32) {
+        if opacity.is_finite() {
+            self.opacity_factor *= opacity.clamp(0.0, 1.0);
+        }
+    }
+
+    /// Read the current opacity of the underlying painter.
+    ///
+    /// See also: [`Self::set_opacity`] and [`Self::multiply_opacity`].
+    #[inline]
+    pub fn opacity(&self) -> f32 {
+        self.opacity_factor
+    }
+
     pub(crate) fn is_visible(&self) -> bool {
         self.fade_to_color != Some(Color32::TRANSPARENT)
     }
diff --git a/crates/egui/src/response.rs b/crates/egui/src/response.rs
index d980bd78eb6..8697a9743a5 100644
--- a/crates/egui/src/response.rs
+++ b/crates/egui/src/response.rs
@@ -2,7 +2,8 @@ use std::{any::Any, sync::Arc};
 
 use crate::{
     emath::{Align, Pos2, Rect, Vec2},
-    menu, Context, CursorIcon, Id, LayerId, PointerButton, Sense, Ui, WidgetRect, WidgetText,
+    menu, ComboBox, Context, CursorIcon, Id, LayerId, PointerButton, Sense, Ui, WidgetRect,
+    WidgetText,
 };
 
 // ----------------------------------------------------------------------------
@@ -522,12 +523,7 @@ impl Response {
     #[doc(alias = "tooltip")]
     pub fn on_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.id.with("__tooltip"),
-                &self.rect,
-                add_contents,
-            );
+            self.show_tooltip_ui(add_contents);
         }
         self
     }
@@ -535,12 +531,7 @@ impl Response {
     /// 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.id.with("__tooltip"),
-                &self.rect,
-                add_contents,
-            );
+            crate::containers::show_tooltip_for(&self.ctx, self.id, &self.rect, add_contents);
         }
         self
     }
@@ -548,18 +539,30 @@ impl Response {
     /// 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.id.with("__tooltip"),
-                add_contents,
-            );
+            crate::containers::show_tooltip_at_pointer(&self.ctx, self.id, add_contents);
         }
         self
     }
 
+    /// Always show this tooltip, even if disabled and the user isn't hovering it.
+    ///
+    /// 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.id, &self.rect, add_contents);
+    }
+
+    /// Always show this tooltip, even if disabled and the user isn't hovering it.
+    ///
+    /// This can be used to give attention to a widget during a tutorial.
+    pub fn show_tooltip_text(&self, text: impl Into<WidgetText>) {
+        self.show_tooltip_ui(|ui| {
+            ui.label(text);
+        });
+    }
+
     /// Was the tooltip open last frame?
     pub fn is_tooltip_open(&self) -> bool {
-        crate::popup::was_tooltip_open_last_frame(&self.ctx, self.id.with("__tooltip"))
+        crate::popup::was_tooltip_open_last_frame(&self.ctx, self.id)
     }
 
     fn should_show_hover_ui(&self) -> bool {
@@ -567,10 +570,7 @@ impl Response {
             return true;
         }
 
-        if self.context_menu_opened() {
-            return false;
-        }
-
+        // Fast early-outs:
         if self.enabled {
             if !self.hovered || !self.ctx.input(|i| i.pointer.has_pointer()) {
                 return false;
@@ -579,20 +579,44 @@ impl Response {
             return false;
         }
 
-        if self.ctx.style().interaction.show_tooltips_only_when_still {
-            // We only show the tooltip when the mouse pointer is still,
-            // but once shown we keep showing it until the mouse leaves the parent.
+        if self.context_menu_opened() {
+            return false;
+        }
+
+        if ComboBox::is_open(&self.ctx, self.id) {
+            return false; // Don't cover the open ComboBox with a tooltip
+        }
 
-            if !self.ctx.input(|i| i.pointer.is_still()) && !self.is_tooltip_open() {
-                // wait for mouse to stop
-                self.ctx.request_repaint();
-                return false;
+        let when_was_a_toolip_last_shown_id = Id::new("when_was_a_toolip_last_shown");
+        let now = self.ctx.input(|i| i.time);
+
+        let when_was_a_toolip_last_shown = self
+            .ctx
+            .data(|d| d.get_temp::<f64>(when_was_a_toolip_last_shown_id));
+
+        let tooltip_delay = self.ctx.style().interaction.tooltip_delay;
+        let tooltip_grace_time = self.ctx.style().interaction.tooltip_grace_time;
+
+        // There is a tooltip_delay before showing the first tooltip,
+        // but once one tooltips 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 = when_was_a_toolip_last_shown
+            .map_or(false, |time| ((now - time) as f32) < tooltip_grace_time);
+
+        if !tooltip_was_recently_shown && !self.is_tooltip_open() {
+            if self.ctx.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()) {
+                    // wait for mouse to stop
+                    self.ctx.request_repaint();
+                    return false;
+                }
             }
-        }
 
-        if !self.is_tooltip_open() {
-            let time_til_tooltip = self.ctx.style().interaction.tooltip_delay
-                - self.ctx.input(|i| i.pointer.time_since_last_movement());
+            let time_til_tooltip =
+                tooltip_delay - self.ctx.input(|i| i.pointer.time_since_last_movement());
 
             if 0.0 < time_til_tooltip {
                 // Wait until the mouse has been still for a while
@@ -612,6 +636,12 @@ impl Response {
             return false;
         }
 
+        // All checks passed: show the tooltip!
+
+        // Remember that we're showing a tooltip
+        self.ctx
+            .data_mut(|data| data.insert_temp::<f64>(when_was_a_toolip_last_shown_id, now));
+
         true
     }
 
diff --git a/crates/egui/src/style.rs b/crates/egui/src/style.rs
index d2d7ce99188..fd1c13a8aab 100644
--- a/crates/egui/src/style.rs
+++ b/crates/egui/src/style.rs
@@ -182,15 +182,25 @@ pub struct Style {
     /// The style to use for [`DragValue`] text.
     pub drag_value_text_style: TextStyle,
 
-    /// If set, labels buttons wtc will use this to determine whether or not
-    /// to wrap the text at the right edge of the [`Ui`] they are in.
-    /// By default this is `None`.
+    /// If set, labels, buttons, etc. will use this to determine whether to wrap the text at the
+    /// right edge of the [`Ui`] they are in. By default, this is `None`.
     ///
-    /// * `None`: follow layout
-    /// * `Some(true)`: default on
-    /// * `Some(false)`: default off
+    /// **Note**: this API is deprecated, use `wrap_mode` instead.
+    ///
+    /// * `None`: use `wrap_mode` instead
+    /// * `Some(true)`: wrap mode defaults to [`crate::TextWrapMode::Wrap`]
+    /// * `Some(false)`: wrap mode defaults to [`crate::TextWrapMode::Extend`]
+    #[deprecated = "Use wrap_mode instead"]
     pub wrap: Option<bool>,
 
+    /// If set, labels, buttons, etc. will use this to determine whether to wrap or truncate the
+    /// text at the right edge of the [`Ui`] they are in, or to extend it. By default, this is
+    /// `None`.
+    ///
+    /// * `None`: follow layout (with may wrap)
+    /// * `Some(mode)`: use the specified mode as default
+    pub wrap_mode: Option<crate::TextWrapMode>,
+
     /// Sizes and distances between widgets
     pub spacing: Spacing,
 
@@ -222,7 +232,7 @@ pub struct Style {
 }
 
 impl Style {
-    // TODO(emilk): rename style.interact() to maybe... `style.interactive` ?
+    // TODO(emilk): rename style.interact() to maybe… `style.interactive` ?
     /// Use this style for interactive things.
     /// Note that you must already have a response,
     /// i.e. you must allocate space and interact BEFORE painting the widget!
@@ -306,10 +316,21 @@ pub struct Spacing {
     /// This is the spacing between the icon and the text
     pub icon_spacing: f32,
 
+    /// The size used for the [`Ui::max_rect`] the first frame.
+    ///
+    /// Text will wrap at this width, and images that expand to fill the available space
+    /// will expand to this size.
+    ///
+    /// If the contents are smaller than this size, the area will shrink to fit the contents.
+    /// If the contents overflow, the area will grow.
+    pub default_area_size: Vec2,
+
     /// Width of a tooltip (`on_hover_ui`, `on_hover_text` etc).
     pub tooltip_width: f32,
 
-    /// The default width of a menu.
+    /// The default wrapping width of a menu.
+    ///
+    /// Items longer than this will wrap to a new line.
     pub menu_width: f32,
 
     /// Horizontal distance between a menu and a submenu.
@@ -637,6 +658,13 @@ pub struct Interaction {
     /// Delay in seconds before showing tooltips after the mouse stops moving
     pub tooltip_delay: f32,
 
+    /// If you have waited for a tooltip and then hover some other widget within
+    /// this many seconds, then show the new tooltip right away,
+    /// skipping [`Self::tooltip_delay`].
+    ///
+    /// This lets the user quickly move over some dead space to hover the next thing.
+    pub tooltip_grace_time: f32,
+
     /// Can you select the text on a [`crate::Label`] by default?
     pub selectable_labels: bool,
 
@@ -1026,12 +1054,14 @@ pub fn default_text_styles() -> BTreeMap<TextStyle, FontId> {
 
 impl Default for Style {
     fn default() -> Self {
+        #[allow(deprecated)]
         Self {
             override_font_id: None,
             override_text_style: None,
             text_styles: default_text_styles(),
             drag_value_text_style: TextStyle::Button,
             wrap: None,
+            wrap_mode: None,
             spacing: Spacing::default(),
             interaction: Interaction::default(),
             visuals: Visuals::default(),
@@ -1061,8 +1091,9 @@ impl Default for Spacing {
             icon_width: 14.0,
             icon_width_inner: 8.0,
             icon_spacing: 4.0,
+            default_area_size: vec2(600.0, 400.0),
             tooltip_width: 600.0,
-            menu_width: 150.0,
+            menu_width: 400.0,
             menu_spacing: 2.0,
             combo_height: 200.0,
             scroll: Default::default(),
@@ -1078,7 +1109,8 @@ impl Default for Interaction {
             resize_grab_radius_corner: 10.0,
             interact_radius: 5.0,
             show_tooltips_only_when_still: true,
-            tooltip_delay: 0.3,
+            tooltip_delay: 0.5,
+            tooltip_grace_time: 0.2,
             selectable_labels: true,
             multi_widget_text_select: true,
         }
@@ -1317,12 +1349,14 @@ use crate::{widgets::*, Ui};
 
 impl Style {
     pub fn ui(&mut self, ui: &mut crate::Ui) {
+        #[allow(deprecated)]
         let Self {
             override_font_id,
             override_text_style,
             text_styles,
             drag_value_text_style,
             wrap: _,
+            wrap_mode: _,
             spacing,
             interaction,
             visuals,
@@ -1445,6 +1479,7 @@ impl Spacing {
             icon_width,
             icon_width_inner,
             icon_spacing,
+            default_area_size,
             tooltip_width,
             menu_width,
             menu_spacing,
@@ -1495,6 +1530,10 @@ impl Spacing {
                 ui.add(DragValue::new(combo_width).clamp_range(0.0..=1000.0));
                 ui.end_row();
 
+                ui.label("Default area size");
+                ui.add(two_drag_values(default_area_size, 0.0..=1000.0));
+                ui.end_row();
+
                 ui.label("TextEdit width");
                 ui.add(DragValue::new(text_edit_width).clamp_range(0.0..=1000.0));
                 ui.end_row();
@@ -1559,6 +1598,7 @@ impl Interaction {
             resize_grab_radius_corner,
             show_tooltips_only_when_still,
             tooltip_delay,
+            tooltip_grace_time,
             selectable_labels,
             multi_widget_text_select,
         } = self;
@@ -1592,6 +1632,17 @@ impl Interaction {
                         .suffix(" s"),
                 );
                 ui.end_row();
+
+                ui.label("Tooltip grace time").on_hover_text(
+                    "If a tooltip is open and you hover another widget within this grace period, show the next tooltip right away",
+                );
+                ui.add(
+                    DragValue::new(tooltip_grace_time)
+                        .clamp_range(0.0..=1.0)
+                        .speed(0.05)
+                        .suffix(" s"),
+                );
+                ui.end_row();
             });
 
         ui.checkbox(
diff --git a/crates/egui/src/ui.rs b/crates/egui/src/ui.rs
index 00b7beef6e4..94cfb638b01 100644
--- a/crates/egui/src/ui.rs
+++ b/crates/egui/src/ui.rs
@@ -61,6 +61,10 @@ pub struct Ui {
     /// and all widgets will assume a gray style.
     enabled: bool,
 
+    /// Set to true in special cases where we do one frame
+    /// where we size up the contents of the Ui, without actually showing it.
+    sizing_pass: bool,
+
     /// Indicates whether this Ui belongs to a Menu.
     menu_state: Option<Arc<RwLock<MenuState>>>,
 }
@@ -82,6 +86,7 @@ impl Ui {
             style,
             placer: Placer::new(max_rect, Layout::default()),
             enabled: true,
+            sizing_pass: false,
             menu_state: None,
         };
 
@@ -108,9 +113,18 @@ impl Ui {
     pub fn child_ui_with_id_source(
         &mut self,
         max_rect: Rect,
-        layout: Layout,
+        mut layout: Layout,
         id_source: impl Hash,
     ) -> Self {
+        if self.sizing_pass {
+            // During the sizing pass we want widgets to use up as little space as possible,
+            // so that we measure the only the space we _need_.
+            layout.cross_justify = false;
+            if layout.cross_align == Align::Center {
+                layout.cross_align = Align::Min;
+            }
+        }
+
         debug_assert!(!max_rect.any_nan());
         let next_auto_id_source = Id::new(self.next_auto_id_source).with("child").value();
         self.next_auto_id_source = self.next_auto_id_source.wrapping_add(1);
@@ -121,6 +135,7 @@ impl Ui {
             style: self.style.clone(),
             placer: Placer::new(max_rect, layout),
             enabled: self.enabled,
+            sizing_pass: self.sizing_pass,
             menu_state: self.menu_state.clone(),
         };
 
@@ -140,6 +155,26 @@ impl Ui {
 
     // -------------------------------------------------
 
+    /// Set to true in special cases where we do one frame
+    /// where we size up the contents of the Ui, without actually showing it.
+    ///
+    /// This will also turn the Ui invisible.
+    /// Should be called right after [`Self::new`], if at all.
+    #[inline]
+    pub fn set_sizing_pass(&mut self) {
+        self.sizing_pass = true;
+        self.set_visible(false);
+    }
+
+    /// Set to true in special cases where we do one frame
+    /// where we size up the contents of the Ui, without actually showing it.
+    #[inline]
+    pub fn is_sizing_pass(&self) -> bool {
+        self.sizing_pass
+    }
+
+    // -------------------------------------------------
+
     /// A unique identity of this [`Ui`].
     #[inline]
     pub fn id(&self) -> Id {
@@ -306,7 +341,7 @@ impl Ui {
     /// Make the widget in this [`Ui`] semi-transparent.
     ///
     /// `opacity` must be between 0.0 and 1.0, where 0.0 means fully transparent (i.e., invisible)
-    /// and 1.0 means fully opaque (i.e., the same as not calling the method at all).
+    /// and 1.0 means fully opaque.
     ///
     /// ### Example
     /// ```
@@ -319,30 +354,72 @@ impl Ui {
     /// });
     /// # });
     /// ```
+    ///
+    /// See also: [`Self::opacity`] and [`Self::multiply_opacity`].
     pub fn set_opacity(&mut self, opacity: f32) {
         self.painter.set_opacity(opacity);
     }
 
+    /// Like [`Self::set_opacity`], but multiplies the given value with the current opacity.
+    ///
+    /// See also: [`Self::set_opacity`] and [`Self::opacity`].
+    pub fn multiply_opacity(&mut self, opacity: f32) {
+        self.painter.multiply_opacity(opacity);
+    }
+
+    /// Read the current opacity of the underlying painter.
+    ///
+    /// See also: [`Self::set_opacity`] and [`Self::multiply_opacity`].
+    #[inline]
+    pub fn opacity(&self) -> f32 {
+        self.painter.opacity()
+    }
+
     /// Read the [`Layout`].
     #[inline]
     pub fn layout(&self) -> &Layout {
         self.placer.layout()
     }
 
-    /// Should text wrap in this [`Ui`]?
+    /// Which wrap mode should the text use in this [`Ui`]?
     ///
-    /// This is determined first by [`Style::wrap`], and then by the layout of this [`Ui`].
-    pub fn wrap_text(&self) -> bool {
-        if let Some(wrap) = self.style.wrap {
-            wrap
+    /// This is determined first by [`Style::wrap_mode`], and then by the layout of this [`Ui`].
+    pub fn wrap_mode(&self) -> TextWrapMode {
+        #[allow(deprecated)]
+        if let Some(wrap_mode) = self.style.wrap_mode {
+            wrap_mode
+        }
+        // `wrap` handling for backward compatibility
+        else if let Some(wrap) = self.style.wrap {
+            if wrap {
+                TextWrapMode::Wrap
+            } else {
+                TextWrapMode::Extend
+            }
         } else if let Some(grid) = self.placer.grid() {
-            grid.wrap_text()
+            if grid.wrap_text() {
+                TextWrapMode::Wrap
+            } else {
+                TextWrapMode::Extend
+            }
         } else {
             let layout = self.layout();
-            layout.is_vertical() || layout.is_horizontal() && layout.main_wrap()
+            if layout.is_vertical() || layout.is_horizontal() && layout.main_wrap() {
+                TextWrapMode::Wrap
+            } else {
+                TextWrapMode::Extend
+            }
         }
     }
 
+    /// Should text wrap in this [`Ui`]?
+    ///
+    /// This is determined first by [`Style::wrap_mode`], and then by the layout of this [`Ui`].
+    #[deprecated = "Use `wrap_mode` instead"]
+    pub fn wrap_text(&self) -> bool {
+        self.wrap_mode() == TextWrapMode::Wrap
+    }
+
     /// Create a painter for a sub-region of this Ui.
     ///
     /// The clip-rect of the returned [`Painter`] will be the intersection
@@ -1075,6 +1152,8 @@ impl Ui {
     /// 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.
     ///
+    /// If this is called multiple times per frame for the same [`ScrollArea`], the deltas will be summed.
+    ///
     /// /// See also: [`Response::scroll_to_me`], [`Ui::scroll_to_rect`], [`Ui::scroll_to_cursor`]
     ///
     /// ```
@@ -1093,8 +1172,9 @@ impl Ui {
     /// # });
     /// ```
     pub fn scroll_with_delta(&self, delta: Vec2) {
-        self.ctx()
-            .input_mut(|input| input.smooth_scroll_delta += delta);
+        self.ctx().frame_state_mut(|state| {
+            state.scroll_delta += delta;
+        });
     }
 }
 
diff --git a/crates/egui/src/widget_text.rs b/crates/egui/src/widget_text.rs
index 57643ae4576..29d59ff18d8 100644
--- a/crates/egui/src/widget_text.rs
+++ b/crates/egui/src/widget_text.rs
@@ -1,8 +1,8 @@
 use std::{borrow::Cow, sync::Arc};
 
 use crate::{
-    text::LayoutJob, Align, Color32, FontFamily, FontSelection, Galley, Style, TextStyle, Ui,
-    Visuals,
+    text::{LayoutJob, TextWrapping},
+    Align, Color32, FontFamily, FontSelection, Galley, Style, TextStyle, TextWrapMode, Ui, Visuals,
 };
 
 /// Text and optional style choices for it.
@@ -640,47 +640,39 @@ impl WidgetText {
 
     /// Layout with wrap mode based on the containing [`Ui`].
     ///
-    /// wrap: override for [`Ui::wrap_text`].
+    /// `wrap_mode`: override for [`Ui::wrap_mode`]
     pub fn into_galley(
         self,
         ui: &Ui,
-        wrap: Option<bool>,
+        wrap_mode: Option<TextWrapMode>,
         available_width: f32,
         fallback_font: impl Into<FontSelection>,
     ) -> Arc<Galley> {
-        let wrap = wrap.unwrap_or_else(|| ui.wrap_text());
         let valign = ui.layout().vertical_align();
         let style = ui.style();
 
-        self.into_galley_impl(
-            ui.ctx(),
-            style,
-            wrap,
-            available_width,
-            fallback_font.into(),
-            valign,
-        )
+        let wrap_mode = wrap_mode.unwrap_or_else(|| ui.wrap_mode());
+        let text_wrapping = TextWrapping::from_wrap_mode_and_width(wrap_mode, available_width);
+
+        self.into_galley_impl(ui.ctx(), style, text_wrapping, fallback_font.into(), valign)
     }
 
     pub fn into_galley_impl(
         self,
         ctx: &crate::Context,
         style: &Style,
-        wrap: bool,
-        available_width: f32,
+        text_wrapping: TextWrapping,
         fallback_font: FontSelection,
         default_valign: Align,
     ) -> Arc<Galley> {
-        let wrap_width = if wrap { available_width } else { f32::INFINITY };
-
         match self {
             Self::RichText(text) => {
                 let mut layout_job = text.into_layout_job(style, fallback_font, default_valign);
-                layout_job.wrap.max_width = wrap_width;
+                layout_job.wrap = text_wrapping;
                 ctx.fonts(|f| f.layout_job(layout_job))
             }
             Self::LayoutJob(mut job) => {
-                job.wrap.max_width = wrap_width;
+                job.wrap = text_wrapping;
                 ctx.fonts(|f| f.layout_job(job))
             }
             Self::Galley(galley) => galley,
diff --git a/crates/egui/src/widgets/button.rs b/crates/egui/src/widgets/button.rs
index 76a62125045..a2b29327b04 100644
--- a/crates/egui/src/widgets/button.rs
+++ b/crates/egui/src/widgets/button.rs
@@ -23,7 +23,7 @@ pub struct Button<'a> {
     image: Option<Image<'a>>,
     text: Option<WidgetText>,
     shortcut_text: WidgetText,
-    wrap: Option<bool>,
+    wrap_mode: Option<TextWrapMode>,
 
     /// None means default for interact
     fill: Option<Color32>,
@@ -58,7 +58,7 @@ impl<'a> Button<'a> {
             text,
             image,
             shortcut_text: Default::default(),
-            wrap: None,
+            wrap_mode: None,
             fill: None,
             stroke: None,
             sense: Sense::click(),
@@ -70,16 +70,29 @@ impl<'a> Button<'a> {
         }
     }
 
-    /// If `true`, the text will wrap to stay within the max width of the [`Ui`].
+    /// Set the wrap mode for the text.
     ///
-    /// By default [`Self::wrap`] will be true in vertical layouts
-    /// and horizontal layouts with wrapping,
-    /// and false on non-wrapping horizontal layouts.
+    /// By default, [`Ui::wrap_mode`] will be used, which can be overridden with [`Style::wrap_mode`].
     ///
     /// Note that any `\n` in the text will always produce a new line.
     #[inline]
-    pub fn wrap(mut self, wrap: bool) -> Self {
-        self.wrap = Some(wrap);
+    pub fn wrap_mode(mut self, wrap_mode: TextWrapMode) -> Self {
+        self.wrap_mode = Some(wrap_mode);
+        self
+    }
+
+    /// Set [`Self::wrap_mode`] to [`TextWrapMode::Wrap`].
+    #[inline]
+    pub fn wrap(mut self) -> Self {
+        self.wrap_mode = Some(TextWrapMode::Wrap);
+
+        self
+    }
+
+    /// Set [`Self::wrap_mode`] to [`TextWrapMode::Truncate`].
+    #[inline]
+    pub fn truncate(mut self) -> Self {
+        self.wrap_mode = Some(TextWrapMode::Truncate);
         self
     }
 
@@ -165,7 +178,7 @@ impl Widget for Button<'_> {
             text,
             image,
             shortcut_text,
-            wrap,
+            wrap_mode,
             fill,
             stroke,
             sense,
@@ -202,18 +215,30 @@ impl Widget for Button<'_> {
             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;
         }
-        if !shortcut_text.is_empty() {
-            text_wrap_width -= 60.0; // Some space for the shortcut text (which we never wrap).
+
+        // 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, text_wrap_width, TextStyle::Button));
-        let shortcut_galley = (!shortcut_text.is_empty())
-            .then(|| shortcut_text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button));
+            text.map(|text| text.into_galley(ui, wrap_mode, text_wrap_width, TextStyle::Button));
 
         let mut desired_size = Vec2::ZERO;
         if image.is_some() {
@@ -227,9 +252,9 @@ impl Widget for Button<'_> {
             desired_size.x += text.size().x;
             desired_size.y = desired_size.y.max(text.size().y);
         }
-        if let Some(shortcut_text) = &shortcut_galley {
-            desired_size.x += ui.spacing().item_spacing.x + shortcut_text.size().x;
-            desired_size.y = desired_size.y.max(shortcut_text.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 {
diff --git a/crates/egui/src/widgets/color_picker.rs b/crates/egui/src/widgets/color_picker.rs
index 6935de4536d..f7efa0bd9da 100644
--- a/crates/egui/src/widgets/color_picker.rs
+++ b/crates/egui/src/widgets/color_picker.rs
@@ -491,7 +491,6 @@ pub fn color_edit_button_hsva(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> Res
         let area_response = Area::new(popup_id)
             .order(Order::Foreground)
             .fixed_pos(button_response.rect.max)
-            .constrain(true)
             .show(ui.ctx(), |ui| {
                 ui.spacing_mut().slider_width = COLOR_SLIDER_WIDTH;
                 Frame::popup(ui.style()).show(ui, |ui| {
diff --git a/crates/egui/src/widgets/drag_value.rs b/crates/egui/src/widgets/drag_value.rs
index 8a7f19028b6..70b957ec151 100644
--- a/crates/egui/src/widgets/drag_value.rs
+++ b/crates/egui/src/widgets/drag_value.rs
@@ -521,7 +521,7 @@ impl<'a> Widget for DragValue<'a> {
                 RichText::new(format!("{}{}{}", prefix, value_text.clone(), suffix))
                     .text_style(text_style),
             )
-            .wrap(false)
+            .wrap_mode(TextWrapMode::Extend)
             .sense(Sense::click_and_drag())
             .min_size(ui.spacing().interact_size); // TODO(emilk): find some more generic solution to `min_size`
 
diff --git a/crates/egui/src/widgets/label.rs b/crates/egui/src/widgets/label.rs
index f09a17baeb2..de6cc98dfe2 100644
--- a/crates/egui/src/widgets/label.rs
+++ b/crates/egui/src/widgets/label.rs
@@ -9,10 +9,11 @@ use self::text_selection::LabelSelectionState;
 /// Usually it is more convenient to use [`Ui::label`].
 ///
 /// ```
+/// # use egui::TextWrapMode;
 /// # egui::__run_test_ui(|ui| {
 /// ui.label("Equivalent");
 /// ui.add(egui::Label::new("Equivalent"));
-/// ui.add(egui::Label::new("With Options").wrap(false));
+/// ui.add(egui::Label::new("With Options").truncate());
 /// ui.label(egui::RichText::new("With formatting").underline());
 /// # });
 /// ```
@@ -22,8 +23,7 @@ use self::text_selection::LabelSelectionState;
 #[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
 pub struct Label {
     text: WidgetText,
-    wrap: Option<bool>,
-    truncate: bool,
+    wrap_mode: Option<TextWrapMode>,
     sense: Option<Sense>,
     selectable: Option<bool>,
 }
@@ -32,8 +32,7 @@ impl Label {
     pub fn new(text: impl Into<WidgetText>) -> Self {
         Self {
             text: text.into(),
-            wrap: None,
-            truncate: false,
+            wrap_mode: None,
             sense: None,
             selectable: None,
         }
@@ -43,37 +42,29 @@ impl Label {
         self.text.text()
     }
 
-    /// If `true`, the text will wrap to stay within the max width of the [`Ui`].
+    /// Set the wrap mode for the text.
     ///
-    /// Calling `wrap` will override [`Self::truncate`].
-    ///
-    /// By default [`Self::wrap`] will be `true` in vertical layouts
-    /// and horizontal layouts with wrapping,
-    /// and `false` on non-wrapping horizontal layouts.
+    /// By default, [`Ui::wrap_mode`] will be used, which can be overridden with [`Style::wrap_mode`].
     ///
     /// Note that any `\n` in the text will always produce a new line.
-    ///
-    /// You can also use [`crate::Style::wrap`].
     #[inline]
-    pub fn wrap(mut self, wrap: bool) -> Self {
-        self.wrap = Some(wrap);
-        self.truncate = false;
+    pub fn wrap_mode(mut self, wrap_mode: TextWrapMode) -> Self {
+        self.wrap_mode = Some(wrap_mode);
         self
     }
 
-    /// If `true`, the text will stop at the max width of the [`Ui`],
-    /// and what doesn't fit will be elided, replaced with `…`.
-    ///
-    /// If the text is truncated, the full text will be shown on hover as a tool-tip.
-    ///
-    /// Default is `false`, which means the text will expand the parent [`Ui`],
-    /// or wrap if [`Self::wrap`] is set.
-    ///
-    /// Calling `truncate` will override [`Self::wrap`].
+    /// Set [`Self::wrap_mode`] to [`TextWrapMode::Wrap`].
+    #[inline]
+    pub fn wrap(mut self) -> Self {
+        self.wrap_mode = Some(TextWrapMode::Wrap);
+
+        self
+    }
+
+    /// Set [`Self::wrap_mode`] to [`TextWrapMode::Truncate`].
     #[inline]
-    pub fn truncate(mut self, truncate: bool) -> Self {
-        self.wrap = None;
-        self.truncate = truncate;
+    pub fn truncate(mut self) -> Self {
+        self.wrap_mode = Some(TextWrapMode::Truncate);
         self
     }
 
@@ -156,11 +147,10 @@ impl Label {
             .text
             .into_layout_job(ui.style(), FontSelection::Default, valign);
 
-        let truncate = self.truncate;
-        let wrap = !truncate && self.wrap.unwrap_or_else(|| ui.wrap_text());
         let available_width = ui.available_width();
 
-        if wrap
+        let wrap_mode = self.wrap_mode.unwrap_or_else(|| ui.wrap_mode());
+        if wrap_mode == TextWrapMode::Wrap
             && ui.layout().main_dir() == Direction::LeftToRight
             && ui.layout().main_wrap()
             && available_width.is_finite()
@@ -192,15 +182,8 @@ impl Label {
             }
             (pos, galley, response)
         } else {
-            if truncate {
-                layout_job.wrap.max_width = available_width;
-                layout_job.wrap.max_rows = 1;
-                layout_job.wrap.break_anywhere = true;
-            } else if wrap {
-                layout_job.wrap.max_width = available_width;
-            } else {
-                layout_job.wrap.max_width = f32::INFINITY;
-            };
+            layout_job.wrap =
+                text::TextWrapping::from_wrap_mode_and_width(wrap_mode, available_width);
 
             if ui.is_grid() {
                 // TODO(emilk): remove special Grid hacks like these
diff --git a/crates/egui/src/widgets/mod.rs b/crates/egui/src/widgets/mod.rs
index 0ab9273c7a5..86bfbc7c213 100644
--- a/crates/egui/src/widgets/mod.rs
+++ b/crates/egui/src/widgets/mod.rs
@@ -91,7 +91,7 @@ where
     }
 }
 
-/// Helper so that you can do `TextEdit::State::read…`
+/// Helper so that you can do e.g. `TextEdit::State::load`.
 pub trait WidgetWithState {
     type State;
 }
diff --git a/crates/egui/src/widgets/progress_bar.rs b/crates/egui/src/widgets/progress_bar.rs
index 99c768bf9af..5f5d2170969 100644
--- a/crates/egui/src/widgets/progress_bar.rs
+++ b/crates/egui/src/widgets/progress_bar.rs
@@ -183,7 +183,12 @@ impl Widget for ProgressBar {
                         format!("{}%", (progress * 100.0) as usize).into()
                     }
                 };
-                let galley = text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button);
+                let galley = text.into_galley(
+                    ui,
+                    Some(TextWrapMode::Extend),
+                    f32::INFINITY,
+                    TextStyle::Button,
+                );
                 let text_pos = outer_rect.left_center() - Vec2::new(0.0, galley.size().y / 2.0)
                     + vec2(ui.spacing().item_spacing.x, 0.0);
                 let text_color = visuals
diff --git a/crates/egui/src/widgets/separator.rs b/crates/egui/src/widgets/separator.rs
index 83c01f31200..f408c6fb0c5 100644
--- a/crates/egui/src/widgets/separator.rs
+++ b/crates/egui/src/widgets/separator.rs
@@ -96,7 +96,11 @@ impl Widget for Separator {
         let is_horizontal_line = is_horizontal_line
             .unwrap_or_else(|| ui.is_grid() || !ui.layout().main_dir().is_horizontal());
 
-        let available_space = ui.available_size_before_wrap();
+        let available_space = if ui.is_sizing_pass() {
+            Vec2::ZERO
+        } else {
+            ui.available_size_before_wrap()
+        };
 
         let size = if is_horizontal_line {
             vec2(available_space.x, spacing)
diff --git a/crates/egui/src/widgets/slider.rs b/crates/egui/src/widgets/slider.rs
index 644694cbe81..61aa56b8548 100644
--- a/crates/egui/src/widgets/slider.rs
+++ b/crates/egui/src/widgets/slider.rs
@@ -904,7 +904,8 @@ impl<'a> Slider<'a> {
         };
 
         if !self.text.is_empty() {
-            let label_response = ui.add(Label::new(self.text.clone()).wrap(false));
+            let label_response =
+                ui.add(Label::new(self.text.clone()).wrap_mode(TextWrapMode::Extend));
             // The slider already has an accessibility label via widget info,
             // but sometimes it's useful for a screen reader to know
             // that a piece of text is a label for another widget,
diff --git a/crates/egui/src/widgets/text_edit/builder.rs b/crates/egui/src/widgets/text_edit/builder.rs
index 440916f31b2..164f928bbf0 100644
--- a/crates/egui/src/widgets/text_edit/builder.rs
+++ b/crates/egui/src/widgets/text_edit/builder.rs
@@ -60,6 +60,7 @@ use super::{TextEditOutput, TextEditState};
 pub struct TextEdit<'t> {
     text: &'t mut dyn TextBuffer,
     hint_text: WidgetText,
+    hint_text_font: Option<FontSelection>,
     id: Option<Id>,
     id_source: Option<Id>,
     font_selection: FontSelection,
@@ -78,7 +79,7 @@ pub struct TextEdit<'t> {
     align: Align2,
     clip_text: bool,
     char_limit: usize,
-    return_key: KeyboardShortcut,
+    return_key: Option<KeyboardShortcut>,
 }
 
 impl<'t> WidgetWithState for TextEdit<'t> {
@@ -111,6 +112,7 @@ impl<'t> TextEdit<'t> {
         Self {
             text,
             hint_text: Default::default(),
+            hint_text_font: None,
             id: None,
             id_source: None,
             font_selection: Default::default(),
@@ -135,7 +137,7 @@ impl<'t> TextEdit<'t> {
             align: Align2::LEFT_TOP,
             clip_text: false,
             char_limit: usize::MAX,
-            return_key: KeyboardShortcut::new(Modifiers::NONE, Key::Enter),
+            return_key: Some(KeyboardShortcut::new(Modifiers::NONE, Key::Enter)),
         }
     }
 
@@ -189,6 +191,13 @@ impl<'t> TextEdit<'t> {
         self
     }
 
+    /// Set a specific style for the hint text.
+    #[inline]
+    pub fn hint_text_font(mut self, hint_text_font: impl Into<FontSelection>) -> Self {
+        self.hint_text_font = Some(hint_text_font.into());
+        self
+    }
+
     /// If true, hide the letters from view and prevent copying from the field.
     #[inline]
     pub fn password(mut self, password: bool) -> Self {
@@ -353,9 +362,11 @@ impl<'t> TextEdit<'t> {
     ///
     /// This combination will cause a newline on multiline,
     /// whereas on singleline it will cause the widget to lose focus.
+    ///
+    /// This combination is optional and can be disabled by passing [`None`] into this function.
     #[inline]
-    pub fn return_key(mut self, return_key: KeyboardShortcut) -> Self {
-        self.return_key = return_key;
+    pub fn return_key(mut self, return_key: impl Into<Option<KeyboardShortcut>>) -> Self {
+        self.return_key = return_key.into();
         self
     }
 }
@@ -436,6 +447,7 @@ impl<'t> TextEdit<'t> {
         let TextEdit {
             text,
             hint_text,
+            hint_text_font,
             id,
             id_source,
             font_selection,
@@ -651,10 +663,21 @@ impl<'t> TextEdit<'t> {
 
             if text.as_str().is_empty() && !hint_text.is_empty() {
                 let hint_text_color = ui.visuals().weak_text_color();
+                let hint_text_font_id = hint_text_font.unwrap_or(font_id.into());
                 let galley = if multiline {
-                    hint_text.into_galley(ui, Some(true), desired_inner_size.x, font_id)
+                    hint_text.into_galley(
+                        ui,
+                        Some(TextWrapMode::Wrap),
+                        desired_inner_size.x,
+                        hint_text_font_id,
+                    )
                 } else {
-                    hint_text.into_galley(ui, Some(false), f32::INFINITY, font_id)
+                    hint_text.into_galley(
+                        ui,
+                        Some(TextWrapMode::Extend),
+                        f32::INFINITY,
+                        hint_text_font_id,
+                    )
                 };
                 painter.galley(rect.min, galley, hint_text_color);
             }
@@ -805,7 +828,7 @@ fn events(
     default_cursor_range: CursorRange,
     char_limit: usize,
     event_filter: EventFilter,
-    return_key: KeyboardShortcut,
+    return_key: Option<KeyboardShortcut>,
 ) -> (bool, CursorRange) {
     let os = ui.ctx().os();
 
@@ -892,8 +915,9 @@ fn events(
                 pressed: true,
                 modifiers,
                 ..
-            } if *key == return_key.logical_key
-                && modifiers.matches_logically(return_key.modifiers) =>
+            } if return_key.is_some_and(|return_key| {
+                *key == return_key.logical_key && modifiers.matches_logically(return_key.modifiers)
+            }) =>
             {
                 if multiline {
                     let mut ccursor = text.delete_selected(&cursor_range);
diff --git a/crates/egui_demo_app/Cargo.toml b/crates/egui_demo_app/Cargo.toml
index 87f787a054a..ec3190918fb 100644
--- a/crates/egui_demo_app/Cargo.toml
+++ b/crates/egui_demo_app/Cargo.toml
@@ -77,6 +77,6 @@ rfd = { version = "0.13", optional = true }
 
 # web:
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-wasm-bindgen = "=0.2.92"
+wasm-bindgen = "=0.2.90"
 wasm-bindgen-futures.workspace = true
 web-sys.workspace = true
diff --git a/crates/egui_demo_app/src/apps/custom3d_wgpu.rs b/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
index 95b3ee1a0af..1676a0ba70c 100644
--- a/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
+++ b/crates/egui_demo_app/src/apps/custom3d_wgpu.rs
@@ -49,13 +49,11 @@ impl Custom3d {
                 module: &shader,
                 entry_point: "vs_main",
                 buffers: &[],
-                compilation_options: wgpu::PipelineCompilationOptions::default(),
             },
             fragment: Some(wgpu::FragmentState {
                 module: &shader,
                 entry_point: "fs_main",
                 targets: &[Some(wgpu_render_state.target_format.into())],
-                compilation_options: wgpu::PipelineCompilationOptions::default(),
             }),
             primitive: wgpu::PrimitiveState::default(),
             depth_stencil: None,
diff --git a/crates/egui_demo_app/src/apps/image_viewer.rs b/crates/egui_demo_app/src/apps/image_viewer.rs
index cd834424aa2..ad7a8448640 100644
--- a/crates/egui_demo_app/src/apps/image_viewer.rs
+++ b/crates/egui_demo_app/src/apps/image_viewer.rs
@@ -184,6 +184,11 @@ impl eframe::App for ImageViewer {
             ui.add_space(5.0);
             ui.label("Aspect ratio is maintained by scaling both sides as necessary");
             ui.checkbox(&mut self.maintain_aspect_ratio, "Maintain aspect ratio");
+
+            // forget all images
+            if ui.button("Forget all images").clicked() {
+                ui.ctx().forget_all_images();
+            }
         });
 
         egui::CentralPanel::default().show(ctx, |ui| {
diff --git a/crates/egui_demo_app/src/backend_panel.rs b/crates/egui_demo_app/src/backend_panel.rs
index 2176d57a8b6..e50c6b29db1 100644
--- a/crates/egui_demo_app/src/backend_panel.rs
+++ b/crates/egui_demo_app/src/backend_panel.rs
@@ -154,10 +154,10 @@ impl BackendPanel {
                         .button("Wait 2s, then request repaint after another 3s")
                         .clicked()
                     {
-                        log::info!("Waiting 2s before requesting repaint...");
+                        log::info!("Waiting 2s before requesting repaint…");
                         let ctx = ui.ctx().clone();
                         call_after_delay(std::time::Duration::from_secs(2), move || {
-                            log::info!("Request a repaint in 3s...");
+                            log::info!("Request a repaint in 3s…");
                             ctx.request_repaint_after(std::time::Duration::from_secs(3));
                         });
                     }
@@ -180,7 +180,7 @@ fn integration_ui(ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
 
     #[cfg(target_arch = "wasm32")]
     ui.collapsing("Web info (location)", |ui| {
-        ui.style_mut().wrap = Some(false);
+        ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
         ui.monospace(format!("{:#?}", _frame.info().web_info.location));
     });
 
@@ -298,7 +298,7 @@ fn integration_ui(ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
 
             let mut size = None;
             egui::ComboBox::from_id_source("viewport-size-combo")
-                .selected_text("Resize to...")
+                .selected_text("Resize to…")
                 .show_ui(ui, |ui| {
                     ui.selectable_value(
                         &mut size,
diff --git a/crates/egui_demo_app/src/main.rs b/crates/egui_demo_app/src/main.rs
index 9d660ed046c..e30a73f22ea 100644
--- a/crates/egui_demo_app/src/main.rs
+++ b/crates/egui_demo_app/src/main.rs
@@ -48,7 +48,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "egui demo app",
         options,
-        Box::new(|cc| Box::new(egui_demo_app::WrapApp::new(cc))),
+        Box::new(|cc| Ok(Box::new(egui_demo_app::WrapApp::new(cc)))),
     )
 }
 
diff --git a/crates/egui_demo_app/src/web.rs b/crates/egui_demo_app/src/web.rs
index f4b9e5de15c..ce06399b27f 100644
--- a/crates/egui_demo_app/src/web.rs
+++ b/crates/egui_demo_app/src/web.rs
@@ -32,7 +32,7 @@ impl WebHandle {
             .start(
                 canvas_id,
                 eframe::WebOptions::default(),
-                Box::new(|cc| Box::new(WrapApp::new(cc))),
+                Box::new(|cc| Ok(Box::new(WrapApp::new(cc)))),
             )
             .await
     }
diff --git a/crates/egui_demo_lib/src/demo/context_menu.rs b/crates/egui_demo_lib/src/demo/context_menu.rs
index 5195a2b0609..86bd2f9d108 100644
--- a/crates/egui_demo_lib/src/demo/context_menu.rs
+++ b/crates/egui_demo_lib/src/demo/context_menu.rs
@@ -80,8 +80,6 @@ impl super::View for ContextMenus {
         ui.label("Right-click plot to edit it!");
         ui.horizontal(|ui| {
             self.example_plot(ui).context_menu(|ui| {
-                ui.set_min_width(220.0);
-
                 ui.menu_button("Plot", |ui| {
                     if ui.radio_value(&mut self.plot, Plot::Sin, "Sin").clicked()
                         || ui
@@ -158,24 +156,24 @@ impl ContextMenus {
     }
 
     fn nested_menus(ui: &mut egui::Ui) {
-        if ui.button("Open...").clicked() {
+        if ui.button("Open…").clicked() {
             ui.close_menu();
         }
         ui.menu_button("SubMenu", |ui| {
             ui.menu_button("SubMenu", |ui| {
-                if ui.button("Open...").clicked() {
+                if ui.button("Open…").clicked() {
                     ui.close_menu();
                 }
                 let _ = ui.button("Item");
             });
             ui.menu_button("SubMenu", |ui| {
-                if ui.button("Open...").clicked() {
+                if ui.button("Open…").clicked() {
                     ui.close_menu();
                 }
                 let _ = ui.button("Item");
             });
             let _ = ui.button("Item");
-            if ui.button("Open...").clicked() {
+            if ui.button("Open…").clicked() {
                 ui.close_menu();
             }
         });
@@ -184,10 +182,10 @@ impl ContextMenus {
             let _ = ui.button("Item2");
             let _ = ui.button("Item3");
             let _ = ui.button("Item4");
-            if ui.button("Open...").clicked() {
+            if ui.button("Open…").clicked() {
                 ui.close_menu();
             }
         });
-        let _ = ui.button("Very long text for this item");
+        let _ = ui.button("Very long text for this item that should be wrapped");
     }
 }
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 0910df4ef56..dc0e91f1b47 100644
--- a/crates/egui_demo_lib/src/demo/demo_app_windows.rs
+++ b/crates/egui_demo_lib/src/demo/demo_app_windows.rs
@@ -334,8 +334,7 @@ fn file_menu_button(ui: &mut Ui) {
     }
 
     ui.menu_button("File", |ui| {
-        ui.set_min_width(220.0);
-        ui.style_mut().wrap = Some(false);
+        ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
 
         // On the web the browser controls the zoom
         #[cfg(not(target_arch = "wasm32"))]
diff --git a/crates/egui_demo_lib/src/demo/frame_demo.rs b/crates/egui_demo_lib/src/demo/frame_demo.rs
index 0027a98d9da..bd1661827f9 100644
--- a/crates/egui_demo_lib/src/demo/frame_demo.rs
+++ b/crates/egui_demo_lib/src/demo/frame_demo.rs
@@ -60,7 +60,7 @@ impl super::View for FrameDemo {
                     .rounding(ui.visuals().widgets.noninteractive.rounding)
                     .show(ui, |ui| {
                         self.frame.show(ui, |ui| {
-                            ui.style_mut().wrap = Some(false);
+                            ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
                             ui.label(egui::RichText::new("Content").color(egui::Color32::WHITE));
                         });
                     });
diff --git a/crates/egui_demo_lib/src/demo/layout_test.rs b/crates/egui_demo_lib/src/demo/layout_test.rs
index a5726c7ab2f..2bc1fd0d4e9 100644
--- a/crates/egui_demo_lib/src/demo/layout_test.rs
+++ b/crates/egui_demo_lib/src/demo/layout_test.rs
@@ -176,7 +176,7 @@ impl LayoutTest {
 }
 
 fn demo_ui(ui: &mut Ui) {
-    ui.add(egui::Label::new("Wrapping text followed by example widgets:").wrap(true));
+    ui.add(egui::Label::new("Wrapping text followed by example widgets:").wrap());
     let mut dummy = false;
     ui.checkbox(&mut dummy, "checkbox");
     ui.radio_value(&mut dummy, false, "radio");
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 f3c7a8dcfec..6b73fe4048b 100644
--- a/crates/egui_demo_lib/src/demo/misc_demo_window.rs
+++ b/crates/egui_demo_lib/src/demo/misc_demo_window.rs
@@ -223,7 +223,7 @@ fn label_ui(ui: &mut egui::Ui) {
         egui::Label::new(
             "Labels containing long text can be set to elide the text that doesn't fit on a single line using `Label::elide`. When hovered, the label will show the full text.",
         )
-        .truncate(true),
+        .truncate(),
     );
 }
 
diff --git a/crates/egui_demo_lib/src/demo/pan_zoom.rs b/crates/egui_demo_lib/src/demo/pan_zoom.rs
index 40323346887..6ee75e3039a 100644
--- a/crates/egui_demo_lib/src/demo/pan_zoom.rs
+++ b/crates/egui_demo_lib/src/demo/pan_zoom.rs
@@ -1,4 +1,5 @@
 use egui::emath::TSTransform;
+use egui::TextWrapMode;
 
 #[derive(Clone, Default, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -122,7 +123,7 @@ impl super::View for PanZoom {
                         .stroke(ui.ctx().style().visuals.window_stroke)
                         .fill(ui.style().visuals.panel_fill)
                         .show(ui, |ui| {
-                            ui.style_mut().wrap = Some(false);
+                            ui.style_mut().wrap_mode = Some(TextWrapMode::Extend);
                             callback(ui, self)
                         });
                 })
diff --git a/crates/egui_demo_lib/src/demo/plot_demo.rs b/crates/egui_demo_lib/src/demo/plot_demo.rs
index 12e45aa0f09..17eceba1855 100644
--- a/crates/egui_demo_lib/src/demo/plot_demo.rs
+++ b/crates/egui_demo_lib/src/demo/plot_demo.rs
@@ -200,7 +200,7 @@ impl LineDemo {
             });
 
             ui.vertical(|ui| {
-                ui.style_mut().wrap = Some(false);
+                ui.style_mut().wrap_mode = Some(TextWrapMode::Extend);
                 ui.checkbox(animate, "Animate");
                 ui.checkbox(square, "Square view")
                     .on_hover_text("Always keep the viewport square.");
diff --git a/crates/egui_demo_lib/src/demo/scrolling.rs b/crates/egui_demo_lib/src/demo/scrolling.rs
index 9c490d23d8a..ec6ca5e1a98 100644
--- a/crates/egui_demo_lib/src/demo/scrolling.rs
+++ b/crates/egui_demo_lib/src/demo/scrolling.rs
@@ -82,7 +82,7 @@ impl super::View for Scrolling {
             }
             ScrollDemo::Bidirectional => {
                 egui::ScrollArea::both().show(ui, |ui| {
-                    ui.style_mut().wrap = Some(false);
+                    ui.style_mut().wrap_mode = Some(TextWrapMode::Extend);
                     for _ in 0..100 {
                         ui.label(crate::LOREM_IPSUM);
                     }
@@ -236,6 +236,7 @@ struct ScrollTo {
     track_item: usize,
     tack_item_align: Option<Align>,
     offset: f32,
+    delta: f32,
 }
 
 impl Default for ScrollTo {
@@ -244,6 +245,7 @@ impl Default for ScrollTo {
             track_item: 25,
             tack_item_align: Some(Align::Center),
             offset: 0.0,
+            delta: 64.0,
         }
     }
 }
@@ -258,6 +260,7 @@ impl super::View for ScrollTo {
         let mut go_to_scroll_offset = false;
         let mut scroll_top = false;
         let mut scroll_bottom = false;
+        let mut scroll_delta = None;
 
         ui.horizontal(|ui| {
             ui.label("Scroll to a specific item index:");
@@ -294,6 +297,20 @@ impl super::View for ScrollTo {
             scroll_bottom |= ui.button("Scroll to bottom").clicked();
         });
 
+        ui.horizontal(|ui| {
+            ui.label("Scroll by");
+            DragValue::new(&mut self.delta)
+                .speed(1.0)
+                .suffix("px")
+                .ui(ui);
+            if ui.button("⬇").clicked() {
+                scroll_delta = Some(self.delta * Vec2::UP); // scroll down (move contents up)
+            }
+            if ui.button("⬆").clicked() {
+                scroll_delta = Some(self.delta * Vec2::DOWN); // scroll up (move contents down)
+            }
+        });
+
         let mut scroll_area = ScrollArea::vertical().max_height(200.0).auto_shrink(false);
         if go_to_scroll_offset {
             scroll_area = scroll_area.vertical_scroll_offset(self.offset);
@@ -305,6 +322,10 @@ impl super::View for ScrollTo {
                 if scroll_top {
                     ui.scroll_to_cursor(Some(Align::TOP));
                 }
+                if let Some(scroll_delta) = scroll_delta {
+                    ui.scroll_with_delta(scroll_delta);
+                }
+
                 ui.vertical(|ui| {
                     for item in 1..=num_items {
                         if track_item && item == self.track_item {
diff --git a/crates/egui_demo_lib/src/demo/table_demo.rs b/crates/egui_demo_lib/src/demo/table_demo.rs
index c7029d44e49..ec6fa58c349 100644
--- a/crates/egui_demo_lib/src/demo/table_demo.rs
+++ b/crates/egui_demo_lib/src/demo/table_demo.rs
@@ -1,4 +1,4 @@
-use egui::TextStyle;
+use egui::{TextStyle, TextWrapMode};
 
 #[derive(PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -196,7 +196,7 @@ impl TableDemo {
                                 ui.label(long_text(row_index));
                             });
                             row.col(|ui| {
-                                ui.style_mut().wrap = Some(false);
+                                ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
                                 if is_thick {
                                     ui.heading("Extra thick row");
                                 } else {
@@ -227,7 +227,8 @@ impl TableDemo {
                         });
                         row.col(|ui| {
                             ui.add(
-                                egui::Label::new("Thousands of rows of even height").wrap(false),
+                                egui::Label::new("Thousands of rows of even height")
+                                    .wrap_mode(TextWrapMode::Extend),
                             );
                         });
 
@@ -253,7 +254,7 @@ impl TableDemo {
                             ui.label(long_text(row_index));
                         });
                         row.col(|ui| {
-                            ui.style_mut().wrap = Some(false);
+                            ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
                             if thick_row(row_index) {
                                 ui.heading("Extra thick row");
                             } else {
diff --git a/crates/egui_demo_lib/src/demo/widget_gallery.rs b/crates/egui_demo_lib/src/demo/widget_gallery.rs
index d68af17db80..0496d8963ef 100644
--- a/crates/egui_demo_lib/src/demo/widget_gallery.rs
+++ b/crates/egui_demo_lib/src/demo/widget_gallery.rs
@@ -63,7 +63,7 @@ impl super::View for WidgetGallery {
     fn ui(&mut self, ui: &mut egui::Ui) {
         ui.add_enabled_ui(self.enabled, |ui| {
             ui.set_visible(self.visible);
-            ui.set_opacity(self.opacity);
+            ui.multiply_opacity(self.opacity);
 
             egui::Grid::new("my_grid")
                 .num_columns(2)
@@ -172,8 +172,6 @@ impl WidgetGallery {
         egui::ComboBox::from_label("Take your pick")
             .selected_text(format!("{radio:?}"))
             .show_ui(ui, |ui| {
-                ui.style_mut().wrap = Some(false);
-                ui.set_min_width(60.0);
                 ui.selectable_value(radio, Enum::First, "First");
                 ui.selectable_value(radio, Enum::Second, "Second");
                 ui.selectable_value(radio, Enum::Third, "Third");
diff --git a/crates/egui_extras/Cargo.toml b/crates/egui_extras/Cargo.toml
index edbac462c94..b5d8efffac7 100644
--- a/crates/egui_extras/Cargo.toml
+++ b/crates/egui_extras/Cargo.toml
@@ -64,6 +64,7 @@ syntect = ["dep:syntect"]
 [dependencies]
 egui = { workspace = true, default-features = false, features = ["serde"] }
 
+ahash.workspace = true
 enum-map = { version = "2", features = ["serde"] }
 log.workspace = true
 serde.workspace = true
diff --git a/crates/egui_extras/src/datepicker/button.rs b/crates/egui_extras/src/datepicker/button.rs
index 839adebfc47..1a4dea82eb6 100644
--- a/crates/egui_extras/src/datepicker/button.rs
+++ b/crates/egui_extras/src/datepicker/button.rs
@@ -142,7 +142,6 @@ impl<'a> Widget for DatePickerButton<'a> {
             } = Area::new(ui.make_persistent_id(self.id_source))
                 .order(Order::Foreground)
                 .fixed_pos(pos)
-                .constrain_to(ui.ctx().screen_rect())
                 .show(ui.ctx(), |ui| {
                     let frame = Frame::popup(ui.style());
                     frame
diff --git a/crates/egui_extras/src/loaders/ehttp_loader.rs b/crates/egui_extras/src/loaders/ehttp_loader.rs
index 9aeb1b663ca..79c776948c3 100644
--- a/crates/egui_extras/src/loaders/ehttp_loader.rs
+++ b/crates/egui_extras/src/loaders/ehttp_loader.rs
@@ -1,5 +1,5 @@
+use ahash::HashMap;
 use egui::{
-    ahash::HashMap,
     load::{Bytes, BytesLoadResult, BytesLoader, BytesPoll, LoadError},
     mutex::Mutex,
 };
diff --git a/crates/egui_extras/src/loaders/file_loader.rs b/crates/egui_extras/src/loaders/file_loader.rs
index afa7d0eefd6..b90cff95754 100644
--- a/crates/egui_extras/src/loaders/file_loader.rs
+++ b/crates/egui_extras/src/loaders/file_loader.rs
@@ -1,5 +1,5 @@
+use ahash::HashMap;
 use egui::{
-    ahash::HashMap,
     load::{Bytes, BytesLoadResult, BytesLoader, BytesPoll, LoadError},
     mutex::Mutex,
 };
diff --git a/crates/egui_extras/src/loaders/image_loader.rs b/crates/egui_extras/src/loaders/image_loader.rs
index 19a91105a63..14086df935b 100644
--- a/crates/egui_extras/src/loaders/image_loader.rs
+++ b/crates/egui_extras/src/loaders/image_loader.rs
@@ -1,5 +1,5 @@
+use ahash::HashMap;
 use egui::{
-    ahash::HashMap,
     load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
     mutex::Mutex,
     ColorImage,
diff --git a/crates/egui_extras/src/loaders/svg_loader.rs b/crates/egui_extras/src/loaders/svg_loader.rs
index 1794a8724f4..67b59540c69 100644
--- a/crates/egui_extras/src/loaders/svg_loader.rs
+++ b/crates/egui_extras/src/loaders/svg_loader.rs
@@ -1,7 +1,8 @@
 use std::{mem::size_of, path::Path, sync::Arc};
 
+use ahash::HashMap;
+
 use egui::{
-    ahash::HashMap,
     load::{BytesPoll, ImageLoadResult, ImageLoader, ImagePoll, LoadError, SizeHint},
     mutex::Mutex,
     ColorImage,
diff --git a/crates/egui_glow/Cargo.toml b/crates/egui_glow/Cargo.toml
index 29129dddc3f..28de667e8c1 100644
--- a/crates/egui_glow/Cargo.toml
+++ b/crates/egui_glow/Cargo.toml
@@ -56,6 +56,7 @@ 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
diff --git a/crates/egui_glow/src/winit.rs b/crates/egui_glow/src/winit.rs
index 0c407ccb75d..5f981ab66d9 100644
--- a/crates/egui_glow/src/winit.rs
+++ b/crates/egui_glow/src/winit.rs
@@ -1,8 +1,8 @@
+use ahash::HashSet;
+use egui::{ViewportId, ViewportOutput};
 pub use egui_winit;
-pub use egui_winit::EventResponse;
-
-use egui::{ahash::HashSet, ViewportId, ViewportOutput};
 use egui_winit::winit;
+pub use egui_winit::EventResponse;
 
 use crate::shader_version::ShaderVersion;
 
diff --git a/crates/egui_plot/Cargo.toml b/crates/egui_plot/Cargo.toml
index bc42765ea16..17e45852242 100644
--- a/crates/egui_plot/Cargo.toml
+++ b/crates/egui_plot/Cargo.toml
@@ -37,6 +37,7 @@ serde = ["dep:serde", "egui/serde"]
 [dependencies]
 egui = { workspace = true, default-features = false }
 
+ahash.workspace = true
 
 #! ### Optional dependencies
 ## Enable this when generating docs.
diff --git a/crates/egui_plot/src/axis.rs b/crates/egui_plot/src/axis.rs
index 059349d6673..3827307a2ae 100644
--- a/crates/egui_plot/src/axis.rs
+++ b/crates/egui_plot/src/axis.rs
@@ -3,7 +3,7 @@ use std::{fmt::Debug, ops::RangeInclusive, sync::Arc};
 use egui::{
     emath::{remap_clamp, round_to_decimals, Rot2},
     epaint::TextShape,
-    Pos2, Rangef, Rect, Response, Sense, TextStyle, Ui, Vec2, WidgetText,
+    Pos2, Rangef, Rect, Response, Sense, TextStyle, TextWrapMode, Ui, Vec2, WidgetText,
 };
 
 use super::{transform::PlotTransform, GridMark};
@@ -264,7 +264,12 @@ impl<'a> AxisWidget<'a> {
 
         {
             let text = self.hints.label;
-            let galley = text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Body);
+            let galley = text.into_galley(
+                ui,
+                Some(TextWrapMode::Extend),
+                f32::INFINITY,
+                TextStyle::Body,
+            );
             let text_color = visuals
                 .override_text_color
                 .unwrap_or_else(|| ui.visuals().text_color());
diff --git a/crates/egui_plot/src/items/mod.rs b/crates/egui_plot/src/items/mod.rs
index 0470d955965..8e31c1fb610 100644
--- a/crates/egui_plot/src/items/mod.rs
+++ b/crates/egui_plot/src/items/mod.rs
@@ -850,10 +850,12 @@ impl PlotItem for Text {
             self.color
         };
 
-        let galley =
-            self.text
-                .clone()
-                .into_galley(ui, Some(false), f32::INFINITY, TextStyle::Small);
+        let galley = self.text.clone().into_galley(
+            ui,
+            Some(egui::TextWrapMode::Extend),
+            f32::INFINITY,
+            TextStyle::Small,
+        );
 
         let pos = transform.position_from_point(&self.position);
         let rect = self.anchor.anchor_size(pos, galley.size());
diff --git a/crates/egui_plot/src/items/values.rs b/crates/egui_plot/src/items/values.rs
index 6e9bff096b6..dbbb59bb41a 100644
--- a/crates/egui_plot/src/items/values.rs
+++ b/crates/egui_plot/src/items/values.rs
@@ -426,7 +426,7 @@ impl ExplicitGenerator {
 
 /// Result of [`super::PlotItem::find_closest()`] search, identifies an element inside the item for immediate use
 pub struct ClosestElem {
-    /// Position of hovered-over value (or bar/box-plot/...) in `PlotItem`
+    /// Position of hovered-over value (or bar/box-plot/…) in `PlotItem`
     pub index: usize,
 
     /// Squared distance from the mouse cursor (needed to compare against other `PlotItems`, which might be nearer)
diff --git a/crates/egui_plot/src/legend.rs b/crates/egui_plot/src/legend.rs
index a3b353e994c..538f2baf623 100644
--- a/crates/egui_plot/src/legend.rs
+++ b/crates/egui_plot/src/legend.rs
@@ -99,11 +99,11 @@ impl LegendEntry {
         }
     }
 
-    fn ui(&mut self, ui: &mut Ui, text: String, text_style: &TextStyle) -> Response {
+    fn ui(&self, ui: &mut Ui, text: String, text_style: &TextStyle) -> Response {
         let Self {
             color,
             checked,
-            hovered,
+            hovered: _,
         } = self;
 
         let font_id = text_style.resolve(ui.style());
@@ -162,9 +162,6 @@ impl LegendEntry {
         let text_position = pos2(text_position_x, rect.center().y - 0.5 * galley.size().y);
         painter.galley(text_position, galley, visuals.text_color());
 
-        *checked ^= response.clicked_by(PointerButton::Primary);
-        *hovered = response.hovered();
-
         response
     }
 }
@@ -267,14 +264,55 @@ impl Widget for &mut LegendWidget {
                 .multiply_with_opacity(config.background_alpha);
                 background_frame
                     .show(ui, |ui| {
-                        entries
+                        let mut focus_on_item = None;
+
+                        let response_union = entries
                             .iter_mut()
-                            .map(|(name, entry)| entry.ui(ui, name.clone(), &config.text_style))
+                            .map(|(name, entry)| {
+                                let response = entry.ui(ui, name.clone(), &config.text_style);
+
+                                // Handle interactions. Alt-clicking must be deferred to end of loop
+                                // since it may affect all entries.
+                                handle_interaction_on_legend_item(&response, entry);
+                                if response.clicked() && ui.input(|r| r.modifiers.alt) {
+                                    focus_on_item = Some(name.clone());
+                                }
+
+                                response
+                            })
                             .reduce(|r1, r2| r1.union(r2))
-                            .unwrap()
+                            .unwrap();
+
+                        if let Some(focus_on_item) = focus_on_item {
+                            handle_focus_on_legend_item(&focus_on_item, entries);
+                        }
+
+                        response_union
                     })
                     .inner
             })
             .inner
     }
 }
+
+/// Handle per-entry interactions.
+fn handle_interaction_on_legend_item(response: &Response, entry: &mut LegendEntry) {
+    entry.checked ^= response.clicked_by(PointerButton::Primary);
+    entry.hovered = response.hovered();
+}
+
+/// Handle alt-click interaction (which may affect all entries).
+fn handle_focus_on_legend_item(
+    clicked_entry_name: &str,
+    entries: &mut BTreeMap<String, LegendEntry>,
+) {
+    // if all other items are already hidden, we show everything
+    let is_focus_item_only_visible = entries
+        .iter()
+        .all(|(name, entry)| !entry.checked || (clicked_entry_name == name));
+
+    // either show everything or show only the focus item
+    for (name, entry) in entries.iter_mut() {
+        entry.checked = is_focus_item_only_visible || clicked_entry_name == name;
+    }
+}
diff --git a/crates/egui_plot/src/lib.rs b/crates/egui_plot/src/lib.rs
index 164710bef26..6dec9d7276d 100644
--- a/crates/egui_plot/src/lib.rs
+++ b/crates/egui_plot/src/lib.rs
@@ -15,7 +15,7 @@ mod transform;
 
 use std::{cmp::Ordering, ops::RangeInclusive, sync::Arc};
 
-use egui::ahash::HashMap;
+use ahash::HashMap;
 use egui::*;
 use emath::Float as _;
 use epaint::Hsva;
@@ -1666,7 +1666,7 @@ impl<'a> PreparedPlot<'a> {
             return (Vec::new(), None);
         }
 
-        let interact_radius_sq = (16.0_f32).powi(2);
+        let interact_radius_sq = ui.style().interaction.interact_radius.powi(2);
 
         let candidates = items
             .iter()
diff --git a/crates/egui_plot/src/memory.rs b/crates/egui_plot/src/memory.rs
index 6a982269f26..5e671865144 100644
--- a/crates/egui_plot/src/memory.rs
+++ b/crates/egui_plot/src/memory.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use egui::{ahash, Context, Id, Pos2, Vec2b};
+use egui::{Context, Id, Pos2, Vec2b};
 
 use crate::{PlotBounds, PlotTransform};
 
diff --git a/crates/emath/src/rect.rs b/crates/emath/src/rect.rs
index c1a7f603ecb..23d0428ac0a 100644
--- a/crates/emath/src/rect.rs
+++ b/crates/emath/src/rect.rs
@@ -608,6 +608,8 @@ impl Rect {
 
 impl Rect {
     /// Does this Rect intersect the given ray (where `d` is normalized)?
+    ///
+    /// A ray that starts inside the rect will return `true`.
     pub fn intersects_ray(&self, o: Pos2, d: Vec2) -> bool {
         let mut tmin = -f32::INFINITY;
         let mut tmax = f32::INFINITY;
@@ -628,7 +630,7 @@ impl Rect {
             tmax = tmax.min(ty1.max(ty2));
         }
 
-        tmin <= tmax
+        0.0 <= tmax && tmin <= tmax
     }
 }
 
@@ -710,4 +712,27 @@ mod tests {
         assert_eq!(r.distance_sq_to_pos(pos2(15.0, 25.0)), 25.0); // below
         assert_eq!(r.distance_sq_to_pos(pos2(25.0, 5.0)), 50.0); // right and above
     }
+
+    #[test]
+    fn test_ray_intersection() {
+        let rect = Rect::from_min_max(pos2(1.0, 1.0), pos2(3.0, 3.0));
+
+        eprintln!("Righward ray from left:");
+        assert!(rect.intersects_ray(pos2(0.0, 2.0), Vec2::RIGHT));
+
+        eprintln!("Righward ray from center:");
+        assert!(rect.intersects_ray(pos2(2.0, 2.0), Vec2::RIGHT));
+
+        eprintln!("Righward ray from right:");
+        assert!(!rect.intersects_ray(pos2(4.0, 2.0), Vec2::RIGHT));
+
+        eprintln!("Leftward ray from left:");
+        assert!(!rect.intersects_ray(pos2(0.0, 2.0), Vec2::LEFT));
+
+        eprintln!("Leftward ray from center:");
+        assert!(rect.intersects_ray(pos2(2.0, 2.0), Vec2::LEFT));
+
+        eprintln!("Leftward ray from right:");
+        assert!(rect.intersects_ray(pos2(4.0, 2.0), Vec2::LEFT));
+    }
 }
diff --git a/crates/emath/src/vec2.rs b/crates/emath/src/vec2.rs
index 99f7d0c05c7..29050935fda 100644
--- a/crates/emath/src/vec2.rs
+++ b/crates/emath/src/vec2.rs
@@ -131,6 +131,7 @@ impl Vec2 {
 
     pub const ZERO: Self = Self { x: 0.0, y: 0.0 };
     pub const INFINITY: Self = Self::splat(f32::INFINITY);
+    pub const NAN: Self = Self::splat(f32::NAN);
 
     #[inline(always)]
     pub const fn new(x: f32, y: f32) -> Self {
diff --git a/crates/epaint/src/shape_transform.rs b/crates/epaint/src/shape_transform.rs
index d0ab91536d1..3e976768d3f 100644
--- a/crates/epaint/src/shape_transform.rs
+++ b/crates/epaint/src/shape_transform.rs
@@ -10,22 +10,16 @@ pub fn adjust_colors(
     #![allow(clippy::match_same_arms)]
     match shape {
         Shape::Noop => {}
+
         Shape::Vec(shapes) => {
             for shape in shapes {
                 adjust_colors(shape, adjust_color);
             }
         }
-        Shape::LineSegment { stroke, points: _ } => match &stroke.color {
-            color::ColorMode::Solid(mut col) => adjust_color(&mut col),
-            color::ColorMode::UV(callback) => {
-                let callback = callback.clone();
-                stroke.color = color::ColorMode::UV(Arc::new(Box::new(move |rect, pos| {
-                    let mut col = callback(rect, pos);
-                    adjust_color(&mut col);
-                    col
-                })));
-            }
-        },
+
+        Shape::LineSegment { stroke, points: _ } => {
+            adjust_color_mode(&mut stroke.color, adjust_color);
+        }
 
         Shape::Path(PathShape {
             points: _,
@@ -46,17 +40,7 @@ pub fn adjust_colors(
             stroke,
         }) => {
             adjust_color(fill);
-            match &stroke.color {
-                color::ColorMode::Solid(mut col) => adjust_color(&mut col),
-                color::ColorMode::UV(callback) => {
-                    let callback = callback.clone();
-                    stroke.color = color::ColorMode::UV(Arc::new(Box::new(move |rect, pos| {
-                        let mut col = callback(rect, pos);
-                        adjust_color(&mut col);
-                        col
-                    })));
-                }
-            }
+            adjust_color_mode(&mut stroke.color, adjust_color);
         }
 
         Shape::Circle(CircleShape {
@@ -124,3 +108,20 @@ pub fn adjust_colors(
         }
     }
 }
+
+fn adjust_color_mode(
+    color_mode: &mut ColorMode,
+    adjust_color: impl Fn(&mut Color32) + Send + Sync + Copy + 'static,
+) {
+    match color_mode {
+        color::ColorMode::Solid(color) => adjust_color(color),
+        color::ColorMode::UV(callback) => {
+            let callback = callback.clone();
+            *color_mode = color::ColorMode::UV(Arc::new(Box::new(move |rect, pos| {
+                let mut color = callback(rect, pos);
+                adjust_color(&mut color);
+                color
+            })));
+        }
+    }
+}
diff --git a/crates/epaint/src/text/font.rs b/crates/epaint/src/text/font.rs
index 989698d7dac..7520c971a89 100644
--- a/crates/epaint/src/text/font.rs
+++ b/crates/epaint/src/text/font.rs
@@ -370,9 +370,11 @@ impl Font {
             .glyph_info_no_cache_or_fallback(PRIMARY_REPLACEMENT_CHAR)
             .or_else(|| slf.glyph_info_no_cache_or_fallback(FALLBACK_REPLACEMENT_CHAR))
             .unwrap_or_else(|| {
-                panic!(
-                    "Failed to find replacement characters {PRIMARY_REPLACEMENT_CHAR:?} or {FALLBACK_REPLACEMENT_CHAR:?}"
-                )
+                #[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;
 
diff --git a/crates/epaint/src/text/text_layout.rs b/crates/epaint/src/text/text_layout.rs
index 276f3f9e2a3..7f1cd865710 100644
--- a/crates/epaint/src/text/text_layout.rs
+++ b/crates/epaint/src/text/text_layout.rs
@@ -238,6 +238,12 @@ fn rows_from_paragraphs(
 }
 
 fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, elided: &mut bool) {
+    let wrap_width_margin = if job.round_output_size_to_nearest_ui_point {
+        0.5
+    } else {
+        0.0
+    };
+
     // Keeps track of good places to insert row break if we exceed `wrap_width`.
     let mut row_break_candidates = RowBreakCandidates::default();
 
@@ -253,7 +259,7 @@ fn line_break(paragraph: &Paragraph, job: &LayoutJob, out_rows: &mut Vec<Row>, e
 
         let potential_row_width = paragraph.glyphs[i].max_x() - row_start_x;
 
-        if job.wrap.max_width < potential_row_width {
+        if job.wrap.max_width + wrap_width_margin < potential_row_width {
             // Row break:
 
             if first_row_indentation > 0.0
@@ -630,7 +636,24 @@ fn galley_from_rows(
         num_indices += row.visuals.mesh.indices.len();
     }
 
-    let rect = Rect::from_min_max(pos2(min_x, 0.0), pos2(max_x, cursor_y));
+    let mut rect = Rect::from_min_max(pos2(min_x, 0.0), pos2(max_x, cursor_y));
+
+    if job.round_output_size_to_nearest_ui_point {
+        let did_exceed_wrap_width_by_a_lot = rect.width() > job.wrap.max_width + 1.0;
+
+        // We round the size to whole ui points here (not pixels!) so that the egui layout code
+        // can have the advantage of working in integer units, avoiding rounding errors.
+        rect.min = rect.min.round();
+        rect.max = rect.max.round();
+
+        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.
+        } else {
+            // Make sure we don't over the max wrap width the user picked:
+            rect.max.x = rect.max.x.at_most(rect.min.x + job.wrap.max_width);
+        }
+    }
 
     Galley {
         job,
diff --git a/crates/epaint/src/text/text_layout_types.rs b/crates/epaint/src/text/text_layout_types.rs
index dec2cb29057..fde36ec6a50 100644
--- a/crates/epaint/src/text/text_layout_types.rs
+++ b/crates/epaint/src/text/text_layout_types.rs
@@ -74,6 +74,10 @@ pub struct LayoutJob {
 
     /// Justify text so that word-wrapped rows fill the whole [`TextWrapping::max_width`].
     pub justify: bool,
+
+    /// Rounding to the closest ui point (not pixel!) allows the rest of the
+    /// layout code to run on perfect integers, avoiding rounding errors.
+    pub round_output_size_to_nearest_ui_point: bool,
 }
 
 impl Default for LayoutJob {
@@ -87,6 +91,7 @@ impl Default for LayoutJob {
             break_on_newline: true,
             halign: Align::LEFT,
             justify: false,
+            round_output_size_to_nearest_ui_point: true,
         }
     }
 }
@@ -180,6 +185,7 @@ impl std::hash::Hash for LayoutJob {
             break_on_newline,
             halign,
             justify,
+            round_output_size_to_nearest_ui_point,
         } = self;
 
         text.hash(state);
@@ -189,6 +195,7 @@ impl std::hash::Hash for LayoutJob {
         break_on_newline.hash(state);
         halign.hash(state);
         justify.hash(state);
+        round_output_size_to_nearest_ui_point.hash(state);
     }
 }
 
@@ -319,6 +326,24 @@ impl TextFormat {
 
 // ----------------------------------------------------------------------------
 
+/// How to wrap and elide text.
+///
+/// This enum is used in high-level APIs where providing a [`TextWrapping`] is too verbose.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum TextWrapMode {
+    /// The text should expand the `Ui` size when reaching its boundary.
+    Extend,
+
+    /// The text should wrap to the next line when reaching the `Ui` boundary.
+    Wrap,
+
+    /// The text should be elided using "…" when reaching the `Ui` boundary.
+    ///
+    /// Note that using [`TextWrapping`] and [`LayoutJob`] offers more control over the elision.
+    Truncate,
+}
+
 /// Controls the text wrapping and elision of a [`LayoutJob`].
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -335,7 +360,7 @@ pub struct TextWrapping {
 
     /// Maximum amount of rows the text galley should have.
     ///
-    /// If this limit is reached, text will be truncated and
+    /// If this limit is reached, text will be truncated
     /// and [`Self::overflow_character`] appended to the final row.
     /// You can detect this by checking [`Galley::elided`].
     ///
@@ -394,6 +419,15 @@ impl Default for TextWrapping {
 }
 
 impl TextWrapping {
+    /// Create a [`TextWrapping`] from a [`TextWrapMode`] and an available width.
+    pub fn from_wrap_mode_and_width(mode: TextWrapMode, max_width: f32) -> Self {
+        match mode {
+            TextWrapMode::Extend => Self::no_max_width(),
+            TextWrapMode::Wrap => Self::wrap_at_width(max_width),
+            TextWrapMode::Truncate => Self::truncate_at_width(max_width),
+        }
+    }
+
     /// A row can be as long as it need to be.
     pub fn no_max_width() -> Self {
         Self {
@@ -402,6 +436,14 @@ impl TextWrapping {
         }
     }
 
+    /// A row can be at most `max_width` wide but can wrap in any number of lines.
+    pub fn wrap_at_width(max_width: f32) -> Self {
+        Self {
+            max_width,
+            ..Default::default()
+        }
+    }
+
     /// Elide text that doesn't fit within the given width, replaced with `…`.
     pub fn truncate_at_width(max_width: f32) -> Self {
         Self {
diff --git a/examples/confirm_exit/src/main.rs b/examples/confirm_exit/src/main.rs
index 14816e1bdea..1ec4a7e0f15 100644
--- a/examples/confirm_exit/src/main.rs
+++ b/examples/confirm_exit/src/main.rs
@@ -12,7 +12,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Confirm exit",
         options,
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
diff --git a/examples/custom_3d_glow/src/main.rs b/examples/custom_3d_glow/src/main.rs
index 241124b7c17..c4b89103d3f 100644
--- a/examples/custom_3d_glow/src/main.rs
+++ b/examples/custom_3d_glow/src/main.rs
@@ -19,7 +19,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Custom 3D painting in eframe using glow",
         options,
-        Box::new(|cc| Box::new(MyApp::new(cc))),
+        Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),
     )
 }
 
diff --git a/examples/custom_font/src/main.rs b/examples/custom_font/src/main.rs
index f42c5763150..9687cb0215b 100644
--- a/examples/custom_font/src/main.rs
+++ b/examples/custom_font/src/main.rs
@@ -12,7 +12,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "egui example: custom font",
         options,
-        Box::new(|cc| Box::new(MyApp::new(cc))),
+        Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),
     )
 }
 
diff --git a/examples/custom_font_style/src/main.rs b/examples/custom_font_style/src/main.rs
index c1a61e3e69c..11608bfc012 100644
--- a/examples/custom_font_style/src/main.rs
+++ b/examples/custom_font_style/src/main.rs
@@ -11,7 +11,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "egui example: global font style",
         options,
-        Box::new(|cc| Box::new(MyApp::new(cc))),
+        Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),
     )
 }
 
diff --git a/examples/custom_keypad/src/main.rs b/examples/custom_keypad/src/main.rs
index 654de25fa44..d72d520a110 100644
--- a/examples/custom_keypad/src/main.rs
+++ b/examples/custom_keypad/src/main.rs
@@ -20,7 +20,7 @@ fn main() -> Result<(), eframe::Error> {
             // This gives us image support:
             egui_extras::install_image_loaders(&cc.egui_ctx);
 
-            Box::<MyApp>::default()
+            Ok(Box::<MyApp>::default())
         }),
     )
 }
diff --git a/examples/custom_plot_manipulation/src/main.rs b/examples/custom_plot_manipulation/src/main.rs
index e423d890fcb..1d4abca3a6b 100644
--- a/examples/custom_plot_manipulation/src/main.rs
+++ b/examples/custom_plot_manipulation/src/main.rs
@@ -11,7 +11,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Plot",
         options,
-        Box::new(|_cc| Box::<PlotExample>::default()),
+        Box::new(|_cc| Ok(Box::<PlotExample>::default())),
     )
 }
 
diff --git a/examples/custom_window_frame/src/main.rs b/examples/custom_window_frame/src/main.rs
index bb098652cbf..ef6df49def7 100644
--- a/examples/custom_window_frame/src/main.rs
+++ b/examples/custom_window_frame/src/main.rs
@@ -19,7 +19,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Custom window frame", // unused title
         options,
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
@@ -81,7 +81,11 @@ fn title_bar_ui(ui: &mut egui::Ui, title_bar_rect: eframe::epaint::Rect, title:
 
     let painter = ui.painter();
 
-    let title_bar_response = ui.interact(title_bar_rect, Id::new("title_bar"), Sense::click());
+    let title_bar_response = ui.interact(
+        title_bar_rect,
+        Id::new("title_bar"),
+        Sense::click_and_drag(),
+    );
 
     // Paint the title:
     painter.text(
@@ -108,7 +112,7 @@ fn title_bar_ui(ui: &mut egui::Ui, title_bar_rect: eframe::epaint::Rect, title:
             .send_viewport_cmd(ViewportCommand::Maximized(!is_maximized));
     }
 
-    if title_bar_response.is_pointer_button_down_on() {
+    if title_bar_response.dragged_by(PointerButton::Primary) {
         ui.ctx().send_viewport_cmd(ViewportCommand::StartDrag);
     }
 
diff --git a/examples/file_dialog/src/main.rs b/examples/file_dialog/src/main.rs
index 267c22e111c..840a72fb5c7 100644
--- a/examples/file_dialog/src/main.rs
+++ b/examples/file_dialog/src/main.rs
@@ -14,7 +14,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Native file dialogs and drag-and-drop files",
         options,
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
diff --git a/examples/hello_world/src/main.rs b/examples/hello_world/src/main.rs
index 1c74f4c4992..2780d0ce56e 100644
--- a/examples/hello_world/src/main.rs
+++ b/examples/hello_world/src/main.rs
@@ -16,7 +16,7 @@ fn main() -> Result<(), eframe::Error> {
             // This gives us image support:
             egui_extras::install_image_loaders(&cc.egui_ctx);
 
-            Box::<MyApp>::default()
+            Ok(Box::<MyApp>::default())
         }),
     )
 }
diff --git a/examples/hello_world_par/src/main.rs b/examples/hello_world_par/src/main.rs
index 2896f24843f..ecf7034c2e1 100644
--- a/examples/hello_world_par/src/main.rs
+++ b/examples/hello_world_par/src/main.rs
@@ -17,7 +17,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "My parallel egui App",
         options,
-        Box::new(|_cc| Box::new(MyApp::new())),
+        Box::new(|_cc| Ok(Box::new(MyApp::new()))),
     )
 }
 
diff --git a/examples/images/src/main.rs b/examples/images/src/main.rs
index 8a124e051a5..a1a15a17c47 100644
--- a/examples/images/src/main.rs
+++ b/examples/images/src/main.rs
@@ -15,7 +15,7 @@ fn main() -> Result<(), eframe::Error> {
         Box::new(|cc| {
             // This gives us image support:
             egui_extras::install_image_loaders(&cc.egui_ctx);
-            Box::<MyApp>::default()
+            Ok(Box::<MyApp>::default())
         }),
     )
 }
diff --git a/examples/keyboard_events/src/main.rs b/examples/keyboard_events/src/main.rs
index bf0b3389981..3c1223d671d 100644
--- a/examples/keyboard_events/src/main.rs
+++ b/examples/keyboard_events/src/main.rs
@@ -10,7 +10,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Keyboard events",
         options,
-        Box::new(|_cc| Box::<Content>::default()),
+        Box::new(|_cc| Ok(Box::<Content>::default())),
     )
 }
 
diff --git a/examples/multiple_viewports/README.md b/examples/multiple_viewports/README.md
index 1ce0a2b98b0..3fa67d8abe7 100644
--- a/examples/multiple_viewports/README.md
+++ b/examples/multiple_viewports/README.md
@@ -4,4 +4,4 @@ Example how to show multiple viewports (native windows) can be created in `egui`
 cargo run -p multiple_viewports
 ```
 
-For a more advanced example, see [../test_viewports].
+For a more advanced example, see [../../tests/test_viewports].
diff --git a/examples/multiple_viewports/src/main.rs b/examples/multiple_viewports/src/main.rs
index 262002e2c5b..0ed26e4e8a0 100644
--- a/examples/multiple_viewports/src/main.rs
+++ b/examples/multiple_viewports/src/main.rs
@@ -17,7 +17,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Multiple viewports",
         options,
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
diff --git a/examples/puffin_profiler/src/main.rs b/examples/puffin_profiler/src/main.rs
index 8fe30d679ff..2987e93c5e8 100644
--- a/examples/puffin_profiler/src/main.rs
+++ b/examples/puffin_profiler/src/main.rs
@@ -22,7 +22,7 @@ fn main() -> Result<(), eframe::Error> {
 
             ..Default::default()
         },
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
diff --git a/examples/save_plot/src/main.rs b/examples/save_plot/src/main.rs
index 61657faae86..fa24ec84295 100644
--- a/examples/save_plot/src/main.rs
+++ b/examples/save_plot/src/main.rs
@@ -14,7 +14,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "My egui App with a plot",
         options,
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
diff --git a/examples/screenshot/src/main.rs b/examples/screenshot/src/main.rs
index c0c627e86a7..24eccd2d27c 100644
--- a/examples/screenshot/src/main.rs
+++ b/examples/screenshot/src/main.rs
@@ -14,7 +14,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Take screenshots and display with eframe/egui",
         options,
-        Box::new(|_cc| Box::<MyApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyApp>::default())),
     )
 }
 
diff --git a/examples/serial_windows/src/main.rs b/examples/serial_windows/src/main.rs
index 04bed8006ae..9ea1f3ea8ef 100644
--- a/examples/serial_windows/src/main.rs
+++ b/examples/serial_windows/src/main.rs
@@ -23,7 +23,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "First Window",
         options.clone(),
-        Box::new(|_cc| Box::new(MyApp { has_next: true })),
+        Box::new(|_cc| Ok(Box::new(MyApp { has_next: true }))),
     )?;
 
     std::thread::sleep(std::time::Duration::from_secs(2));
@@ -32,7 +32,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Second Window",
         options.clone(),
-        Box::new(|_cc| Box::new(MyApp { has_next: true })),
+        Box::new(|_cc| Ok(Box::new(MyApp { has_next: true }))),
     )?;
 
     std::thread::sleep(std::time::Duration::from_secs(2));
@@ -41,7 +41,7 @@ fn main() -> Result<(), eframe::Error> {
     eframe::run_native(
         "Third Window",
         options,
-        Box::new(|_cc| Box::new(MyApp { has_next: false })),
+        Box::new(|_cc| Ok(Box::new(MyApp { has_next: false }))),
     )
 }
 
diff --git a/examples/test_viewports/screenshot.png b/examples/test_viewports/screenshot.png
deleted file mode 100644
index 5e8680bbcb0..00000000000
Binary files a/examples/test_viewports/screenshot.png and /dev/null differ
diff --git a/examples/user_attention/src/main.rs b/examples/user_attention/src/main.rs
index cbe27b6d5bc..53c170a1144 100644
--- a/examples/user_attention/src/main.rs
+++ b/examples/user_attention/src/main.rs
@@ -15,7 +15,7 @@ fn main() -> eframe::Result<()> {
     eframe::run_native(
         "User attention test",
         native_options,
-        Box::new(|cc| Box::new(Application::new(cc))),
+        Box::new(|cc| Ok(Box::new(Application::new(cc)))),
     )
 }
 
@@ -103,9 +103,9 @@ impl eframe::App for Application {
                         None => "Unfocus the window, fast!".to_owned(),
                         Some(t) => {
                             if let Ok(elapsed) = t.duration_since(SystemTime::now()) {
-                                format!("Resetting attention in {} s...", elapsed.as_secs())
+                                format!("Resetting attention in {} s…", elapsed.as_secs())
                             } else {
-                                "Resetting attention...".to_owned()
+                                "Resetting attention…".to_owned()
                             }
                         }
                     }
diff --git a/scripts/setup_web.sh b/scripts/setup_web.sh
index 51e53d4be4a..36d39128b6e 100755
--- a/scripts/setup_web.sh
+++ b/scripts/setup_web.sh
@@ -7,4 +7,4 @@ cd "$script_path/.."
 rustup target add wasm32-unknown-unknown
 
 # For generating JS bindings:
-cargo install --quiet wasm-bindgen-cli --version 0.2.92
+cargo install --quiet wasm-bindgen-cli --version 0.2.90
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 00000000000..ac4d8a18f4c
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,4 @@
+## Test apps
+Some application to tests various parts of egui and eframe.
+
+At some point it would be nice to have automatic screenshot regression tests for these.
diff --git a/examples/test_inline_glow_paint/Cargo.toml b/tests/test_inline_glow_paint/Cargo.toml
similarity index 100%
rename from examples/test_inline_glow_paint/Cargo.toml
rename to tests/test_inline_glow_paint/Cargo.toml
diff --git a/examples/test_inline_glow_paint/src/main.rs b/tests/test_inline_glow_paint/src/main.rs
similarity index 95%
rename from examples/test_inline_glow_paint/src/main.rs
rename to tests/test_inline_glow_paint/src/main.rs
index 7851ad63b8b..12569652665 100644
--- a/examples/test_inline_glow_paint/src/main.rs
+++ b/tests/test_inline_glow_paint/src/main.rs
@@ -16,7 +16,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     eframe::run_native(
         "My test app",
         options,
-        Box::new(|_cc| Box::<MyTestApp>::default()),
+        Box::new(|_cc| Ok(Box::<MyTestApp>::default())),
     )?;
     Ok(())
 }
diff --git a/tests/test_size_pass/Cargo.toml b/tests/test_size_pass/Cargo.toml
new file mode 100644
index 00000000000..6886c7af2a1
--- /dev/null
+++ b/tests/test_size_pass/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+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.76"
+publish = false
+
+[lints]
+workspace = true
+
+[features]
+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",
+] }
diff --git a/tests/test_size_pass/src/main.rs b/tests/test_size_pass/src/main.rs
new file mode 100644
index 00000000000..f841cd1d9b8
--- /dev/null
+++ b/tests/test_size_pass/src/main.rs
@@ -0,0 +1,48 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+#![allow(rustdoc::missing_crate_level_docs)] // it's a test
+
+use eframe::egui;
+
+fn main() -> eframe::Result<()> {
+    env_logger::init(); // Use `RUST_LOG=debug` to see logs.
+
+    let options = eframe::NativeOptions::default();
+    eframe::run_simple_native("My egui App", options, move |ctx, _frame| {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            if ui.button("Reset egui memory").clicked() {
+                ctx.memory_mut(|mem| *mem = Default::default());
+            }
+
+            ui.separator();
+
+            ui.label("The menu should be as wide as the widest button");
+            ui.menu_button("Click for menu", |ui| {
+                let _ = ui.button("Narrow").clicked();
+                let _ = ui.button("Very wide text").clicked();
+                let _ = ui.button("Narrow").clicked();
+            });
+
+            ui.label("Hover for tooltip").on_hover_ui(|ui| {
+                ui.label("A separator:");
+                ui.separator();
+            });
+
+            ui.separator();
+
+            let alternatives = [
+                "Short",
+                "Min",
+                "Very very long text that will extend",
+                "Short",
+            ];
+            let mut selected = 1;
+
+            egui::ComboBox::from_label("ComboBox").show_index(
+                ui,
+                &mut selected,
+                alternatives.len(),
+                |i| alternatives[i],
+            );
+        });
+    })
+}
diff --git a/examples/test_viewports/Cargo.toml b/tests/test_viewports/Cargo.toml
similarity index 100%
rename from examples/test_viewports/Cargo.toml
rename to tests/test_viewports/Cargo.toml
diff --git a/examples/test_viewports/README.md b/tests/test_viewports/README.md
similarity index 52%
rename from examples/test_viewports/README.md
rename to tests/test_viewports/README.md
index 280ffe2325d..2fa38c802aa 100644
--- a/examples/test_viewports/README.md
+++ b/tests/test_viewports/README.md
@@ -1,5 +1,3 @@
 This is a test of the viewports feature of eframe and egui, where we show off using multiple windows.
 
-For a simple example, see [`multiple_viewports`](../multiple_viewports).
-
-![](screenshot.png)
+For a simple example, see [`multiple_viewports`](../../examples/multiple_viewports).
diff --git a/examples/test_viewports/src/main.rs b/tests/test_viewports/src/main.rs
similarity index 99%
rename from examples/test_viewports/src/main.rs
rename to tests/test_viewports/src/main.rs
index 8bbb1b22a07..6687e8c0156 100644
--- a/examples/test_viewports/src/main.rs
+++ b/tests/test_viewports/src/main.rs
@@ -22,7 +22,7 @@ fn main() {
 
             ..Default::default()
         },
-        Box::new(|_| Box::<App>::default()),
+        Box::new(|_cc| Ok(Box::<App>::default())),
     );
 }
 
diff --git a/web_demo/index.html b/web_demo/index.html
index 142355b48f8..c4b3bac0095 100644
--- a/web_demo/index.html
+++ b/web_demo/index.html
@@ -48,9 +48,10 @@
             margin-left: auto;
             display: block;
             position: absolute;
-            top: 0%;
-            left: 50%;
-            transform: translate(-50%, 0%);
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
         }
 
         .centered {