diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index a1009057..8cd58413 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -20,7 +20,7 @@ eframe = { git = "https://github.com/emilk/egui", branch = "master" }
 -->
 
 **Describe the bug**
-<!-- A clear and concise description of what the bug is. -->
+<!-- A clear and concise description of what the bug is. An image is good, a gif or movie is better! -->
 
 **To Reproduce**
 Steps to reproduce the behavior:
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 96db0602..eb595662 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -147,3 +147,9 @@ jobs:
       - run: sudo apt-get update && sudo apt-get install libspeechd-dev
       - run: rustup target add wasm32-unknown-unknown
       - run: cargo doc -p egui_web --target wasm32-unknown-unknown --lib --no-deps --all-features
+
+  cargo-deny:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: EmbarkStudios/cargo-deny-action@v1
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 410b648c..994c5be2 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -42,7 +42,7 @@ Puts an egui app inside a native window on your laptop. Paints the triangles tha
 ### `eframe`
 A wrapper around `egui_web` + `egui_glium`, so you can compile the same app for either web or native.
 
-The demo that you can see at <https://emilk.github.io/egui/index.html> is using `eframe` to host the `egui`. The demo code is found in:
+The demo that you can see at <https://www.egui.rs> is using `eframe` to host the `egui`. The demo code is found in:
 
 ### `egui_demo_lib`
 Depends on `egui` + `epi`.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index be641726..81e84aad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,13 +8,51 @@ NOTE: [`epaint`](epaint/CHANGELOG.md), [`eframe`](eframe/CHANGELOG.md), [`egui_w
 ## Unreleased
 
 ### Added ⭐
+* Much improved font selection ([#1154](https://github.com/emilk/egui/pull/1154)):
+  * You can now select any font size and family using `RichText::size` amd `RichText::family` and the new `FontId`.
+  * Easily change text styles with `Style::text_styles`.
+  * Added `Ui::text_style_height`.
+  * Added `TextStyle::resolve`.
+* `Context::load_texture` to convert an image into a texture which can be displayed using e.g. `ui.image(texture, size)` ([#1110](https://github.com/emilk/egui/pull/1110)).
 * Added `Ui::add_visible` and `Ui::add_visible_ui`.
+* Opt-in dependency on `tracing` crate for logging warnings ([#1192](https://github.com/emilk/egui/pull/1192)).
+* Added `CollapsingHeader::icon` to override the default open/close icon using a custom function. ([1147](https://github.com/emilk/egui/pull/1147)).
+* Added `Plot::x_axis_formatter` and `Plot::y_axis_formatter` for custom axis labels ([#1130](https://github.com/emilk/egui/pull/1130)).
+* Added `ui.data()`, `ctx.data()`, `ctx.options()` and `ctx.tessellation_options()` ([#1175](https://github.com/emilk/egui/pull/1175)).
+* Added `Plot::allow_boxed_zoom()`, `Plot::boxed_zoom_pointer()` for boxed zooming on plots ([#1188](https://github.com/emilk/egui/pull/1188)).
+* Added linked axis support for plots via `plot::LinkedAxisGroup` ([#1184](https://github.com/emilk/egui/pull/1184)).
+* Added `Response::on_hover_text_at_pointer` as a convenience akin to `Response::on_hover_text`. ([1179](https://github.com/emilk/egui/pull/1179))
 
 ### Changed 🔧
+* ⚠️ `Context::input` and `Ui::input` now locks a mutex. This can lead to a dead-lock is used in an `if let` binding!
+  * `if let Some(pos) = ui.input().pointer.latest_pos()` and similar must now be rewritten on two lines.
+  * Search for this problem in your code using the regex `if let .*input`.
+* Renamed `CtxRef` to `Context` ([#1050](https://github.com/emilk/egui/pull/1050)).
+* `Context` can now be cloned and stored between frames ([#1050](https://github.com/emilk/egui/pull/1050)).
 * Renamed `Ui::visible` to `Ui::is_visible`.
+* Split `Event::Text` into `Event::Text` and `Event::Paste` ([#1058](https://github.com/emilk/egui/pull/1058)).
+* For integrations:
+  * `FontImage` has been replaced by `TexturesDelta` (found in `Output`), describing what textures were loaded and freed each frame ([#1110](https://github.com/emilk/egui/pull/1110)).
+  * The painter must support partial texture updates ([#1149](https://github.com/emilk/egui/pull/1149)).
+  * Added `RawInput::max_texture_side` which should be filled in with e.g. `GL_MAX_TEXTURE_SIZE` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* Replaced `Style::body_text_style` with more generic `Style::text_styles` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* `TextStyle` is no longer `Copy` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* Replaced `TextEdit::text_style` with `TextEdit::font` ([#1154](https://github.com/emilk/egui/pull/1154)).
+* Replaced `corner_radius: f32` with `rounding: Rounding`, allowing per-corner rounding settings ([#1206](https://github.com/emilk/egui/pull/1206)).
+* `Plot::highlight` now takes a `bool` argument ([#1159](https://github.com/emilk/egui/pull/1159)).
+* `ScrollArea::show` now returns a `ScrollAreaOutput`, so you might need to add `.inner` after the call to it ([#1166](https://github.com/emilk/egui/pull/1166)).
 
 ### Fixed 🐛
-* Context menu now respects the theme ([#1043](https://github.com/emilk/egui/pull/1043))
+* Context menus now respects the theme ([#1043](https://github.com/emilk/egui/pull/1043))
+* Plot `Orientation` was not public, although fields using this type were ([#1130](https://github.com/emilk/egui/pull/1130))
+* Fixed `enable_drag` for Windows ([#1108](https://github.com/emilk/egui/pull/1108)).
+* Calling `Context::set_pixels_per_point` before the first frame will now work.
+
+### Contributors 🙏
+* [AlexxxRu](https://github.com/alexxxru): [#1108](https://github.com/emilk/egui/pull/1108).
+* [danielkeller](https://github.com/danielkeller): [#1050](https://github.com/emilk/egui/pull/1050).
+* [juancampa](https://github.com/juancampa): [#1147](https://github.com/emilk/egui/pull/1147).
+
 
 ## 0.16.1 - 2021-12-31 - Add back `CtxRef::begin_frame,end_frame`
 
@@ -334,7 +372,7 @@ NOTE: [`epaint`](epaint/CHANGELOG.md), [`eframe`](eframe/CHANGELOG.md), [`egui_w
 ### Changed 🔧
 * Text will now wrap at newlines, spaces, dashes, punctuation or in the middle of a words if necessary, in that order of priority.
 * Widgets will now always line break at `\n` characters.
-* Widgets will now more intelligently choose wether or not to wrap text.
+* Widgets will now more intelligently choose whether or not to wrap text.
 * `mouse` has been renamed `pointer` everywhere (to make it clear it includes touches too).
 * Most parts of `Response` are now methods, so `if ui.button("…").clicked {` is now `if ui.button("…").clicked() {`.
 * `Response::active` is now gone. You can use `response.dragged()` or `response.clicked()` instead.
@@ -517,6 +555,7 @@ NOTE: [`epaint`](epaint/CHANGELOG.md), [`eframe`](eframe/CHANGELOG.md), [`egui_w
 * Optimization: coarse culling in the tessellator
 * CHANGED: switch argument order of `ui.checkbox` and `ui.radio`
 
+
 ## 0.1.4 - 2020-09-08
 
 This is when I started the CHANGELOG.md, after almost two years of development. Better late than never.
@@ -528,3 +567,13 @@ This is when I started the CHANGELOG.md, after almost two years of development.
 * Regions: resizing, vertical scrolling, collapsing headers (sections)
 * Rendering: Anti-aliased rendering of lines, circles, text and convex polygons.
 * Tooltips on hover
+
+
+## Earlier:
+
+* 2020-08-10: renamed the project to "egui"
+* 2020-05-30: first release on crates.io (0.1.0)
+* 2020-05-01: serious work starts (pandemic project)
+* 2019-03-12: gave a talk about what would later become egui: https://www.youtube.com/watch?v=-pmwLHw5Gbs
+* 2018-12-23: [initial commit](https://github.com/emilk/egui/commit/856bbf4dae4a69693a0324da34e8b0dd3754dfdf)
+* 2018-11-04: started tinkering on a train
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e6808d39..c3490a60 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -16,7 +16,7 @@ There is an `egui` discord at <https://discord.gg/vbuv9Xan65>.
 
 ## Filing an issue
 
-[Issues](https://github.com/emilk/egui/issues) are for bug reports and feature requests. Issues are not for asking questions (use [Discussions](https://github.com/emilk/egui/discussions) for that).
+[Issues](https://github.com/emilk/egui/issues) are for bug reports and feature requests. Issues are not for asking questions (use [Discussions](https://github.com/emilk/egui/discussions) or [Discord](https://discord.gg/vbuv9Xan65) for that).
 
 Always make sure there is not already a similar issue to the one you are creating.
 
@@ -36,6 +36,8 @@ When you feel the PR is ready to go, do a self-review of the code, and then open
 
 Please keep pull requests small and focused.
 
+Don't worry about having many small commits in the PR - they will be squashed to one commit once merged.
+
 Do not include the `.js` and `.wasm` build artifacts generated for building for web.
 `git` is not great at storing large files like these, so we only commit a new web demo after a new egui release.
 
@@ -59,6 +61,8 @@ While using an immediate mode gui is simple, implementing one is a lot more tric
 
 * read some code before writing your own
 * follow the `egui` code style
+* add blank lines around all `fn`, `struct`, `enum`, etc.
+* `// Comment like this`, not `//like this`
 * write idiomatic rust
 * avoid `unsafe`
 * avoid code that can cause panics
diff --git a/Cargo.lock b/Cargo.lock
index 8ee67a10..34c91490 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "ab_glyph"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20b228f2c198f98d4337ceb560333fb12cbb2f4948a953bf8c57d09deb219603"
+checksum = "61caed9aec6daeee1ea38ccf5fb225e4f96c1eeead1b4a5c267324a63cf02326"
 dependencies = [
  "ab_glyph_rasterizer",
  "owned_ttf_parser",
@@ -39,6 +39,12 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
 
+[[package]]
+name = "ahash"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "739f4a8db6605981345c5654f3a85b056ce52f37a39d34da03f25bf2151ea16e"
+
 [[package]]
 name = "ahash"
 version = "0.7.6"
@@ -76,16 +82,116 @@ dependencies = [
 ]
 
 [[package]]
-name = "anyhow"
-version = "1.0.52"
+name = "ashpd"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84450d0b4a8bd1ba4144ce8ce718fbc5d071358b1e5384bace6536b3d1f2d5b3"
+checksum = "7915e26e0786f91768d23de32afafa4ee5e2ea76be21c0ecd8e14441543c1655"
+dependencies = [
+ "enumflags2",
+ "futures",
+ "rand",
+ "serde",
+ "serde_repr",
+ "zbus",
+]
+
+[[package]]
+name = "async-broadcast"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90622698a1218e0b2fb846c97b5f19a0831f6baddee73d9454156365ccfa473b"
+dependencies = [
+ "easy-parallel",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-channel"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2114d64672151c0c5eaa5e131ec84a74f06e1e559830dabba01ca30605d66319"
+dependencies = [
+ "concurrent-queue",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "871f9bb5e0a22eeb7e8cf16641feb87c9dc67032ccf8ff49e772eb9941d3a965"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "once_cell",
+ "slab",
+]
+
+[[package]]
+name = "async-io"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a811e6a479f2439f0c04038796b5cfb3d2ad56c230e0f2d3f7b04d68cfee607b"
+dependencies = [
+ "concurrent-queue",
+ "futures-lite",
+ "libc",
+ "log",
+ "once_cell",
+ "parking",
+ "polling",
+ "slab",
+ "socket2",
+ "waker-fn",
+ "winapi",
+]
+
+[[package]]
+name = "async-lock"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6a8ea61bf9947a1007c5cada31e647dbc77b103c679858150003ba697ea798b"
+dependencies = [
+ "event-listener",
+]
+
+[[package]]
+name = "async-recursion"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7d78656ba01f1b93024b7c3a0467f1608e4be67d725749fdcd7d2c7678fd7a2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "async-task"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d306121baf53310a3fd342d88dc0824f6bbeace68347593658525565abee8"
+
+[[package]]
+name = "async-trait"
+version = "0.1.52"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "061a7acccaa286c011ddc30970520b98fa40e00c9d644633fb26b5fc63a265e3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "atk-sys"
-version = "0.14.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "badcf670157c84bb8b1cf6b5f70b650fed78da2033c9eed84c4e49b11cbe83ea"
+checksum = "58aeb089fb698e06db8089971c7ee317ab9644bade33383f63631437b03aafb6"
 dependencies = [
  "glib-sys",
  "gobject-sys",
@@ -118,15 +224,15 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 
 [[package]]
 name = "backtrace"
-version = "0.3.63"
+version = "0.3.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "321629d8ba6513061f26707241fa9bc89524ff1cd7a915a97ef0c62c666ce1b6"
+checksum = "5e121dee8023ce33ab248d9ce1493df03c3b38a659b240096fcbd7048ff9c31f"
 dependencies = [
  "addr2line",
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "miniz_oxide 0.4.4",
+ "miniz_oxide",
  "object",
  "rustc-demangle",
 ]
@@ -210,9 +316,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.8.0"
+version = "3.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c"
+checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"
 
 [[package]]
 name = "bytemuck"
@@ -247,10 +353,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
 
 [[package]]
-name = "cairo-sys-rs"
-version = "0.14.9"
+name = "cache-padded"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b448b876970834fda82ba3aeaccadbd760206b75388fc5c1b02f1e343b697570"
+checksum = "c1db59621ec70f09c5e9b597b220c7a2b43611f4710dc03ceb8748637775692c"
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c55d429bef56ac9172d25fecb85dc8068307d17acd74b377866b7a1ef25d3c8"
 dependencies = [
  "libc",
  "system-deps",
@@ -263,7 +375,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf2eec61efe56aa1e813f5126959296933cf0700030e4314786c48779a66ab82"
 dependencies = [
  "log",
- "nix",
+ "nix 0.22.3",
 ]
 
 [[package]]
@@ -298,9 +410,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-expr"
-version = "0.8.1"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b412e83326147c2bb881f8b40edfbf9905b9b8abaebd0e47ca190ba62fda8f0e"
+checksum = "3431df59f28accaf4cb4eed4a9acc66bea3f3c3753aa6cdc2f024174ef232af7"
 dependencies = [
  "smallvec",
 ]
@@ -355,9 +467,9 @@ checksum = "5d83feae28854d73f33659f9018546157422ddf5b84264ce171a766d8547d77b"
 
 [[package]]
 name = "clang-sys"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa66045b9cb23c2e9c1520732030608b02ee07e5cfaa5a521ec15ded7fa24c90"
+checksum = "4cc00842eed744b858222c4c9faf7243aafc6d33f92f96935263ef4d8a41ce21"
 dependencies = [
  "glob",
  "libc",
@@ -428,14 +540,33 @@ checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
 name = "combine"
-version = "4.6.2"
+version = "4.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2b2f5d0ee456f3928812dfc8c6d9a1d592b98678f6d56db9b0cd2b7bc6c8db5"
+checksum = "50b727aacc797f9fc28e355d21f34709ac4fc9adecfe470ad07b8f4464f53062"
 dependencies = [
  "bytes",
  "memchr",
 ]
 
+[[package]]
+name = "concurrent-queue"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30ed07550be01594c6026cff2a1d7fe9c8f683caa798e12b68694ac9e88286a3"
+dependencies = [
+ "cache-padded",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if 1.0.0",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "copypasta"
 version = "0.7.1"
@@ -534,9 +665,9 @@ dependencies = [
 
 [[package]]
 name = "crc32fast"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "738c290dfaea84fc1ca15ad9c168d083b05a714e1efddd8edaab678dc28d2836"
+checksum = "a2209c310e29876f7f0b2721e7e26b84aff178aa3da5d091f9bfbf47669e60e3"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -579,9 +710,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
+checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa"
 dependencies = [
  "cfg-if 1.0.0",
  "crossbeam-utils",
@@ -600,9 +731,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.5"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+checksum = "97242a70df9b89a65d0b6df3c4bf5b9ce03c5b7309019777fbde37e7537f8762"
 dependencies = [
  "cfg-if 1.0.0",
  "crossbeam-utils",
@@ -613,9 +744,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
+checksum = "cfcae03edb34f947e64acdb1c33ec169824e20657e9ecb61cef6c8c74dcb8120"
 dependencies = [
  "cfg-if 1.0.0",
  "lazy_static",
@@ -649,6 +780,22 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35"
 
+[[package]]
+name = "dark-light"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a76de8354e3935082b341ac29aeff1d05dd14eab64d67ffce4c2f6af06cdb2b"
+dependencies = [
+ "dconf_rs",
+ "detect-desktop-environment",
+ "dirs",
+ "objc",
+ "rust-ini",
+ "winreg",
+ "zbus",
+ "zvariant",
+]
+
 [[package]]
 name = "darling"
 version = "0.13.1"
@@ -685,13 +832,18 @@ dependencies = [
 ]
 
 [[package]]
-name = "deflate"
-version = "0.8.6"
+name = "dconf_rs"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73770f8e1fe7d64df17ca66ad28994a0a623ea497fa69486e14984e715c5d174"
+checksum = "7046468a81e6a002061c01e6a7c83139daf91b11c30e66795b13217c2d885c8b"
+
+[[package]]
+name = "deflate"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f95bf05dffba6e6cce8dfbb30def788154949ccd9aed761b472119c21e01c70"
 dependencies = [
  "adler32",
- "byteorder",
 ]
 
 [[package]]
@@ -705,6 +857,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "detect-desktop-environment"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21d8ad60dd5b13a4ee6bd8fa2d5d88965c597c67bce32b5fc49c94f55cb50810"
+
 [[package]]
 name = "directories-next"
 version = "2.0.0"
@@ -715,6 +873,26 @@ dependencies = [
  "dirs-sys-next",
 ]
 
+[[package]]
+name = "dirs"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03d86534ed367a67548dc68113a0f5db55432fdfbb6e6f9d77704397d95d5780"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
 [[package]]
 name = "dirs-sys-next"
 version = "0.1.2"
@@ -741,6 +919,15 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "dlv-list"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68df3f2b690c1b86e65ef7830956aededf3cb0a16f898f79b9a6f421a7b6211b"
+dependencies = [
+ "rand",
+]
+
 [[package]]
 name = "downcast-rs"
 version = "1.2.0"
@@ -774,6 +961,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee2626afccd7561a06cf1367e2950c4718ea04565e20fb5029b6c7d8ad09abcf"
 
+[[package]]
+name = "easy-parallel"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6907e25393cdcc1f4f3f513d9aac1e840eb1cc341a0fccb01171f7d14d10b946"
+
 [[package]]
 name = "eframe"
 version = "0.16.0"
@@ -783,8 +976,10 @@ dependencies = [
  "egui_glium",
  "egui_glow",
  "egui_web",
+ "ehttp",
  "epi",
  "image",
+ "poll-promise",
  "rfd",
 ]
 
@@ -792,11 +987,12 @@ dependencies = [
 name = "egui"
 version = "0.16.1"
 dependencies = [
- "ahash",
+ "ahash 0.7.6",
  "epaint",
  "nohash-hasher",
  "ron",
  "serde",
+ "tracing",
 ]
 
 [[package]]
@@ -804,10 +1000,12 @@ name = "egui-winit"
 version = "0.16.0"
 dependencies = [
  "copypasta",
+ "dark-light",
  "egui",
  "epi",
  "instant",
  "serde",
+ "tracing",
  "tts",
  "webbrowser",
  "winit",
@@ -819,6 +1017,7 @@ version = "0.16.0"
 dependencies = [
  "eframe",
  "egui_demo_lib",
+ "tracing-subscriber",
 ]
 
 [[package]]
@@ -833,6 +1032,7 @@ dependencies = [
  "enum-map",
  "epi",
  "image",
+ "poll-promise",
  "serde",
  "syntect",
  "unicode_names2",
@@ -851,6 +1051,8 @@ dependencies = [
 name = "egui_glium"
 version = "0.16.0"
 dependencies = [
+ "ahash 0.7.6",
+ "bytemuck",
  "egui",
  "egui-winit",
  "epi",
@@ -862,6 +1064,7 @@ dependencies = [
 name = "egui_glow"
 version = "0.16.0"
 dependencies = [
+ "bytemuck",
  "egui",
  "egui-winit",
  "epi",
@@ -869,6 +1072,7 @@ dependencies = [
  "glutin",
  "image",
  "memoffset",
+ "tracing",
  "wasm-bindgen",
  "web-sys",
 ]
@@ -877,12 +1081,16 @@ dependencies = [
 name = "egui_web"
 version = "0.16.0"
 dependencies = [
+ "bytemuck",
+ "console_error_panic_hook",
  "egui",
  "egui_glow",
  "epi",
  "js-sys",
  "ron",
  "serde",
+ "tracing",
+ "tracing-wasm",
  "tts",
  "wasm-bindgen",
  "wasm-bindgen-futures",
@@ -891,9 +1099,9 @@ dependencies = [
 
 [[package]]
 name = "ehttp"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b078e2305de4c998700ac152b3e7a358d7fbe77e15b3b1cd2c44a8b82176124f"
+checksum = "80b69a6f9168b96c0ae04763bec27a8b06b34343c334dd2703a4ec21f0f5e110"
 dependencies = [
  "js-sys",
  "ureq",
@@ -918,10 +1126,74 @@ dependencies = [
 ]
 
 [[package]]
-name = "enum-map"
-version = "1.1.1"
+name = "encoding"
+version = "0.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e893a7ba6116821058dec84a6fb14fb2a97cd8ce5fd0f85d5a4e760ecd7329d9"
+checksum = "6b0d943856b990d12d3b55b359144ff341533e516d94098b1d3fc1ac666d36ec"
+dependencies = [
+ "encoding-index-japanese",
+ "encoding-index-korean",
+ "encoding-index-simpchinese",
+ "encoding-index-singlebyte",
+ "encoding-index-tradchinese",
+]
+
+[[package]]
+name = "encoding-index-japanese"
+version = "1.20141219.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04e8b2ff42e9a05335dbf8b5c6f7567e5591d0d916ccef4e0b1710d32a0d0c91"
+dependencies = [
+ "encoding_index_tests",
+]
+
+[[package]]
+name = "encoding-index-korean"
+version = "1.20141219.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dc33fb8e6bcba213fe2f14275f0963fd16f0a02c878e3095ecfdf5bee529d81"
+dependencies = [
+ "encoding_index_tests",
+]
+
+[[package]]
+name = "encoding-index-simpchinese"
+version = "1.20141219.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87a7194909b9118fc707194baa434a4e3b0fb6a5a757c73c3adb07aa25031f7"
+dependencies = [
+ "encoding_index_tests",
+]
+
+[[package]]
+name = "encoding-index-singlebyte"
+version = "1.20141219.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3351d5acffb224af9ca265f435b859c7c01537c0849754d3db3fdf2bfe2ae84a"
+dependencies = [
+ "encoding_index_tests",
+]
+
+[[package]]
+name = "encoding-index-tradchinese"
+version = "1.20141219.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd0e20d5688ce3cab59eb3ef3a2083a5c77bf496cb798dc6fcdb75f323890c18"
+dependencies = [
+ "encoding_index_tests",
+]
+
+[[package]]
+name = "encoding_index_tests"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a246d82be1c9d791c5dfde9a2bd045fc3cbba3fa2b11ad558f27d01712f00569"
+
+[[package]]
+name = "enum-map"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4daa8ce58bdc96f86eb90b4b8eab8f1e051da02f8c564389ae2b8ce38932f758"
 dependencies = [
  "enum-map-derive",
  "serde",
@@ -929,9 +1201,30 @@ dependencies = [
 
 [[package]]
 name = "enum-map-derive"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84278eae0af6e34ff6c1db44c11634a694aafac559ff3080e4db4e4ac35907aa"
+checksum = "a63b7a0ddec6f38dcec5e36257750b7a8fcaf4227e12ceb306e341d63634da05"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "enumflags2"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a25c90b056b3f84111cf183cbeddef0d3a0bbe9a674f057e1a1533c315f24def"
+dependencies = [
+ "enumflags2_derive",
+ "serde",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "144ec79496cbab6f84fa125dc67be9264aef22eb8a28da8454d9c33f15108da4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -956,7 +1249,7 @@ name = "epaint"
 version = "0.16.0"
 dependencies = [
  "ab_glyph",
- "ahash",
+ "ahash 0.7.6",
  "atomic_refcell",
  "bytemuck",
  "cint",
@@ -975,8 +1268,15 @@ dependencies = [
  "egui",
  "ron",
  "serde",
+ "tracing",
 ]
 
+[[package]]
+name = "event-listener"
+version = "2.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77f3309417938f28bf8228fcff79a4a37103981e3e186d2ccd19c74b38f4eb71"
+
 [[package]]
 name = "fancy-regex"
 version = "0.7.1"
@@ -987,6 +1287,15 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "fastrand"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+dependencies = [
+ "instant",
+]
+
 [[package]]
 name = "flate2"
 version = "1.0.22"
@@ -996,7 +1305,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "crc32fast",
  "libc",
- "miniz_oxide 0.4.4",
+ "miniz_oxide",
 ]
 
 [[package]]
@@ -1031,16 +1340,114 @@ dependencies = [
 ]
 
 [[package]]
-name = "gcc"
-version = "0.3.55"
+name = "futures"
+version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2"
+checksum = "28560757fe2bb34e79f907794bb6b22ae8b0e5c669b638a1132f2592b19035b4"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3dda0b6588335f360afc675d0564c17a77a2bda81ca178a4b6081bd86c7f0b"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0c8ff0461b82559810cdccfde3215c3f373807f5e5232b71479bff7bb2583d7"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29d6d2ff5bb10fb95c85b8ce46538a2e5f5e7fdc755623a7d4529ab8a4ed9d2a"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f9d34af5a1aac6fb380f735fe510746c38067c5bf16c7fd250280503c971b2"
+
+[[package]]
+name = "futures-lite"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "parking",
+ "pin-project-lite",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbd947adfffb0efc70599b3ddcf7b5597bb5fa9e245eb99f62b3a5f7bb8bd3c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3055baccb68d74ff6480350f8d6eb8fcfa3aa11bdc1a1ae3afdd0514617d508"
+
+[[package]]
+name = "futures-task"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ee7c6485c30167ce4dfb83ac568a849fe53274c831081476ee13e0dce1aad72"
+
+[[package]]
+name = "futures-util"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b5cf40b47a271f77a8b1bec03ca09044d99d2372c0de244e66430761127164"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
 
 [[package]]
 name = "gdk-pixbuf-sys"
-version = "0.14.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f097c0704201fbc8f69c1762dc58c6947c8bb188b8ed0bc7e65259f1894fe590"
+checksum = "413424d9818621fa3cfc8a3a915cdb89a7c3c507d56761b4ec83a9a98e587171"
 dependencies = [
  "gio-sys",
  "glib-sys",
@@ -1051,9 +1458,9 @@ dependencies = [
 
 [[package]]
 name = "gdk-sys"
-version = "0.14.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e091b3d3d6696949ac3b3fb3c62090e5bfd7bd6850bef5c3c5ea701de1b1f1e"
+checksum = "32e7a08c1e8f06f4177fb7e51a777b8c1689f743a7bc11ea91d44d2226073a88"
 dependencies = [
  "cairo-sys-rs",
  "gdk-pixbuf-sys",
@@ -1068,9 +1475,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+checksum = "418d37c8b1d42553c93648be529cb70f920d3baf8ef469b74b9638df426e0b4c"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -1085,9 +1492,9 @@ checksum = "78cc372d058dcf6d5ecd98510e7fbc9e5aec4d21de70f65fea8fecebcd881bd4"
 
 [[package]]
 name = "gio-sys"
-version = "0.14.0"
+version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0a41df66e57fcc287c4bcf74fc26b884f31901ea9792ec75607289b456f48fa"
+checksum = "97225e1b9c7c48ed7fec4377fdc72702965bfbfd3a944b928ccbb5d8ed82ccc9"
 dependencies = [
  "glib-sys",
  "gobject-sys",
@@ -1109,9 +1516,9 @@ dependencies = [
 
 [[package]]
 name = "glib-sys"
-version = "0.14.0"
+version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c1d60554a212445e2a858e42a0e48cece1bd57b311a19a9468f70376cf554ae"
+checksum = "0c4f08dd67f74b223fedbbb30e73145b9acd444e67cc4d77d0598659b7eebe7e"
 dependencies = [
  "libc",
  "system-deps",
@@ -1225,9 +1632,9 @@ dependencies = [
 
 [[package]]
 name = "gobject-sys"
-version = "0.14.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa92cae29759dae34ab5921d73fff5ad54b3d794ab842c117e36cafc7994c3f5"
+checksum = "6edb1f0b3e4c08e2a0a490d1082ba9e902cdff8ff07091e85c6caec60d17e2ab"
 dependencies = [
  "glib-sys",
  "libc",
@@ -1236,9 +1643,9 @@ dependencies = [
 
 [[package]]
 name = "gtk-sys"
-version = "0.14.0"
+version = "0.15.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c14c8d3da0545785a7c5a120345b3abb534010fb8ae0f2ef3f47c027fba303e"
+checksum = "d5bc2f0587cba247f60246a0ca11fe25fb733eabc3de12d1965fc07efab87c84"
 dependencies = [
  "atk-sys",
  "cairo-sys-rs",
@@ -1258,6 +1665,15 @@ version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
 
+[[package]]
+name = "hashbrown"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
+dependencies = [
+ "ahash 0.4.7",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.11.2"
@@ -1266,12 +1682,9 @@ checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
 
 [[package]]
 name = "heck"
-version = "0.3.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
-dependencies = [
- "unicode-segmentation",
-]
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
 
 [[package]]
 name = "hermit-abi"
@@ -1282,6 +1695,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
 [[package]]
 name = "humantime"
 version = "2.1.0"
@@ -1307,9 +1726,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.23.14"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24ffcb7e7244a9bf19d35bf2883b9c080c4ced3c07a9895572178cdb8f13f6a1"
+checksum = "e94ac3d41f882c624a82d7945952032388488681f45f9d4077999a6c85688d61"
 dependencies = [
  "bytemuck",
  "byteorder",
@@ -1323,12 +1742,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
+checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
 dependencies = [
  "autocfg",
- "hashbrown",
+ "hashbrown 0.11.2",
 ]
 
 [[package]]
@@ -1386,15 +1805,15 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "jpeg-decoder"
-version = "0.1.22"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229d53d58899083193af11e15917b5640cd40b29ff475a1fe4ef725deb02d0f2"
+checksum = "fbcf0244f6597be39ab8d9203f574cafb529ae8c698afa2182f7b3c3205a4a9c"
 
 [[package]]
 name = "js-sys"
-version = "0.3.55"
+version = "0.3.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cc9ffccd38c451a86bf13657df244e9c3f37493cce8e5e21e940963777acc84"
+checksum = "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -1425,15 +1844,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.112"
+version = "0.2.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
+checksum = "e74d72e0f9b65b5b4ca49a346af3976df0f9c61d550727f349ecd559f251a26c"
 
 [[package]]
 name = "libloading"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afe203d669ec979b7128619bae5a63b7b42e9203c1b29146079ee05e2f604b52"
+checksum = "efbc0f03f9a775e9f6aed295c6a1ba2253c5757a9e03d55c6caa46a681abcddd"
 dependencies = [
  "cfg-if 1.0.0",
  "winapi",
@@ -1456,9 +1875,9 @@ checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
 
 [[package]]
 name = "lock_api"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"
+checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
 dependencies = [
  "scopeguard",
 ]
@@ -1517,15 +1936,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
-[[package]]
-name = "miniz_oxide"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "791daaae1ed6889560f8c4359194f56648355540573244a5448a83ba1ecc7435"
-dependencies = [
- "adler32",
-]
-
 [[package]]
 name = "miniz_oxide"
 version = "0.4.4"
@@ -1538,9 +1948,9 @@ dependencies = [
 
 [[package]]
 name = "mint"
-version = "0.5.8"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162e591484b4b8fe9e1ca16ebf07ab584fdc3334508d76a788cd54d89cfc20dc"
+checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
 
 [[package]]
 name = "mio"
@@ -1572,7 +1982,20 @@ checksum = "96d868f654c72e75f8687572699cdabe755f03effbb62542768e995d5b8d699d"
 dependencies = [
  "bitflags",
  "jni-sys",
- "ndk-sys",
+ "ndk-sys 0.2.2",
+ "num_enum",
+ "thiserror",
+]
+
+[[package]]
+name = "ndk"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2032c77e030ddee34a6787a64166008da93f6a352b629261d0fee232b8742dd4"
+dependencies = [
+ "bitflags",
+ "jni-sys",
+ "ndk-sys 0.3.0",
  "num_enum",
  "thiserror",
 ]
@@ -1586,9 +2009,23 @@ dependencies = [
  "lazy_static",
  "libc",
  "log",
- "ndk",
+ "ndk 0.5.0",
  "ndk-macro",
- "ndk-sys",
+ "ndk-sys 0.2.2",
+]
+
+[[package]]
+name = "ndk-glue"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04c0d14b0858eb9962a5dac30b809b19f19da7e4547d64af2b0bb051d2e55d79"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "log",
+ "ndk 0.6.0",
+ "ndk-macro",
+ "ndk-sys 0.3.0",
 ]
 
 [[package]]
@@ -1611,10 +2048,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1bcdd74c20ad5d95aacd60ef9ba40fdf77f767051040541df557b7a9b2a2121"
 
 [[package]]
-name = "nix"
-version = "0.22.0"
+name = "ndk-sys"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf1e25ee6b412c2a1e3fcb6a4499a5c1bfe7f43e014bdce9a6b6666e5aa2d187"
+checksum = "6e5a6ae77c8ee183dcbbba6150e2e6b9f3f4196a7666c02a715a95692ec1fa97"
+dependencies = [
+ "jni-sys",
+]
+
+[[package]]
+name = "nix"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4916f159ed8e5de0082076562152a76b7a1f64a01fd9d1e0fea002c37624faf"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if 1.0.0",
+ "libc",
+ "memoffset",
+]
+
+[[package]]
+name = "nix"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f866317acbd3a240710c63f065ffb1e4fd466259045ccb504130b7f668f35c6"
 dependencies = [
  "bitflags",
  "cc",
@@ -1672,9 +2131,9 @@ dependencies = [
 
 [[package]]
 name = "num-rational"
-version = "0.3.2"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
+checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a"
 dependencies = [
  "autocfg",
  "num-integer",
@@ -1702,19 +2161,18 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.5.5"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "085fe377a4b2805c0fbc09484415ec261174614b7f080b0e0d520456ac421a67"
+checksum = "720d3ea1055e4e4574c0c0b0f8c3fd4f24c4cdaf465948206dea090b57b526ad"
 dependencies = [
- "derivative",
  "num_enum_derive",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.5.5"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5249369707a1e07b39f78d98c8f34e00aca7dcb053812fdbb5ad7be82c1bba38"
+checksum = "0d992b768490d7fe0d8586d9b5745f6c49f557da6d81dc982b1d167ad4edbb21"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -1722,6 +2180,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "num_threads"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97ba99ba6393e2c3734791401b66902d981cb03bf190af674ca69949b6d5fb15"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "objc"
 version = "0.2.7"
@@ -1782,6 +2249,32 @@ version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
+[[package]]
+name = "openssl-probe"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+
+[[package]]
+name = "ordered-multimap"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c672c7ad9ec066e428c00eb917124a06f08db19e2584de982cc34b1f4c12485"
+dependencies = [
+ "dlv-list",
+ "hashbrown 0.9.1",
+]
+
+[[package]]
+name = "ordered-stream"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44630c059eacfd6e08bdaa51b1db2ce33119caa4ddc1235e923109aa5f25ccb1"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "osmesa-sys"
 version = "0.1.2"
@@ -1793,18 +2286,18 @@ dependencies = [
 
 [[package]]
 name = "owned_ttf_parser"
-version = "0.13.2"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65ee3f72636e6f164cc41c9f9057f4e58c4e13507699ea7f5e5242b64b8198ee"
+checksum = "4ef05f2882a8b3e7acc10c153ade2631f7bfc8ce00d2bf3fb8f4e9d2ae6ea5c3"
 dependencies = [
  "ttf-parser",
 ]
 
 [[package]]
 name = "pango-sys"
-version = "0.14.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2367099ca5e761546ba1d501955079f097caa186bb53ce0f718dca99ac1942fe"
+checksum = "7022c2fb88cd2d9d55e1a708a8c53a3ae8678234c4a54bf623400aeb7f31fac2"
 dependencies = [
  "glib-sys",
  "gobject-sys",
@@ -1812,6 +2305,12 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "parking"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+
 [[package]]
 name = "parking_lot"
 version = "0.11.2"
@@ -1849,6 +2348,18 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 
+[[package]]
+name = "pin-project-lite"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "pkg-config"
 version = "0.3.24"
@@ -1865,7 +2376,7 @@ dependencies = [
  "indexmap",
  "line-wrap",
  "serde",
- "time 0.3.5",
+ "time 0.3.7",
  "xml-rs",
 ]
 
@@ -1899,16 +2410,51 @@ dependencies = [
 
 [[package]]
 name = "png"
-version = "0.16.8"
+version = "0.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c3287920cb847dee3de33d301c463fba14dda99db24214ddf93f83d3021f4c6"
+checksum = "c845088517daa61e8a57eee40309347cea13f273694d1385c553e7a57127763b"
 dependencies = [
  "bitflags",
  "crc32fast",
  "deflate",
- "miniz_oxide 0.3.7",
+ "encoding",
+ "miniz_oxide",
 ]
 
+[[package]]
+name = "poll-promise"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "260817b339544e5b23d4bb66d4522d89dd64af88d16b6dcd7b2a2409ee2e095d"
+dependencies = [
+ "static_assertions",
+]
+
+[[package]]
+name = "polling"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685404d509889fade3e86fe3a5803bca2ec09b0c0778d5ada6ec8bf7a8de5259"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "log",
+ "wepoll-ffi",
+ "winapi",
+]
+
+[[package]]
+name = "pollster"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5da3b0203fd7ee5720aa0b5e790b591aa5d3f41c3ed2c34a3a393382198af2f7"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
 [[package]]
 name = "proc-macro-crate"
 version = "1.1.0"
@@ -1939,13 +2485,53 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d"
+checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
+]
+
 [[package]]
 name = "raw-window-handle"
 version = "0.4.2"
@@ -2024,10 +2610,11 @@ checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
 
 [[package]]
 name = "rfd"
-version = "0.6.3"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b0c25b610bf37d9874ff224ab2791ff2272bedeb5638a2dca8b18e1270ed69b"
+checksum = "2aaf1d71ccd44689f7c2c72da1117fd8db71f72a76fe9b5c5dbb17ab903007e0"
 dependencies = [
+ "ashpd",
  "block",
  "dispatch",
  "glib-sys",
@@ -2035,9 +2622,11 @@ dependencies = [
  "gtk-sys",
  "js-sys",
  "lazy_static",
+ "log",
  "objc",
  "objc-foundation",
  "objc_id",
+ "pollster",
  "raw-window-handle",
  "wasm-bindgen",
  "wasm-bindgen-futures",
@@ -2071,6 +2660,16 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "rust-ini"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63471c4aa97a1cf8332a5f97709a79a4234698de6a1f5087faf66f2dae810e22"
+dependencies = [
+ "cfg-if 1.0.0",
+ "ordered-multimap",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.21"
@@ -2104,6 +2703,27 @@ dependencies = [
  "webpki",
 ]
 
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca9ebdfa27d3fc180e42879037b5338ab1c040c06affd00d8338598e7800943"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eebeaeb360c87bfb72e84abdb3447159c0eaececf1bef2aecd65a8be949d1c9"
+dependencies = [
+ "base64",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.9"
@@ -2125,6 +2745,16 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "schannel"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
+dependencies = [
+ "lazy_static",
+ "winapi",
+]
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.0"
@@ -2147,6 +2777,29 @@ dependencies = [
  "untrusted",
 ]
 
+[[package]]
+name = "security-framework"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fed7948b6c68acbb6e20c334f55ad635dc0f75506963de4464289fbd3b051ac"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.9.2",
+ "core-foundation-sys 0.8.3",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a57321bf8bc2362081b2599912d2961fe899c0efadf1b4b2f8d48b3e253bb96c"
+dependencies = [
+ "core-foundation-sys 0.8.3",
+ "libc",
+]
+
 [[package]]
 name = "semver"
 version = "1.0.4"
@@ -2155,9 +2808,9 @@ checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012"
 
 [[package]]
 name = "serde"
-version = "1.0.132"
+version = "1.0.136"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9875c23cf305cd1fd7eb77234cbb705f21ea6a72c637a5c6db5fe4b8e7f008"
+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
 dependencies = [
  "serde_derive",
 ]
@@ -2174,9 +2827,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.132"
+version = "1.0.136"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecc0db5cb2556c0e558887d9bbdcf6ac4471e83ff66cf696e5419024d1606276"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2185,15 +2838,50 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.73"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcbd0344bc6533bc7ec56df11d42fb70f1b912351c0825ccb7211b59d8af7cf5"
+checksum = "d23c1ba4cf0efd44be32017709280b32d1cea5c3f1275c3b6d9e8bc54f758085"
 dependencies = [
  "itoa 1.0.1",
  "ryu",
  "serde",
 ]
 
+[[package]]
+name = "serde_repr"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98d0516900518c29efa217c298fa1f4e6c6ffc85ae29fd7f4ee48f176e1a9ed5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha1"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1da05c97445caa12d05e848c4a4fcbbea29e748ac28f7e80e9b010392063770"
+dependencies = [
+ "sha1_smol",
+]
+
+[[package]]
+name = "sha1_smol"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012"
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "shared_library"
 version = "0.1.9"
@@ -2210,6 +2898,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
 
+[[package]]
+name = "slab"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
+
 [[package]]
 name = "slotmap"
 version = "1.0.6"
@@ -2221,9 +2915,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ecab6c735a6bb4139c0caafd0cc3635748bbb3acf4550e8138122099251f309"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
 
 [[package]]
 name = "smithay-client-toolkit"
@@ -2237,7 +2931,7 @@ dependencies = [
  "lazy_static",
  "log",
  "memmap2",
- "nix",
+ "nix 0.22.3",
  "pkg-config",
  "wayland-client",
  "wayland-cursor",
@@ -2255,10 +2949,20 @@ dependencies = [
 ]
 
 [[package]]
-name = "speech-dispatcher"
-version = "0.9.0"
+name = "socket2"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b684552615661fef2658506637989f8a8ead697c83c9a35a12d2a11bbd96955"
+checksum = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "speech-dispatcher"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbab517fe176eb95d9bcc23c5ba75500fc5157d13a6978cfe135395fa149e151"
 dependencies = [
  "lazy_static",
  "speech-dispatcher-sys",
@@ -2266,12 +2970,11 @@ dependencies = [
 
 [[package]]
 name = "speech-dispatcher-sys"
-version = "0.5.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b662a91fe7e39d3d11edcf0297c717a8c05683a6c6445df9aba83b034b2b2db5"
+checksum = "6c3e8acdf2b1f4bb13f1813b40b52f3edf4cc94d8a55fe713a584f672a10388d"
 dependencies = [
  "bindgen",
- "gcc",
 ]
 
 [[package]]
@@ -2280,6 +2983,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
 
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "strsim"
 version = "0.8.0"
@@ -2292,35 +3001,23 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
-[[package]]
-name = "strum"
-version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf86bbcfd1fa9670b7a129f64fc0c9fcbbfe4f1bc4210e9e98fe71ffc12cde2"
-
-[[package]]
-name = "strum_macros"
-version = "0.21.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d06aaeeee809dbc59eb4556183dd927df67db1540de5be8d3ec0b6636358a5ec"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "syn"
-version = "1.0.84"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecb2e6da8ee5eb9a61068762a32fa9619cc591ceb055b3687f4cd4051ec2e06b"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-xid",
 ]
 
+[[package]]
+name = "sync_wrapper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8"
+
 [[package]]
 name = "syntect"
 version = "4.6.0"
@@ -2345,18 +3042,13 @@ dependencies = [
 
 [[package]]
 name = "system-deps"
-version = "3.2.0"
+version = "6.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "480c269f870722b3b08d2f13053ce0c2ab722839f472863c3e2d61ff3a1c2fa6"
+checksum = "ad3a97fdef3daf935d929b3e97e5a6a680cd4622e40c2941ca0875d6566416f8"
 dependencies = [
- "anyhow",
  "cfg-expr",
  "heck",
- "itertools",
  "pkg-config",
- "strum",
- "strum_macros",
- "thiserror",
  "toml",
  "version-compare",
 ]
@@ -2405,6 +3097,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+dependencies = [
+ "once_cell",
+]
+
 [[package]]
 name = "time"
 version = "0.1.43"
@@ -2417,12 +3118,13 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.5"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41effe7cfa8af36f439fac33861b66b049edc6f9a32331e2312660529c1c24ad"
+checksum = "004cbc98f30fa233c61a38bc77e96a9106e65c88f2d3bef182ae952027e5753d"
 dependencies = [
- "itoa 0.4.8",
+ "itoa 1.0.1",
  "libc",
+ "num_threads",
 ]
 
 [[package]]
@@ -2460,16 +3162,85 @@ dependencies = [
 ]
 
 [[package]]
-name = "ttf-parser"
-version = "0.13.4"
+name = "tracing"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76dacc724328b3d5e2ed67f9e30cdb56893a34ab239032502cc8f19f8dae4bbc"
+checksum = "2d8d93354fe2a8e50d5953f5ae2e47a3fc2ef03292e7ea46e3cc38f549525fb9"
+dependencies = [
+ "cfg-if 1.0.0",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8276d9a4a3a558d7b7ad5303ad50b53d58264641b82914b7ada36bd762e7a716"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03cfcb51380632a72d3111cb8d3447a8d908e577d31beeac006f836383d29a23"
+dependencies = [
+ "lazy_static",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6923477a48e41c1951f1999ef8bb5a3023eb723ceadafe78ffb65dc366761e3"
+dependencies = [
+ "lazy_static",
+ "log",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5312f325fe3588e277415f5a6cca1f4ccad0f248c4cd5a4bd33032d7286abc22"
+dependencies = [
+ "ansi_term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "tracing-wasm"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ttf-parser"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ccbe8381883510b6a2d8f1e32905bddd178c11caef8083086d0c0c9ab0ac281"
 
 [[package]]
 name = "tts"
-version = "0.19.2"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38dcd7e0cdd94949f55b94c24ccbb7922437883ec268dbbac23480db32287016"
+checksum = "5dd3cc4cfd63db314c5b82e8b60cba72869f048c4e6d26e7ec1645bf4de2ca2d"
 dependencies = [
  "cocoa-foundation",
  "dyn-clonable",
@@ -2477,7 +3248,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "log",
- "ndk-glue",
+ "ndk-glue 0.6.0",
  "objc",
  "speech-dispatcher",
  "thiserror",
@@ -2501,12 +3272,6 @@ dependencies = [
  "tinyvec",
 ]
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
-
 [[package]]
 name = "unicode-width"
 version = "0.1.9"
@@ -2534,8 +3299,7 @@ checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 [[package]]
 name = "ureq"
 version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9399fa2f927a3d327187cbd201480cee55bee6ac5d3c77dd27f0c6814cff16d5"
+source = "git+https://github.com/emilk/ureq/?branch=opt-in-webpki-roots#d4ca2ca620b65854c3428306b03ab7ef562bf796"
 dependencies = [
  "base64",
  "chunked_transfer",
@@ -2543,9 +3307,10 @@ dependencies = [
  "log",
  "once_cell",
  "rustls",
+ "rustls-native-certs",
+ "sync_wrapper",
  "url",
  "webpki",
- "webpki-roots",
 ]
 
 [[package]]
@@ -2560,6 +3325,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -2568,9 +3339,9 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
 
 [[package]]
 name = "version-compare"
-version = "0.0.11"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c18c859eead79d8b95d09e4678566e8d70105c4e7b251f707a03df32442661b"
+checksum = "fe88247b92c1df6b6de80ddc290f3976dbdf2f5f5d3fd049a9fb598c6dd5ca73"
 
 [[package]]
 name = "version_check"
@@ -2578,6 +3349,12 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
+[[package]]
+name = "waker-fn"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+
 [[package]]
 name = "walkdir"
 version = "2.3.2"
@@ -2597,9 +3374,9 @@ checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.78"
+version = "0.2.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce"
+checksum = "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"
 dependencies = [
  "cfg-if 1.0.0",
  "wasm-bindgen-macro",
@@ -2607,9 +3384,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.78"
+version = "0.2.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b"
+checksum = "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"
 dependencies = [
  "bumpalo",
  "lazy_static",
@@ -2622,9 +3399,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.28"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e8d7523cb1f2a4c96c1317ca690031b714a51cc14e05f712446691f413f5d39"
+checksum = "2eb6ec270a31b1d3c7e266b999739109abce8b6c87e4b31fcfcd788b65267395"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -2634,9 +3411,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.78"
+version = "0.2.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9"
+checksum = "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -2644,9 +3421,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.78"
+version = "0.2.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab"
+checksum = "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2657,20 +3434,20 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.78"
+version = "0.2.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc"
+checksum = "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"
 
 [[package]]
 name = "wayland-client"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9108ec1c37f4774d0c2937ba1a6c23d1786b2152c4a13bd9fdb20e42d16e8841"
+checksum = "91223460e73257f697d9e23d401279123d36039a3f7a449e983f123292d4458f"
 dependencies = [
  "bitflags",
  "downcast-rs",
  "libc",
- "nix",
+ "nix 0.22.3",
  "scoped-tls",
  "wayland-commons",
  "wayland-scanner",
@@ -2679,11 +3456,11 @@ dependencies = [
 
 [[package]]
 name = "wayland-commons"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "265ef51b3b3e5c9ef098f10425c39624663f459c3821dcaacc4748be975f1beb"
+checksum = "94f6e5e340d7c13490eca867898c4cec5af56c27a5ffe5c80c6fc4708e22d33e"
 dependencies = [
- "nix",
+ "nix 0.22.3",
  "once_cell",
  "smallvec",
  "wayland-sys",
@@ -2691,20 +3468,20 @@ dependencies = [
 
 [[package]]
 name = "wayland-cursor"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c19bb6628daf4097e58b7911481e8371e13318d5a60894779901bd3267407a7"
+checksum = "c52758f13d5e7861fc83d942d3d99bf270c83269575e52ac29e5b73cb956a6bd"
 dependencies = [
- "nix",
+ "nix 0.22.3",
  "wayland-client",
  "xcursor",
 ]
 
 [[package]]
 name = "wayland-egl"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accf27d1e5e1f64ba30b683fd926c2c916cc1014bea3376fb258e80abf622e40"
+checksum = "83281d69ee162b59031c666385e93bde4039ec553b90c4191cdb128ceea29a3a"
 dependencies = [
  "wayland-client",
  "wayland-sys",
@@ -2712,9 +3489,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b3b6f1dc0193072ef4eadcb144da30d58c1f2895516c063804d213310703c8e"
+checksum = "60147ae23303402e41fe034f74fb2c35ad0780ee88a1c40ac09a3be1e7465741"
 dependencies = [
  "bitflags",
  "wayland-client",
@@ -2724,9 +3501,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-scanner"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaaf2bc85e7b9143159af96bd23d954a5abe391c4376db712320643280fdc6f4"
+checksum = "39a1ed3143f7a143187156a2ab52742e89dac33245ba505c17224df48939f9e0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2735,9 +3512,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-sys"
-version = "0.29.1"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba9e06acb775b3007f8d3094438306979e572d1d3b844d7a71557a84b055d959"
+checksum = "d9341df79a8975679188e37dab3889bfa57c44ac2cb6da166f519a81cbe452d4"
 dependencies = [
  "dlib",
  "lazy_static",
@@ -2746,9 +3523,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.55"
+version = "0.3.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38eb105f1c59d9eaa6b5cdc92b859d85b926e82cb2e0945cd0c9259faa6fe9fb"
+checksum = "c060b319f29dd25724f09a2ba1418f142f539b2be99fbf4d2d5a8f7330afb8eb"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -2776,19 +3553,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "webpki-roots"
-version = "0.22.1"
+name = "wepoll-ffi"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c475786c6f47219345717a043a37ec04cb4bc185e28853adcc4fa0a947eba630"
+checksum = "d743fdedc5c64377b5fc2bc036b01c7fd642205a0d96356034ae3404d49eb7fb"
 dependencies = [
- "webpki",
+ "cc",
 ]
 
 [[package]]
 name = "which"
-version = "4.2.2"
+version = "4.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
+checksum = "2a5a7e487e921cf220206864a94a89b6c6905bfc19f1057fa26a4cb360e5c1d2"
 dependencies = [
  "either",
  "lazy_static",
@@ -2834,9 +3611,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aac7fef12f4b59cd0a29339406cc9203ab44e440ddff6b3f5a41455349fa9cf3"
+checksum = "b749ebd2304aa012c5992d11a25d07b406bdbe5f79d371cb7a918ce501a19eb0"
 dependencies = [
  "windows_aarch64_msvc",
  "windows_i686_gnu",
@@ -2847,42 +3624,41 @@ dependencies = [
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d027175d00b01e0cbeb97d6ab6ebe03b12330a35786cbaca5252b1c4bf5d9b"
+checksum = "29277a4435d642f775f63c7d1faeb927adba532886ce0287bd985bffb16b6bca"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8793f59f7b8e8b01eda1a652b2697d87b93097198ae85f823b969ca5b89bba58"
+checksum = "1145e1989da93956c68d1864f32fb97c8f561a8f89a5125f6a2b7ea75524e4b8"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8602f6c418b67024be2996c512f5f995de3ba417f4c75af68401ab8756796ae4"
+checksum = "d4a09e3a0d4753b73019db171c1339cd4362c8c44baf1bcea336235e955954a6"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3d615f419543e0bd7d2b3323af0d86ff19cbc4f816e6453f36a2c2ce889c354"
+checksum = "8ca64fcb0220d58db4c119e050e7af03c69e6f4f415ef69ec1773d9aab422d5a"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d95421d9ed3672c280884da53201a5c46b7b2765ca6faf34b0d71cf34a3561"
+checksum = "08cabc9f0066848fef4bc6a1c1668e6efce38b661d2aeec75d18d8617eebb5f1"
 
 [[package]]
 name = "winit"
-version = "0.26.0"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70466a5f4825cc88c92963591b06dbc255420bffe19d847bfcda475e82d079c0"
+checksum = "9b43cc931d58b99461188607efd7acb2a093e65fc621f54cad78517a6063e73a"
 dependencies = [
  "bitflags",
- "block",
  "cocoa",
  "core-foundation 0.9.2",
  "core-graphics 0.22.3",
@@ -2893,9 +3669,9 @@ dependencies = [
  "libc",
  "log",
  "mio",
- "ndk",
- "ndk-glue",
- "ndk-sys",
+ "ndk 0.5.0",
+ "ndk-glue 0.5.0",
+ "ndk-sys 0.2.2",
  "objc",
  "parking_lot",
  "percent-encoding",
@@ -2909,6 +3685,15 @@ dependencies = [
  "x11-dl",
 ]
 
+[[package]]
+name = "winreg"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d107f8c6e916235c4c01cabb3e8acf7bea8ef6a63ca2e7fa0527c049badfc48c"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "x11-clipboard"
 version = "0.5.3"
@@ -2963,3 +3748,90 @@ checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
 dependencies = [
  "linked-hash-map",
 ]
+
+[[package]]
+name = "zbus"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb86f3d4592e26a48b2719742aec94f8ae6238ebde20d98183ee185d1275e9a"
+dependencies = [
+ "async-broadcast",
+ "async-channel",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "async-recursion",
+ "async-task",
+ "async-trait",
+ "byteorder",
+ "derivative",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "hex",
+ "lazy_static",
+ "nix 0.23.1",
+ "once_cell",
+ "ordered-stream",
+ "rand",
+ "serde",
+ "serde_repr",
+ "sha1",
+ "static_assertions",
+ "winapi",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36823cc10fddc3c6b19f048903262dacaf8274170e9a255784bdd8b4570a8040"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "syn",
+]
+
+[[package]]
+name = "zbus_names"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45dfcdcf87b71dad505d30cc27b1b7b88a64b6d1c435648f48f9dbc1fdc4b7e1"
+dependencies = [
+ "serde",
+ "static_assertions",
+ "zvariant",
+]
+
+[[package]]
+name = "zvariant"
+version = "3.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49ea5dc38b2058fae6a5b79009388143dadce1e91c26a67f984a0fc0381c8033"
+dependencies = [
+ "byteorder",
+ "enumflags2",
+ "libc",
+ "serde",
+ "static_assertions",
+ "zvariant_derive",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "3.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c2cecc5a61c2a053f7f653a24cd15b3b0195d7f7ddb5042c837fb32e161fb7a"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index a8113833..da9c7db1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,3 +25,6 @@ opt-level = 2 # fast and small wasm, basically same as `opt-level = 's'`
 # opt-level = 3 # unecessarily large wasm for no performance gain
 
 # debug = true # include debug symbols, useful when profiling wasm
+
+[patch.crates-io]
+ureq = { git = "https://github.com/emilk/ureq/", branch = "opt-in-webpki-roots" } # See https://github.com/algesten/ureq/pull/479 / https://github.com/algesten/ureq/issues/478
diff --git a/README.md b/README.md
index ab50bdd0..946e8cdc 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@
 ![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
 [![Discord](https://img.shields.io/discord/900275882684477440?label=egui%20discord)](https://discord.gg/JFcEma9bJq)
 
+👉 [Click to run the web demo](https://www.egui.rs/#demo) 👈
 
 egui is a simple, fast, and highly portable immediate mode GUI library for Rust. egui runs on the web, natively, and [in your favorite game engine](#integrations) (or will soon).
 
@@ -18,43 +19,19 @@ egui can be used anywhere you can draw textured triangles, which means you can e
 
 Sections:
 
+* [Example](#example)
 * [Quick start](#quick-start)
 * [Demo](#demo)
 * [Goals](#goals)
 * [Who is egui for?](#who-is-egui-for)
 * [State / features](#state)
-* [How it works](#how-it-works)
 * [Integrations](#integrations)
 * [Why immediate mode](#why-immediate-mode)
 * [FAQ](#faq)
 * [Other](#other)
 * [Credits](#credits)
 
-## Quick start
-
-If you just want to write a GUI application in Rust (for the web or for native), go to <https://github.com/emilk/eframe_template/> and follow the instructions there! The official docs are at <https://docs.rs/egui>. For inspiration, check out the [the egui web demo](https://emilk.github.io/egui/index.html) and follow the links in it to its source code. There is also an excellent tutorial video at <https://www.youtube.com/watch?v=NtUkr_z7l84>.
-
-If you want to integrate egui into an existing engine, go to the [Integrations](#integrations) section.
-
-If you have questions, use [GitHub Discussions](https://github.com/emilk/egui/discussions). There is also [an egui discord server](https://discord.gg/JFcEma9bJq). If you want to contribute to egui, please read the [Contributing Guidelines](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md).
-
-## Demo
-
-[Click to run egui web demo](https://emilk.github.io/egui/index.html) (works in any browser with WASM and WebGL support). Uses [`egui_web`](https://github.com/emilk/egui/tree/master/egui_web).
-
-To test the demo app locally, run `cargo run --release -p egui_demo_app`.
-
-The native backend is [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow) (using [`glow`](https://crates.io/crates/glow)) and should work out-of-the-box on Mac and Windows, but on Linux you need to first run:
-
-`sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libspeechd-dev libxkbcommon-dev libssl-dev`
-
-On Fedora Rawhide you need to run:
-
-`dnf install clang clang-devel clang-tools-extra speech-dispatcher-devel libxkbcommon-devel pkg-config openssl-devel libxcb-devel`
-
-**NOTE**: This is just for the demo app - egui itself is completely platform agnostic!
-
-### Example
+## Example
 
 ``` rust
 ui.heading("My egui Application");
@@ -71,6 +48,30 @@ ui.label(format!("Hello '{}', age {}", name, age));
 
 <img src="media/demo.gif">
 
+## Quick start
+
+If you just want to write a GUI application in Rust (for the web or for native), go to <https://github.com/emilk/eframe_template/> and follow the instructions there! The official docs are at <https://docs.rs/egui>. For inspiration, check out the [the egui web demo](https://www.egui.rs/#demo) and follow the links in it to its source code. There is also an excellent tutorial video at <https://www.youtube.com/watch?v=NtUkr_z7l84>.
+
+If you want to integrate egui into an existing engine, go to the [Integrations](#integrations) section.
+
+If you have questions, use [GitHub Discussions](https://github.com/emilk/egui/discussions). There is also [an egui discord server](https://discord.gg/JFcEma9bJq). If you want to contribute to egui, please read the [Contributing Guidelines](https://github.com/emilk/egui/blob/master/CONTRIBUTING.md).
+
+## Demo
+
+[Click to run egui web demo](https://www.egui.rs/#demo) (works in any browser with WASM and WebGL support). Uses [`egui_web`](https://github.com/emilk/egui/tree/master/egui_web).
+
+To test the demo app locally, run `cargo run --release -p egui_demo_app`.
+
+The native backend is [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow) (using [`glow`](https://crates.io/crates/glow)) and should work out-of-the-box on Mac and Windows, but on Linux you need to first run:
+
+`sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libspeechd-dev libxkbcommon-dev libssl-dev`
+
+On Fedora Rawhide you need to run:
+
+`dnf install clang clang-devel clang-tools-extra speech-dispatcher-devel libxkbcommon-devel pkg-config openssl-devel libxcb-devel`
+
+**NOTE**: This is just for the demo app - egui itself is completely platform agnostic!
+
 ## Goals
 
 * The easiest to use GUI library
@@ -145,72 +146,75 @@ Light Theme:
 
 <img src="media/light_theme.png" width="50%">
 
-## How it works
-
-Loop:
-
-* Gather input (mouse, touches, keyboard, screen size, etc) and give it to egui
-* Run application code (Immediate Mode GUI)
-* Tell egui to tessellate the frame graphics to a triangle mesh
-* Render the triangle mesh with your favorite graphics API (see [OpenGL example](https://github.com/emilk/egui/blob/master/egui_glium/src/painter.rs)) or use `eframe`, the egui framework crate.
-
 ## Integrations
 
 egui is build to be easy to integrate into any existing game engine or platform you are working on.
 egui itself doesn't know or care on what OS it is running or how to render things to the screen - that is the job of the egui integration.
-The integration needs to do two things:
 
-* **IO**: Supply egui with input (mouse position, keyboard presses, …) and handle egui output (cursor changes, copy-paste integration, …).
-* **Painting**: Render the textured triangles that egui outputs.
+An integration needs to do the following each frame:
 
-### Official
+* **Input**: Gather input (mouse, touches, keyboard, screen size, etc) and give it to egui
+* Run the application code
+* **Output**: Handle egui output (cursor changes, paste, texture allocations, …)
+* **Painting**: Render the triangle mesh egui produces (see [OpenGL example](https://github.com/emilk/egui/blob/master/egui_glium/src/painter.rs))
 
-There are three official egui integrations made for apps:
+### Official integrations
+
+If you making an app, your best bet is using [`eframe`](https://github.com/emilk/egui/tree/master/eframe), the official egui framework. It lets you write apps that works on both the web and native. `eframe` is just a thin wrapper over `egui_web` and `egui_glium` (see below).
+
+These are the official egui integrations:
 
-* [`egui_web`](https://github.com/emilk/egui/tree/master/egui_web) for making a web app. Compiles to WASM, renders with WebGL. [Click to run the egui demo](https://emilk.github.io/egui/index.html).
 * [`egui_glium`](https://github.com/emilk/egui/tree/master/egui_glium) for compiling native apps with [Glium](https://github.com/glium/glium).
 * [`egui_glow`](https://github.com/emilk/egui/tree/master/egui_glow) for compiling native apps with [Glow](https://github.com/grovesNL/glow).
-* [`egui-winit`](https://github.com/emilk/egui/tree/master/egui-winit) for integrating with [`winit`](https://github.com/rust-windowing/winit). `egui-winit` is used by `egui_glium` and `egui_glow`.
+* [`egui_web`](https://github.com/emilk/egui/tree/master/egui_web) for making a web app. Compiles to WASM, renders with WebGL. [Click to run the egui demo](https://www.egui.rs/#demo).
+* [`egui-winit`](https://github.com/emilk/egui/tree/master/egui-winit) for integrating with [winit](https://github.com/rust-windowing/winit). `egui-winit` is used by `egui_glium` and `egui_glow`.
 
-If you making an app, consider using [`eframe`](https://github.com/emilk/egui/tree/master/eframe), a framework which allows you to write code that works on both the web (`egui_web`) and native (using `egui_glium`).
-
-### 3rd party
+### 3rd party integrations
 
 * [`amethyst_egui`](https://github.com/jgraef/amethyst_egui) for [the Amethyst game engine](https://amethyst.rs/).
 * [`bevy_egui`](https://github.com/mvlabat/bevy_egui) for [the Bevy game engine](https://bevyengine.org/).
 * [`egui_glfw_gl`](https://github.com/cohaereo/egui_glfw_gl) for [GLFW](https://crates.io/crates/glfw).
-* [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad) for [Miniquad](https://github.com/not-fl3/miniquad).
-* [`egui-macroquad`](https://github.com/optozorax/egui-macroquad) for [macroquad](https://github.com/not-fl3/macroquad).
 * [`egui_sdl2_gl`](https://crates.io/crates/egui_sdl2_gl) for [SDL2](https://crates.io/crates/sdl2).
 * [`egui_vulkano`](https://github.com/derivator/egui_vulkano) for [Vulkano](https://github.com/vulkano-rs/vulkano).
-* [`egui-winit-ash-integration`](https://github.com/MatchaChoco010/egui-winit-ash-integration) for [winit](https://github.com/rust-windowing/winit) and [ash](https://github.com/MaikKlein/ash).
+* [`egui_wgpu_backend`](https://crates.io/crates/egui_wgpu_backend) for [wgpu](https://crates.io/crates/wgpu) (WebGPU API).
 * [`egui_winit_vulkano`](https://github.com/hakolao/egui_winit_vulkano) for [Vulkano](https://github.com/vulkano-rs/vulkano).
+* [`egui-macroquad`](https://github.com/optozorax/egui-macroquad) for [macroquad](https://github.com/not-fl3/macroquad).
+* [`egui-miniquad`](https://github.com/not-fl3/egui-miniquad) for [Miniquad](https://github.com/not-fl3/miniquad).
+* [`egui-tetra`](https://crates.io/crates/egui-tetra) for [Tetra](https://crates.io/crates/tetra), a 2D game framework.
+* [`egui-winit-ash-integration`](https://github.com/MatchaChoco010/egui-winit-ash-integration) for [winit](https://github.com/rust-windowing/winit) and [ash](https://github.com/MaikKlein/ash).
 * [`fltk-egui`](https://crates.io/crates/fltk-egui) for [fltk-rs](https://github.com/fltk-rs/fltk-rs).
 * [`ggez-egui`](https://github.com/NemuiSen/ggez-egui) for the [ggez](https://ggez.rs/) game framework.
-* [`godot-egui`](https://github.com/setzer22/godot-egui) for [`godot-rust`](https://github.com/godot-rust/godot-rust).
+* [`godot-egui`](https://github.com/setzer22/godot-egui) for [godot-rust](https://github.com/godot-rust/godot-rust).
 * [`nannou_egui`](https://github.com/AlexEne/nannou_egui) for [nannou](https://nannou.cc).
-* [`egui-tetra`](https://crates.io/crates/egui-tetra) for [Tetra](https://crates.io/crates/tetra), a 2D game framework.
-* [`egui_wgpu_backend`](https://crates.io/crates/egui_wgpu_backend) for [`wgpu`](https://crates.io/crates/wgpu) (WebGPU API).
+* [`smithay-egui`](https://github.com/Smithay/smithay-egui) for [smithay](https://github.com/Smithay/smithay/).
 
-Missing an integration for the thing you're working on? Create one, it is easy!
+Missing an integration for the thing you're working on? Create one, it's easy!
 
 ### Writing your own egui integration
 
-You need to collect [`egui::RawInput`](https://docs.rs/egui/latest/egui/struct.RawInput.html), paint [`egui::ClippedMesh`](https://docs.rs/epaint/):es and handle [`egui::Output`](https://docs.rs/egui/latest/egui/struct.Output.html). The basic structure is this:
+You need to collect [`egui::RawInput`](https://docs.rs/egui/latest/egui/struct.RawInput.html), paint [`egui::ClippedMesh`](https://docs.rs/epaint/latest/epaint/struct.ClippedMesh.html):es and handle [`egui::Output`](https://docs.rs/egui/latest/egui/struct.Output.html). The basic structure is this:
 
 ``` rust
 let mut egui_ctx = egui::CtxRef::default();
 
 // Game loop:
 loop {
+    // Gather input (mouse, touches, keyboard, screen size, etc):
     let raw_input: egui::RawInput = my_integration.gather_input();
     let (output, shapes) = egui_ctx.run(raw_input, |egui_ctx| {
         my_app.ui(egui_ctx); // add panels, windows and widgets to `egui_ctx` here
     });
-    let clipped_meshes = egui_ctx.tessellate(shapes); // create triangles to paint
+    let clipped_meshes = egui_ctx.tessellate(shapes); // creates triangles to paint
+
+    my_integration.set_egui_textures(&output.textures_delta.set);
     my_integration.paint(clipped_meshes);
+    my_integration.free_egui_textures(&output.textures_delta.free);
+
     my_integration.set_cursor_icon(output.cursor_icon);
-    // Also see `egui::Output` for more
+    if !output.copied_text.is_empty() {
+        my_integration.set_clipboard_text(output.copied_text);
+    }
+    // See `egui::Output` for more
 }
 ```
 
@@ -231,11 +235,12 @@ For a reference OpenGL backend, see [the `egui_glium` painter](https://github.co
 
 * egui uses premultiplied alpha, so make sure your blending function is `(ONE, ONE_MINUS_SRC_ALPHA)`.
 * Make sure your texture sampler is clamped (`GL_CLAMP_TO_EDGE`).
-* Use an sRGBA-aware texture if available (e.g. `GL_SRGB8_ALPHA8`).
-  * Otherwise: remember to decode gamma in the fragment shader.
-* Decode the gamma of the incoming vertex colors in your vertex shader.
-* Turn on sRGBA/linear framebuffer if available (`GL_FRAMEBUFFER_SRGB`).
-  * Otherwise: gamma-encode the colors before you write them again.
+* egui prefers linear color spaces for all blending so:
+  * Use an sRGBA-aware texture if available (e.g. `GL_SRGB8_ALPHA8`).
+    * Otherwise: remember to decode gamma in the fragment shader.
+  * Decode the gamma of the incoming vertex colors in your vertex shader.
+  * Turn on sRGBA/linear framebuffer if available (`GL_FRAMEBUFFER_SRGB`).
+    * Otherwise: gamma-encode the colors before you write them again.
 
 
 ## Why immediate mode
@@ -301,7 +306,7 @@ Yes! But you need to install your own font (`.ttf` or `.otf`) using `Context::se
 Yes! You can customize the colors, spacing and sizes of everything. By default egui comes with a dark and a light theme.
 
 ### What about accessibility, such as screen readers?
-There is experimental support for a screen reader. In [the web demo](https://emilk.github.io/egui/index.html) you can enable it in the "Backend" tab.
+There is experimental support for a screen reader. In [the web demo](https://www.egui.rs/#demo) you can enable it in the "Backend" tab.
 
 Read more at <https://github.com/emilk/egui/issues/167>.
 
@@ -365,10 +370,13 @@ Notable contributions by:
 * [@AlexApps99](https://github.com/AlexApps99): [`egui_glow`](https://github.com/emilk/egui/pull/685).
 * [@mankinskin](https://github.com/mankinskin): [Context menus](https://github.com/emilk/egui/pull/543).
 * [@t18b219k](https://github.com/t18b219k): [Port glow painter to web](https://github.com/emilk/egui/pull/868).
+* [@danielkeller](https://github.com/danielkeller): [`Context` refactor](https://github.com/emilk/egui/pull/1050).
 * And [many more](https://github.com/emilk/egui/graphs/contributors?type=a).
 
 egui is licensed under [MIT](LICENSE-MIT) OR [Apache-2.0](LICENSE-APACHE).
 
+* The flattening algorithm for the cubic bezier curve and quadratic bezier curve is from [lyon_geom](https://docs.rs/lyon_geom/latest/lyon_geom/)
+
 Default fonts:
 
 * `emoji-icon-font.ttf`: [Copyright (c) 2014 John Slegers](https://github.com/jslegers/emoji-icon-font) , MIT License
diff --git a/deny.toml b/deny.toml
new file mode 100644
index 00000000..afd1bb45
--- /dev/null
+++ b/deny.toml
@@ -0,0 +1,68 @@
+# https://embarkstudios.github.io/cargo-deny/
+
+targets = [
+    { triple = "aarch64-apple-darwin" },
+    { triple = "aarch64-linux-android" },
+    { triple = "x86_64-apple-darwin" },
+    { triple = "x86_64-pc-windows-msvc" },
+    { triple = "x86_64-unknown-linux-gnu" },
+    { triple = "x86_64-unknown-linux-musl" },
+]
+
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+yanked = "deny"
+ignore = [
+    "RUSTSEC-2020-0071", # https://rustsec.org/advisories/RUSTSEC-2020-0071 - chrono/time: Potential segfault in the time crate
+    "RUSTSEC-2020-0159", # https://rustsec.org/advisories/RUSTSEC-2020-0159 - chrono/time: Potential segfault in localtime_r invocations
+    "RUSTSEC-2021-0019", # https://rustsec.org/advisories/RUSTSEC-2021-0019 - xcb - is being worked on: https://github.com/rust-x-bindings/rust-xcb/issues/107
+]
+
+[bans]
+multiple-versions = "deny"
+wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+deny = [
+    { name = "openssl" },           # prefer rustls
+    { name = "openssl-sys" },       # prefer rustls
+]
+
+skip = [
+    { name = "time" }, # old version pulled in by unmaintianed crate 'chrono'
+]
+skip-tree = [
+    { name = "eframe", version = "0.16.0" },
+]
+
+
+[licenses]
+unlicensed = "deny"
+allow-osi-fsf-free = "neither"
+confidence-threshold = 0.92 # We want really high confidence when inferring licenses from text
+copyleft = "deny"
+allow = [
+    "Apache-2.0 WITH LLVM-exception", # https://spdx.org/licenses/LLVM-exception.html
+    "Apache-2.0",                     # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
+    "BSD-2-Clause",                   # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
+    "BSD-3-Clause",                   # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
+    "BSL-1.0",                        # https://tldrlegal.com/license/boost-software-license-1.0-explained
+    "CC0-1.0",                        # https://creativecommons.org/publicdomain/zero/1.0/
+    "ISC",                            # https://tldrlegal.com/license/-isc-license
+    "MIT",                            # https://tldrlegal.com/license/mit-license
+    "OpenSSL",                        # https://www.openssl.org/source/license.html
+    "Zlib",                           # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
+]
+
+[[licenses.clarify]]
+name = "webpki"
+expression = "ISC"
+license-files = [
+    { path = "LICENSE", hash = 0x001c7e6c }
+]
+
+[[licenses.clarify]]
+name = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [
+    { path = "LICENSE", hash = 0xbd0eed23 }
+]
diff --git a/docs/CNAME b/docs/CNAME
new file mode 100644
index 00000000..ce62e6b7
--- /dev/null
+++ b/docs/CNAME
@@ -0,0 +1 @@
+www.egui.rs
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
index 077fb745..7cc35cfc 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,3 +1,3 @@
-This folder contains the files required for the egui web demo hosted at <https://emilk.github.io/egui/>.
+This folder contains the files required for the egui web demo hosted at <https://www.egui.rs/>.
 
 The reason the folder is called "docs" is because that is the name that GitHub requires in order to host a web page from the `master` branch of a repository.
diff --git a/docs/example.html b/docs/example.html
index 45e2cc3b..9caf23db 100644
--- a/docs/example.html
+++ b/docs/example.html
@@ -3,7 +3,7 @@
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
 <head>
-    <meta http-equiv="refresh" content="0; url = https://emilk.github.io/egui/#http" />
+    <meta http-equiv="refresh" content="0; url = https://www.egui.rs/#http" />
 </head>
 
 <body>
diff --git a/docs/index.html b/docs/index.html
index 47975923..6d3a5588 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -46,7 +46,7 @@
             transform: translate(-50%, 0%);
         }
 
-        .loading {
+        .centered {
             margin-right: auto;
             margin-left: auto;
             display: block;
@@ -54,9 +54,10 @@
             top: 50%;
             left: 50%;
             transform: translate(-50%, -50%);
-            color: white;
+            color: #f0f0f0;
             font-size: 24px;
             font-family: Ubuntu-Light, Helvetica, sans-serif;
+            text-align: center;
         }
 
         /* ---------------------------------------------- */
@@ -94,8 +95,10 @@
 <body>
     <!-- The WASM code will resize the canvas dynamically -->
     <canvas id="the_canvas_id"></canvas>
-    <div class="loading" id="loading">
-        Loading…&nbsp;&nbsp;
+    <div class="centered" id="center_text">
+        <p style="font-size:16px">
+            Loading…
+        </p>
         <div class="lds-dual-ring"></div>
     </div>
 
@@ -119,18 +122,33 @@
         // We'll defer our execution until the wasm is ready to go.
         // Here we tell bindgen the path to the wasm file so it can start
         // initialization and return to us a promise when it's done.
+        console.debug("loading wasm…");
         wasm_bindgen("./egui_demo_app_bg.wasm")
             .then(on_wasm_loaded)
-            .catch(console.error);
+            .catch(on_wasm_error);
 
         function on_wasm_loaded() {
-            console.log("loaded wasm, starting egui app…");
+            console.debug("wasm loaded. starting egui app…");
 
             // This call installs a bunch of callbacks and then returns:
             wasm_bindgen.start("the_canvas_id");
 
-            console.log("egui app started.");
-            document.getElementById("loading").remove();
+            console.debug("egui app started.");
+            document.getElementById("center_text").remove();
+        }
+
+        function on_wasm_error(error) {
+            console.error("Failed to start egui: " + error);
+            document.getElementById("center_text").innerHTML = `
+                <p>
+                    An error occurred loading egui
+                </p>
+                <p style="font-family:Courier New">
+                    ${error}
+                </p>
+                <p style="font-size:14px">
+                    Make sure you use a modern browser with WebGL and WASM enabled.
+                </p>`;
         }
     </script>
 </body>
diff --git a/eframe/CHANGELOG.md b/eframe/CHANGELOG.md
index a6480965..5b64eafa 100644
--- a/eframe/CHANGELOG.md
+++ b/eframe/CHANGELOG.md
@@ -1,12 +1,19 @@
 # Changelog for eframe
 All notable changes to the `eframe` and `epi` crates.
 
-NOTE: [`egui_web`](egui_web/CHANGELOG.md), [`egui-winit`](egui-winit/CHANGELOG.md), [`egui_glium`](egui_glium/CHANGELOG.md), and [`egui_glow`](egui_glow/CHANGELOG.md) have their own changelogs!
+NOTE: [`egui_web`](../egui_web/CHANGELOG.md), [`egui-winit`](../egui-winit/CHANGELOG.md), [`egui_glium`](../egui_glium/CHANGELOG.md), and [`egui_glow`](../egui_glow/CHANGELOG.md) have their own changelogs!
 
 
 ## Unreleased
+* Removed `Frame::alloc_texture`. Use `egui::Context::load_texture` instead ([#1110](https://github.com/emilk/egui/pull/1110)).
 * The default native backend is now `egui_glow` (instead of `egui_glium`) ([#1020](https://github.com/emilk/egui/pull/1020)).
 * The default web painter is now `egui_glow` (instead of WebGL) ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+* Fix horizontal scrolling direction on Linux.
+* Added `App::on_exit_event` ([#1038](https://github.com/emilk/egui/pull/1038))
+* Added `NativeOptions::initial_window_pos`.
+* Shift-scroll will now result in horizontal scrolling on all platforms ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Log using the `tracing` crate. Log to stdout by adding `tracing_subscriber::fmt::init();` to your `main` ([#1192](https://github.com/emilk/egui/pull/1192)).
 
 
 ## 0.16.0 - 2021-12-29
diff --git a/eframe/Cargo.toml b/eframe/Cargo.toml
index a01d380a..35265b99 100644
--- a/eframe/Cargo.toml
+++ b/eframe/Cargo.toml
@@ -23,23 +23,6 @@ all-features = true
 
 [lib]
 
-[dependencies]
-egui = { version = "0.16.0", path = "../egui", default-features = false }
-epi = { version = "0.16.0", path = "../epi" }
-
-# native:
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-egui-winit = { version = "0.16.0", path = "../egui-winit", default-features = false }
-egui_glium = { version = "0.16.0", path = "../egui_glium", default-features = false, features = ["clipboard", "epi", "links"], optional = true }
-egui_glow = { version = "0.16.0", path = "../egui_glow", default-features = false, features = ["clipboard", "epi", "links", "winit"], optional = true }
-
-# web:
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-egui_web = { version = "0.16.0", path = "../egui_web", default-features = false, features = ["glow"] }
-
-[dev-dependencies]
-image = { version = "0.23", default-features = false, features = ["png"] }
-rfd = "0.6"
 
 [features]
 default = ["default_fonts", "egui_glow"]
@@ -57,9 +40,31 @@ persistence = [
   "epi/persistence",
 ]
 
-# experimental support for a screen reader
+# enable screen reader support (requires `ctx.options().screen_reader = true;`)
 screen_reader = [
   # we cannot touch egui_glium or egui_glow here due to https://github.com/rust-lang/cargo/issues/8832
   "egui-winit/screen_reader",
   "egui_web/screen_reader",
 ]
+
+
+[dependencies]
+egui = { version = "0.16.0", path = "../egui", default-features = false }
+epi = { version = "0.16.0", path = "../epi" }
+
+# native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+egui-winit = { version = "0.16.0", path = "../egui-winit", default-features = false }
+egui_glium = { version = "0.16.0", path = "../egui_glium", default-features = false, features = ["clipboard", "epi", "links"], optional = true }
+egui_glow = { version = "0.16.0", path = "../egui_glow", default-features = false, features = ["clipboard", "epi", "links", "winit"], optional = true }
+
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+egui_web = { version = "0.16.0", path = "../egui_web", default-features = false, features = ["glow"] }
+
+[dev-dependencies]
+ehttp = "0.2"
+image = { version = "0.24", default-features = false, features = ["jpeg", "png"] }
+poll-promise = "0.1"
+rfd = "0.7"
+
diff --git a/eframe/examples/confirm_exit.rs b/eframe/examples/confirm_exit.rs
new file mode 100644
index 00000000..f1e8a359
--- /dev/null
+++ b/eframe/examples/confirm_exit.rs
@@ -0,0 +1,49 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::{egui, epi};
+
+#[derive(Default)]
+struct MyApp {
+    can_exit: bool,
+    is_exiting: bool,
+}
+
+impl epi::App for MyApp {
+    fn name(&self) -> &str {
+        "Confirm exit"
+    }
+
+    fn on_exit_event(&mut self) -> bool {
+        self.is_exiting = true;
+        self.can_exit
+    }
+
+    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Try to close the window");
+        });
+
+        if self.is_exiting {
+            egui::Window::new("Do you want to quit?")
+                .collapsible(false)
+                .resizable(false)
+                .show(ctx, |ui| {
+                    ui.horizontal(|ui| {
+                        if ui.button("Yes!").clicked() {
+                            self.can_exit = true;
+                            frame.quit();
+                        }
+
+                        if ui.button("Not yet").clicked() {
+                            self.is_exiting = false;
+                        }
+                    });
+                });
+        }
+    }
+}
+
+fn main() {
+    let options = eframe::NativeOptions::default();
+    eframe::run_native(Box::new(MyApp::default()), options);
+}
diff --git a/eframe/examples/custom_font.rs b/eframe/examples/custom_font.rs
index 199521da..8ba2ced4 100644
--- a/eframe/examples/custom_font.rs
+++ b/eframe/examples/custom_font.rs
@@ -19,7 +19,7 @@ impl epi::App for MyApp {
 
     fn setup(
         &mut self,
-        ctx: &egui::CtxRef,
+        ctx: &egui::Context,
         _frame: &epi::Frame,
         _storage: Option<&dyn epi::Storage>,
     ) {
@@ -35,14 +35,14 @@ impl epi::App for MyApp {
 
         // Put my font first (highest priority) for proportional text:
         fonts
-            .fonts_for_family
+            .families
             .entry(egui::FontFamily::Proportional)
             .or_default()
             .insert(0, "my_font".to_owned());
 
         // Put my font as last fallback for monospace:
         fonts
-            .fonts_for_family
+            .families
             .entry(egui::FontFamily::Monospace)
             .or_default()
             .push("my_font".to_owned());
@@ -51,7 +51,7 @@ impl epi::App for MyApp {
         ctx.set_fonts(fonts);
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, _frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, _frame: &epi::Frame) {
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("egui using custom fonts");
             ui.text_edit_multiline(&mut self.text);
diff --git a/eframe/examples/download_image.rs b/eframe/examples/download_image.rs
new file mode 100644
index 00000000..e350ac56
--- /dev/null
+++ b/eframe/examples/download_image.rs
@@ -0,0 +1,81 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+
+use eframe::{egui, epi};
+use poll_promise::Promise;
+
+fn main() {
+    let options = eframe::NativeOptions::default();
+    eframe::run_native(Box::new(MyApp::default()), options);
+}
+
+#[derive(Default)]
+struct MyApp {
+    /// `None` when download hasn't started yet.
+    promise: Option<Promise<ehttp::Result<egui::TextureHandle>>>,
+}
+
+impl epi::App for MyApp {
+    fn name(&self) -> &str {
+        "Download and show an image with eframe/egui"
+    }
+
+    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
+        let promise = self.promise.get_or_insert_with(|| {
+            // Begin download.
+            // We download the image using `ehttp`, a library that works both in WASM and on native.
+            // We use the `poll-promise` library to communicate with the UI thread.
+            let ctx = ctx.clone();
+            let frame = frame.clone();
+            let (sender, promise) = Promise::new();
+            let request = ehttp::Request::get("https://picsum.photos/seed/1.759706314/1024");
+            ehttp::fetch(request, move |response| {
+                frame.request_repaint(); // wake up UI thread
+                let texture = response.and_then(|response| parse_response(&ctx, response));
+                sender.send(texture); // send the results back to the UI thread.
+            });
+            promise
+        });
+
+        egui::CentralPanel::default().show(ctx, |ui| match promise.ready() {
+            None => {
+                ui.add(egui::Spinner::new()); // still loading
+            }
+            Some(Err(err)) => {
+                ui.colored_label(egui::Color32::RED, err); // something went wrong
+            }
+            Some(Ok(texture)) => {
+                let mut size = texture.size_vec2();
+                size *= (ui.available_width() / size.x).min(1.0);
+                size *= (ui.available_height() / size.y).min(1.0);
+                ui.image(texture, size);
+            }
+        });
+    }
+}
+
+fn parse_response(
+    ctx: &egui::Context,
+    response: ehttp::Response,
+) -> Result<egui::TextureHandle, String> {
+    let content_type = response.content_type().unwrap_or_default();
+    if content_type.starts_with("image/") {
+        let image = load_image(&response.bytes).map_err(|err| err.to_string())?;
+        Ok(ctx.load_texture("my-image", image))
+    } else {
+        Err(format!(
+            "Expected image, found content-type {:?}",
+            content_type
+        ))
+    }
+}
+
+fn load_image(image_data: &[u8]) -> Result<egui::ColorImage, image::ImageError> {
+    let image = image::load_from_memory(image_data)?;
+    let size = [image.width() as _, image.height() as _];
+    let image_buffer = image.to_rgba8();
+    let pixels = image_buffer.as_flat_samples();
+    Ok(egui::ColorImage::from_rgba_unmultiplied(
+        size,
+        pixels.as_slice(),
+    ))
+}
diff --git a/eframe/examples/file_dialog.rs b/eframe/examples/file_dialog.rs
index b9767e3e..f4b2f5a9 100644
--- a/eframe/examples/file_dialog.rs
+++ b/eframe/examples/file_dialog.rs
@@ -13,7 +13,7 @@ impl epi::App for MyApp {
         "Native file dialogs and drag-and-drop files"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, _frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, _frame: &epi::Frame) {
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.label("Drag-and-drop files onto the window!");
 
@@ -57,7 +57,7 @@ impl epi::App for MyApp {
 }
 
 impl MyApp {
-    fn detect_files_being_dropped(&mut self, ctx: &egui::CtxRef) {
+    fn detect_files_being_dropped(&mut self, ctx: &egui::Context) {
         use egui::*;
 
         // Preview hovering files:
@@ -82,7 +82,7 @@ impl MyApp {
                 screen_rect.center(),
                 Align2::CENTER_CENTER,
                 text,
-                TextStyle::Heading,
+                TextStyle::Heading.resolve(&ctx.style()),
                 Color32::WHITE,
             );
         }
diff --git a/eframe/examples/hello_world.rs b/eframe/examples/hello_world.rs
index 9a944929..7ec61fba 100644
--- a/eframe/examples/hello_world.rs
+++ b/eframe/examples/hello_world.rs
@@ -21,7 +21,7 @@ impl epi::App for MyApp {
         "My egui App"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
         let Self { name, age } = self;
 
         egui::CentralPanel::default().show(ctx, |ui| {
diff --git a/eframe/examples/image.rs b/eframe/examples/image.rs
index 91e0f4f5..a47e6c5b 100644
--- a/eframe/examples/image.rs
+++ b/eframe/examples/image.rs
@@ -4,7 +4,7 @@ use eframe::{egui, epi};
 
 #[derive(Default)]
 struct MyApp {
-    texture: Option<(egui::Vec2, egui::TextureId)>,
+    texture: Option<egui::TextureHandle>,
 }
 
 impl epi::App for MyApp {
@@ -12,31 +12,18 @@ impl epi::App for MyApp {
         "Show an image with eframe/egui"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
-        if self.texture.is_none() {
-            // Load the image:
-            let image_data = include_bytes!("rust-logo-256x256.png");
-            use image::GenericImageView;
-            let image = image::load_from_memory(image_data).expect("Failed to load image");
-            let image_buffer = image.to_rgba8();
-            let size = [image.width() as usize, image.height() as usize];
-            let pixels = image_buffer.into_vec();
-            let image = epi::Image::from_rgba_unmultiplied(size, &pixels);
-
-            // Allocate a texture:
-            let texture = frame.alloc_texture(image);
-            let size = egui::Vec2::new(size[0] as f32, size[1] as f32);
-            self.texture = Some((size, texture));
-        }
+    fn update(&mut self, ctx: &egui::Context, _frame: &epi::Frame) {
+        let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+            let image = load_image(include_bytes!("rust-logo-256x256.png")).unwrap();
+            ctx.load_texture("rust-logo", image)
+        });
 
         egui::CentralPanel::default().show(ctx, |ui| {
-            if let Some((size, texture)) = self.texture {
-                ui.heading("This is an image:");
-                ui.image(texture, size);
+            ui.heading("This is an image:");
+            ui.image(texture, texture.size_vec2());
 
-                ui.heading("This is an image you can click:");
-                ui.add(egui::ImageButton::new(texture, size));
-            }
+            ui.heading("This is an image you can click:");
+            ui.add(egui::ImageButton::new(texture, texture.size_vec2()));
         });
     }
 }
@@ -45,3 +32,14 @@ fn main() {
     let options = eframe::NativeOptions::default();
     eframe::run_native(Box::new(MyApp::default()), options);
 }
+
+fn load_image(image_data: &[u8]) -> Result<egui::ColorImage, image::ImageError> {
+    let image = image::load_from_memory(image_data)?;
+    let size = [image.width() as _, image.height() as _];
+    let image_buffer = image.to_rgba8();
+    let pixels = image_buffer.as_flat_samples();
+    Ok(egui::ColorImage::from_rgba_unmultiplied(
+        size,
+        pixels.as_slice(),
+    ))
+}
diff --git a/eframe/src/lib.rs b/eframe/src/lib.rs
index 2fff7519..d0ba574d 100644
--- a/eframe/src/lib.rs
+++ b/eframe/src/lib.rs
@@ -26,7 +26,7 @@
 //!        "My egui App"
 //!    }
 //!
-//!    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+//!    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
 //!        egui::CentralPanel::default().show(ctx, |ui| {
 //!            ui.heading("Hello World!");
 //!        });
@@ -129,7 +129,7 @@ pub fn start_web(canvas_id: &str, app: Box<dyn epi::App>) -> Result<(), wasm_bin
 ///        "My egui App"
 ///    }
 ///
-///    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+///    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
 ///        egui::CentralPanel::default().show(ctx, |ui| {
 ///            ui.heading("Hello World!");
 ///        });
@@ -160,7 +160,7 @@ pub fn run_native(app: Box<dyn epi::App>, native_options: epi::NativeOptions) ->
 ///        "My egui App"
 ///    }
 ///
-///    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+///    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
 ///        egui::CentralPanel::default().show(ctx, |ui| {
 ///            ui.heading("Hello World!");
 ///        });
diff --git a/egui-winit/CHANGELOG.md b/egui-winit/CHANGELOG.md
index e2eb6621..80de1eaa 100644
--- a/egui-winit/CHANGELOG.md
+++ b/egui-winit/CHANGELOG.md
@@ -4,7 +4,12 @@ All notable changes to the `egui-winit` integration will be noted in this file.
 
 
 ## Unreleased
+* Fixed horizontal scrolling direction on Linux.
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
 * Replaced `std::time::Instant` with `instant::Instant` for WebAssembly compatability ([#1023](https://github.com/emilk/egui/pull/1023))
+* Shift-scroll will now result in horizontal scrolling on all platforms ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Require knowledge about max texture side (e.g. `GL_MAX_TEXTURE_SIZE`)) ([#1154](https://github.com/emilk/egui/pull/1154)).
+* Fixed `enable_drag` for Windows. Now called only once just after left click ([#1108](https://github.com/emilk/egui/pull/1108)).
 
 
 ## 0.16.0 - 2021-12-29
diff --git a/egui-winit/Cargo.toml b/egui-winit/Cargo.toml
index 917a3ae5..bbb0fbfa 100644
--- a/egui-winit/Cargo.toml
+++ b/egui-winit/Cargo.toml
@@ -21,22 +21,9 @@ include = [
 [package.metadata.docs.rs]
 all-features = true
 
-[dependencies]
-egui = { version = "0.16.0", path = "../egui", default-features = false, features = ["single_threaded"] }
-instant = { version = "0.1", features = ["wasm-bindgen"] }
-winit = "0.26"
-
-epi = { version = "0.16.0", path = "../epi", optional = true }
-
-copypasta = { version = "0.7", optional = true }
-serde = { version = "1.0", optional = true, features = ["derive"] }
-webbrowser = { version = "0.5", optional = true }
-
-# feature screen_reader
-tts = { version = "0.19", optional = true }
 
 [features]
-default = ["clipboard", "links"]
+default = ["clipboard", "dark-light", "links"]
 
 # enable cut/copy/paste to OS clipboard.
 # if disabled a clipboard will be simulated so you can still copy/paste within the egui app.
@@ -48,8 +35,25 @@ links = ["webbrowser"]
 # experimental support for a screen reader
 screen_reader = ["tts"]
 
-persistence = ["egui/serialize", "serde"]
+persistence = ["egui/serialize", "serde"] # can't add epi/persistence here because of https://github.com/rust-lang/cargo/issues/8832
 serialize = ["egui/serialize", "serde"]
 
 # implement bytemuck on most types.
 convert_bytemuck = ["egui/convert_bytemuck"]
+
+
+[dependencies]
+egui = { version = "0.16.0", path = "../egui", default-features = false, features = ["single_threaded", "tracing"] }
+instant = { version = "0.1", features = ["wasm-bindgen"] }
+tracing = "0.1"
+winit = "0.26.1"
+
+epi = { version = "0.16.0", path = "../epi", optional = true }
+
+copypasta = { version = "0.7", optional = true }
+dark-light = { version = "0.2.1", optional = true } # detect dark mode system preference
+serde = { version = "1.0", optional = true, features = ["derive"] }
+webbrowser = { version = "0.5", optional = true }
+
+# feature screen_reader
+tts = { version = "0.20", optional = true }
diff --git a/egui-winit/src/clipboard.rs b/egui-winit/src/clipboard.rs
index 4a70d47f..d6e29e33 100644
--- a/egui-winit/src/clipboard.rs
+++ b/egui-winit/src/clipboard.rs
@@ -29,7 +29,7 @@ impl Clipboard {
             match clipboard.get_contents() {
                 Ok(contents) => Some(contents),
                 Err(err) => {
-                    eprintln!("Paste error: {}", err);
+                    tracing::error!("Paste error: {}", err);
                     None
                 }
             }
@@ -46,7 +46,7 @@ impl Clipboard {
         if let Some(clipboard) = &mut self.copypasta {
             use copypasta::ClipboardProvider as _;
             if let Err(err) = clipboard.set_contents(text) {
-                eprintln!("Copy/Cut error: {}", err);
+                tracing::error!("Copy/Cut error: {}", err);
             }
         }
 
@@ -62,7 +62,7 @@ fn init_copypasta() -> Option<copypasta::ClipboardContext> {
     match copypasta::ClipboardContext::new() {
         Ok(clipboard) => Some(clipboard),
         Err(err) => {
-            eprintln!("Failed to initialize clipboard: {}", err);
+            tracing::error!("Failed to initialize clipboard: {}", err);
             None
         }
     }
diff --git a/egui-winit/src/epi.rs b/egui-winit/src/epi.rs
index badea97a..70d13d32 100644
--- a/egui-winit/src/epi.rs
+++ b/egui-winit/src/epi.rs
@@ -1,29 +1,62 @@
+use egui::Vec2;
+use winit::dpi::LogicalSize;
+
+pub fn points_to_size(points: Vec2) -> LogicalSize<f64> {
+    winit::dpi::LogicalSize {
+        width: points.x as f64,
+        height: points.y as f64,
+    }
+}
+
 pub fn window_builder(
     native_options: &epi::NativeOptions,
     window_settings: &Option<crate::WindowSettings>,
 ) -> winit::window::WindowBuilder {
-    let window_icon = native_options.icon_data.clone().and_then(load_icon);
+    let epi::NativeOptions {
+        always_on_top,
+        maximized,
+        decorated,
+        drag_and_drop_support,
+        icon_data,
+        initial_window_pos,
+        initial_window_size,
+        min_window_size,
+        max_window_size,
+        resizable,
+        transparent,
+    } = native_options;
+
+    let window_icon = icon_data.clone().and_then(load_icon);
 
     let mut window_builder = winit::window::WindowBuilder::new()
-        .with_always_on_top(native_options.always_on_top)
-        .with_maximized(native_options.maximized)
-        .with_decorations(native_options.decorated)
-        .with_resizable(native_options.resizable)
-        .with_transparent(native_options.transparent)
+        .with_always_on_top(*always_on_top)
+        .with_maximized(*maximized)
+        .with_decorations(*decorated)
+        .with_resizable(*resizable)
+        .with_transparent(*transparent)
         .with_window_icon(window_icon);
 
-    window_builder =
-        window_builder_drag_and_drop(window_builder, native_options.drag_and_drop_support);
+    if let Some(min_size) = *min_window_size {
+        window_builder = window_builder.with_min_inner_size(points_to_size(min_size));
+    }
+    if let Some(max_size) = *max_window_size {
+        window_builder = window_builder.with_max_inner_size(points_to_size(max_size));
+    }
 
-    let initial_size_points = native_options.initial_window_size;
+    window_builder = window_builder_drag_and_drop(window_builder, *drag_and_drop_support);
 
     if let Some(window_settings) = window_settings {
         window_builder = window_settings.initialize_window(window_builder);
-    } else if let Some(initial_size_points) = initial_size_points {
-        window_builder = window_builder.with_inner_size(winit::dpi::LogicalSize {
-            width: initial_size_points.x as f64,
-            height: initial_size_points.y as f64,
-        });
+    } else {
+        if let Some(pos) = *initial_window_pos {
+            window_builder = window_builder.with_position(winit::dpi::PhysicalPosition {
+                x: pos.x as f64,
+                y: pos.y as f64,
+            });
+        }
+        if let Some(initial_window_size) = *initial_window_size {
+            window_builder = window_builder.with_inner_size(points_to_size(initial_window_size));
+        }
     }
 
     window_builder
@@ -55,10 +88,9 @@ pub fn handle_app_output(
     window: &winit::window::Window,
     current_pixels_per_point: f32,
     app_output: epi::backend::AppOutput,
-) -> epi::backend::TexAllocationData {
+) {
     let epi::backend::AppOutput {
         quit: _,
-        tex_allocation_data,
         window_size,
         window_title,
         decorated,
@@ -86,8 +118,6 @@ pub fn handle_app_output(
     if drag_window {
         let _ = window.drag_window();
     }
-
-    tex_allocation_data
 }
 
 // ----------------------------------------------------------------------------
@@ -191,30 +221,34 @@ impl Persistence {
 pub struct EpiIntegration {
     frame: epi::Frame,
     persistence: crate::epi::Persistence,
-    pub egui_ctx: egui::CtxRef,
+    pub egui_ctx: egui::Context,
     egui_winit: crate::State,
     pub app: Box<dyn epi::App>,
     /// When set, it is time to quit
     quit: bool,
+    can_drag_window: bool,
 }
 
 impl EpiIntegration {
     pub fn new(
         integration_name: &'static str,
+        max_texture_side: usize,
         window: &winit::window::Window,
         repaint_signal: std::sync::Arc<dyn epi::backend::RepaintSignal>,
         persistence: crate::epi::Persistence,
         app: Box<dyn epi::App>,
     ) -> Self {
-        let egui_ctx = egui::CtxRef::default();
+        let egui_ctx = egui::Context::default();
 
         *egui_ctx.memory() = persistence.load_memory().unwrap_or_default();
 
+        let prefer_dark_mode = prefer_dark_mode();
+
         let frame = epi::Frame::new(epi::backend::FrameData {
             info: epi::IntegrationInfo {
                 name: integration_name,
                 web_info: None,
-                prefer_dark_mode: None, // TODO: figure out system default
+                prefer_dark_mode,
                 cpu_usage: None,
                 native_pixels_per_point: Some(crate::native_pixels_per_point(window)),
             },
@@ -222,13 +256,20 @@ impl EpiIntegration {
             repaint_signal,
         });
 
+        if prefer_dark_mode == Some(true) {
+            egui_ctx.set_visuals(egui::Visuals::dark());
+        } else {
+            egui_ctx.set_visuals(egui::Visuals::light());
+        }
+
         let mut slf = Self {
             frame,
             persistence,
             egui_ctx,
-            egui_winit: crate::State::new(window),
+            egui_winit: crate::State::new(max_texture_side, window),
             app,
             quit: false,
+            can_drag_window: false,
         };
 
         slf.setup(window);
@@ -243,17 +284,19 @@ impl EpiIntegration {
         self.app
             .setup(&self.egui_ctx, &self.frame, self.persistence.storage());
         let app_output = self.frame.take_app_output();
-        self.quit |= app_output.quit;
-        let tex_alloc_data =
-            crate::epi::handle_app_output(window, self.egui_ctx.pixels_per_point(), app_output);
-        self.frame.lock().output.tex_allocation_data = tex_alloc_data; // Do it later
+
+        if app_output.quit {
+            self.quit = self.app.on_exit_event();
+        }
+
+        crate::epi::handle_app_output(window, self.egui_ctx.pixels_per_point(), app_output);
     }
 
     fn warm_up(&mut self, window: &winit::window::Window) {
-        let saved_memory = self.egui_ctx.memory().clone();
+        let saved_memory: egui::Memory = self.egui_ctx.memory().clone();
         self.egui_ctx.memory().set_everything_is_visible(true);
-        let (_, tex_alloc_data, _) = self.update(window);
-        self.frame.lock().output.tex_allocation_data = tex_alloc_data; // handle it next frame
+        let (_, textures_delta, _) = self.update(window);
+        self.egui_ctx.output().textures_delta = textures_delta; // Handle it next frame
         *self.egui_ctx.memory() = saved_memory; // We don't want to remember that windows were huge.
         self.egui_ctx.clear_animations();
     }
@@ -264,8 +307,19 @@ impl EpiIntegration {
     }
 
     pub fn on_event(&mut self, event: &winit::event::WindowEvent<'_>) {
-        use winit::event::WindowEvent;
-        self.quit |= matches!(event, WindowEvent::CloseRequested | WindowEvent::Destroyed);
+        use winit::event::{ElementState, MouseButton, WindowEvent};
+
+        match event {
+            WindowEvent::CloseRequested => self.quit = self.app.on_exit_event(),
+            WindowEvent::Destroyed => self.quit = true,
+            WindowEvent::MouseInput {
+                button: MouseButton::Left,
+                state: ElementState::Pressed,
+                ..
+            } => self.can_drag_window = true,
+            _ => {}
+        }
+
         self.egui_winit.on_event(&self.egui_ctx, event);
     }
 
@@ -273,11 +327,7 @@ impl EpiIntegration {
     pub fn update(
         &mut self,
         window: &winit::window::Window,
-    ) -> (
-        bool,
-        epi::backend::TexAllocationData,
-        Vec<egui::epaint::ClippedShape>,
-    ) {
+    ) -> (bool, egui::TexturesDelta, Vec<egui::epaint::ClippedShape>) {
         let frame_start = instant::Instant::now();
 
         let raw_input = self.egui_winit.take_egui_input(window);
@@ -286,18 +336,24 @@ impl EpiIntegration {
         });
 
         let needs_repaint = egui_output.needs_repaint;
-        self.egui_winit
+        let textures_delta = self
+            .egui_winit
             .handle_output(window, &self.egui_ctx, egui_output);
 
-        let app_output = self.frame.take_app_output();
-        self.quit |= app_output.quit;
-        let tex_allocation_data =
-            crate::epi::handle_app_output(window, self.egui_ctx.pixels_per_point(), app_output);
+        let mut app_output = self.frame.take_app_output();
+        app_output.drag_window &= self.can_drag_window; // Necessary on Windows; see https://github.com/emilk/egui/pull/1108
+        self.can_drag_window = false;
+
+        if app_output.quit {
+            self.quit = self.app.on_exit_event();
+        }
+
+        crate::epi::handle_app_output(window, self.egui_ctx.pixels_per_point(), app_output);
 
         let frame_time = (instant::Instant::now() - frame_start).as_secs_f64() as f32;
         self.frame.lock().info.cpu_usage = Some(frame_time);
 
-        (needs_repaint, tex_allocation_data, shapes)
+        (needs_repaint, textures_delta, shapes)
     }
 
     pub fn maybe_autosave(&mut self, window: &winit::window::Window) {
@@ -311,3 +367,16 @@ impl EpiIntegration {
             .save(&mut *self.app, &self.egui_ctx, window);
     }
 }
+
+#[cfg(feature = "dark-light")]
+fn prefer_dark_mode() -> Option<bool> {
+    match dark_light::detect() {
+        dark_light::Mode::Dark => Some(true),
+        dark_light::Mode::Light => Some(false),
+    }
+}
+
+#[cfg(not(feature = "dark-light"))]
+fn prefer_dark_mode() -> Option<bool> {
+    None
+}
diff --git a/egui-winit/src/lib.rs b/egui-winit/src/lib.rs
index 1fa2d22d..6e19f435 100644
--- a/egui-winit/src/lib.rs
+++ b/egui-winit/src/lib.rs
@@ -129,17 +129,22 @@ pub struct State {
 }
 
 impl State {
-    /// Initialize with the native `pixels_per_point` (dpi scaling).
-    pub fn new(window: &winit::window::Window) -> Self {
-        Self::from_pixels_per_point(native_pixels_per_point(window))
+    /// Initialize with:
+    /// * `max_texture_side`: e.g. `GL_MAX_TEXTURE_SIZE`
+    /// * the native `pixels_per_point` (dpi scaling).
+    pub fn new(max_texture_side: usize, window: &winit::window::Window) -> Self {
+        Self::from_pixels_per_point(max_texture_side, native_pixels_per_point(window))
     }
 
-    /// Initialize with a given dpi scaling.
-    pub fn from_pixels_per_point(pixels_per_point: f32) -> Self {
+    /// Initialize with:
+    /// * `max_texture_side`: e.g. `GL_MAX_TEXTURE_SIZE`
+    /// * the given `pixels_per_point` (dpi scaling).
+    pub fn from_pixels_per_point(max_texture_side: usize, pixels_per_point: f32) -> Self {
         Self {
             start_time: instant::Instant::now(),
             egui_input: egui::RawInput {
                 pixels_per_point: Some(pixels_per_point),
+                max_texture_side,
                 ..Default::default()
             },
             pointer_pos_in_points: None,
@@ -453,17 +458,19 @@ impl State {
                 egui::vec2(delta.x as f32, delta.y as f32) / self.pixels_per_point()
             }
         };
-        if cfg!(target_os = "macos") {
-            delta.x *= -1.0; // until https://github.com/rust-windowing/winit/pull/2105 is merged and released
-        }
-        if cfg!(target_os = "windows") {
-            delta.x *= -1.0; // until https://github.com/rust-windowing/winit/pull/2101 is merged and released
-        }
+
+        delta.x *= -1.0; // Winit has inverted hscroll. Remove this line when we update winit after https://github.com/rust-windowing/winit/pull/2105 is merged and released
 
         if self.egui_input.modifiers.ctrl || self.egui_input.modifiers.command {
             // Treat as zoom instead:
             let factor = (delta.y / 200.0).exp();
             self.egui_input.events.push(egui::Event::Zoom(factor));
+        } else if self.egui_input.modifiers.shift {
+            // Treat as horizontal scrolling.
+            // Note: one Mac we already get horizontal scroll events when shift is down.
+            self.egui_input
+                .events
+                .push(egui::Event::Scroll(egui::vec2(delta.x + delta.y, 0.0)));
         } else {
             self.egui_input.events.push(egui::Event::Scroll(delta));
         }
@@ -484,7 +491,7 @@ impl State {
                     if let Some(contents) = self.clipboard.get() {
                         self.egui_input
                             .events
-                            .push(egui::Event::Text(contents.replace("\r\n", "\n")));
+                            .push(egui::Event::Paste(contents.replace("\r\n", "\n")));
                     }
                 }
             }
@@ -512,26 +519,39 @@ impl State {
         window: &winit::window::Window,
         egui_ctx: &egui::Context,
         output: egui::Output,
-    ) {
-        self.current_pixels_per_point = egui_ctx.pixels_per_point(); // someone can have changed it to scale the UI
-
-        if egui_ctx.memory().options.screen_reader {
+    ) -> egui::TexturesDelta {
+        if egui_ctx.options().screen_reader {
             self.screen_reader.speak(&output.events_description());
         }
 
-        self.set_cursor_icon(window, output.cursor_icon);
+        let egui::Output {
+            cursor_icon,
+            open_url,
+            copied_text,
+            needs_repaint: _,             // needs to be handled elsewhere
+            events: _,                    // handled above
+            mutable_text_under_cursor: _, // only used in egui_web
+            text_cursor_pos,
+            textures_delta,
+        } = output;
 
-        if let Some(open) = output.open_url {
-            open_url(&open.url);
+        self.current_pixels_per_point = egui_ctx.pixels_per_point(); // someone can have changed it to scale the UI
+
+        self.set_cursor_icon(window, cursor_icon);
+
+        if let Some(open_url) = open_url {
+            open_url_in_browser(&open_url.url);
         }
 
-        if !output.copied_text.is_empty() {
-            self.clipboard.set(output.copied_text);
+        if !copied_text.is_empty() {
+            self.clipboard.set(copied_text);
         }
 
-        if let Some(egui::Pos2 { x, y }) = output.text_cursor_pos {
+        if let Some(egui::Pos2 { x, y }) = text_cursor_pos {
             window.set_ime_position(winit::dpi::LogicalPosition { x, y });
         }
+
+        textures_delta
     }
 
     fn set_cursor_icon(&mut self, window: &winit::window::Window, cursor_icon: egui::CursorIcon) {
@@ -554,15 +574,15 @@ impl State {
     }
 }
 
-fn open_url(_url: &str) {
+fn open_url_in_browser(_url: &str) {
     #[cfg(feature = "webbrowser")]
     if let Err(err) = webbrowser::open(_url) {
-        eprintln!("Failed to open url: {}", err);
+        tracing::warn!("Failed to open url: {}", err);
     }
 
     #[cfg(not(feature = "webbrowser"))]
     {
-        eprintln!("Cannot open url - feature \"links\" not enabled.");
+        tracing::warn!("Cannot open url - feature \"links\" not enabled.");
     }
 }
 
diff --git a/egui-winit/src/screen_reader.rs b/egui-winit/src/screen_reader.rs
index 9397d2ea..e3ac02b1 100644
--- a/egui-winit/src/screen_reader.rs
+++ b/egui-winit/src/screen_reader.rs
@@ -15,11 +15,11 @@ impl Default for ScreenReader {
     fn default() -> Self {
         let tts = match tts::Tts::default() {
             Ok(screen_reader) => {
-                eprintln!("Initialized screen reader.");
+                tracing::debug!("Initialized screen reader.");
                 Some(screen_reader)
             }
             Err(err) => {
-                eprintln!("Failed to load screen reader: {}", err);
+                tracing::warn!("Failed to load screen reader: {}", err);
                 None
             }
         };
@@ -38,10 +38,10 @@ impl ScreenReader {
             return;
         }
         if let Some(tts) = &mut self.tts {
-            eprintln!("Speaking: {:?}", text);
+            tracing::debug!("Speaking: {:?}", text);
             let interrupt = true;
             if let Err(err) = tts.speak(text, interrupt) {
-                eprintln!("Failed to read: {}", err);
+                tracing::warn!("Failed to read: {}", err);
             }
         }
     }
diff --git a/egui/Cargo.toml b/egui/Cargo.toml
index 6f9ed8b2..67591cf2 100644
--- a/egui/Cargo.toml
+++ b/egui/Cargo.toml
@@ -23,13 +23,6 @@ all-features = true
 
 [lib]
 
-[dependencies]
-epaint = { version = "0.16.0", path = "../epaint", default-features = false }
-
-ahash = "0.7"
-nohash-hasher = "0.2"
-ron = { version = "0.7", optional = true }
-serde = { version = "1", features = ["derive", "rc"], optional = true }
 
 [features]
 default = ["default_fonts", "single_threaded"]
@@ -37,6 +30,9 @@ default = ["default_fonts", "single_threaded"]
 # add compatibility with https://crates.io/crates/cint
 cint = ["epaint/cint"]
 
+# implement bytemuck on most types.
+convert_bytemuck = ["epaint/convert_bytemuck"]
+
 # If set, egui will use `include_bytes!` to bundle some fonts.
 # If you plan on specifying your own fonts you may disable this feature.
 default_fonts = ["epaint/default_fonts"]
@@ -55,10 +51,20 @@ persistence = ["serde", "epaint/serialize", "ron"]
 # implement serde on most types.
 serialize = ["serde", "epaint/serialize"]
 
-# implement bytemuck on most types.
-convert_bytemuck = ["epaint/convert_bytemuck"]
-
 # multi_threaded is only needed if you plan to use the same egui::Context
 # from multiple threads. It comes with a minor performance impact.
 single_threaded = ["epaint/single_threaded"]
 multi_threaded = ["epaint/multi_threaded"]
+
+
+[dependencies]
+epaint = { version = "0.16.0", path = "../epaint", default-features = false }
+
+ahash = "0.7"
+nohash-hasher = "0.2"
+
+# Optional:
+ron = { version = "0.7", optional = true }
+serde = { version = "1", features = ["derive", "rc"], optional = true }
+# egui doesn't log much, but when it does, it uses `tracing`
+tracing = { version = "0.1", optional = true }
diff --git a/egui/examples/README.md b/egui/examples/README.md
index 44a9fe08..33da866c 100644
--- a/egui/examples/README.md
+++ b/egui/examples/README.md
@@ -1,5 +1,5 @@
 There are no stand-alone egui examples, because egui is not stand-alone!
 
-There are plenty of examples in [the online demo](https://emilk.github.io/egui/). You can find the source code for it at <https://github.com/emilk/egui/tree/master/egui_demo_lib>.
+There are plenty of examples in [the online demo](https://www.egui.rs/#demo). You can find the source code for it at <https://github.com/emilk/egui/tree/master/egui_demo_lib>.
 
 If you are using `eframe`, check out [the `eframe` examples](https://github.com/emilk/egui/tree/master/eframe/examples) and [the `eframe` template repository](https://github.com/emilk/eframe_template/).
diff --git a/egui/src/animation_manager.rs b/egui/src/animation_manager.rs
index 8a6795f5..3cc273bf 100644
--- a/egui/src/animation_manager.rs
+++ b/egui/src/animation_manager.rs
@@ -3,6 +3,7 @@ use crate::{emath::remap_clamp, Id, IdMap, InputState};
 #[derive(Clone, Default)]
 pub(crate) struct AnimationManager {
     bools: IdMap<BoolAnim>,
+    values: IdMap<ValueAnim>,
 }
 
 #[derive(Clone, Debug)]
@@ -12,6 +13,14 @@ struct BoolAnim {
     toggle_time: f64,
 }
 
+#[derive(Clone, Debug)]
+struct ValueAnim {
+    from_value: f32,
+    to_value: f32,
+    /// when did `value` last toggle?
+    toggle_time: f64,
+}
+
 impl AnimationManager {
     /// See `Context::animate_bool` for documentation
     pub fn animate_bool(
@@ -56,4 +65,47 @@ impl AnimationManager {
             }
         }
     }
+
+    pub fn animate_value(
+        &mut self,
+        input: &InputState,
+        animation_time: f32,
+        id: Id,
+        value: f32,
+    ) -> f32 {
+        match self.values.get_mut(&id) {
+            None => {
+                self.values.insert(
+                    id,
+                    ValueAnim {
+                        from_value: value,
+                        to_value: value,
+                        toggle_time: -f64::INFINITY, // long time ago
+                    },
+                );
+                value
+            }
+            Some(anim) => {
+                let time_since_toggle = (input.time - anim.toggle_time) as f32;
+                // On the frame we toggle we don't want to return the old value,
+                // so we extrapolate forwards:
+                let time_since_toggle = time_since_toggle + input.predicted_dt;
+                let current_value = remap_clamp(
+                    time_since_toggle,
+                    0.0..=animation_time,
+                    anim.from_value..=anim.to_value,
+                );
+                if anim.to_value != value {
+                    anim.from_value = current_value; //start new animation from current position of playing animation
+                    anim.to_value = value;
+                    anim.toggle_time = input.time;
+                }
+                if animation_time == 0.0 {
+                    anim.from_value = value;
+                    anim.to_value = value;
+                }
+                current_value
+            }
+        }
+    }
 }
diff --git a/egui/src/containers/area.rs b/egui/src/containers/area.rs
index cb5fc831..9ff25d5f 100644
--- a/egui/src/containers/area.rs
+++ b/egui/src/containers/area.rs
@@ -176,7 +176,7 @@ pub(crate) struct Prepared {
 impl Area {
     pub fn show<R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
         let prepared = self.begin(ctx);
@@ -186,7 +186,7 @@ impl Area {
         InnerResponse { inner, response }
     }
 
-    pub(crate) fn begin(self, ctx: &CtxRef) -> Prepared {
+    pub(crate) fn begin(self, ctx: &Context) -> Prepared {
         let Area {
             id,
             movable,
@@ -234,7 +234,7 @@ impl Area {
         }
     }
 
-    pub fn show_open_close_animation(&self, ctx: &CtxRef, frame: &Frame, is_open: bool) {
+    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);
 
@@ -276,7 +276,7 @@ impl Prepared {
         self.drag_bounds
     }
 
-    pub(crate) fn content_ui(&self, ctx: &CtxRef) -> Ui {
+    pub(crate) fn content_ui(&self, ctx: &Context) -> Ui {
         let screen_rect = ctx.input().screen_rect();
 
         let bounds = if let Some(bounds) = self.drag_bounds {
@@ -317,7 +317,7 @@ impl Prepared {
     }
 
     #[allow(clippy::needless_pass_by_value)] // intentional to swallow up `content_ui`.
-    pub(crate) fn end(self, ctx: &CtxRef, content_ui: Ui) -> Response {
+    pub(crate) fn end(self, ctx: &Context, content_ui: Ui) -> Response {
         let Prepared {
             layer_id,
             mut state,
@@ -370,8 +370,9 @@ impl Prepared {
 }
 
 fn pointer_pressed_on_area(ctx: &Context, layer_id: LayerId) -> bool {
-    if let Some(pointer_pos) = ctx.input().pointer.interact_pos() {
-        ctx.input().pointer.any_pressed() && ctx.layer_id_at(pointer_pos) == Some(layer_id)
+    if let Some(pointer_pos) = ctx.pointer_interact_pos() {
+        let any_pressed = ctx.input().pointer.any_pressed();
+        any_pressed && ctx.layer_id_at(pointer_pos) == Some(layer_id)
     } else {
         false
     }
diff --git a/egui/src/containers/collapsing_header.rs b/egui/src/containers/collapsing_header.rs
index 66c6b213..d0df0895 100644
--- a/egui/src/containers/collapsing_header.rs
+++ b/egui/src/containers/collapsing_header.rs
@@ -1,9 +1,9 @@
 use std::hash::Hash;
 
 use crate::*;
-use epaint::{Shape, TextStyle};
+use epaint::Shape;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub(crate) struct State {
@@ -13,22 +13,13 @@ pub(crate) struct State {
     open_height: Option<f32>,
 }
 
-impl Default for State {
-    fn default() -> Self {
-        Self {
-            open: false,
-            open_height: None,
-        }
-    }
-}
-
 impl State {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(id)
+        ctx.data().get_persisted(id)
     }
 
     pub fn store(self, ctx: &Context, id: Id) {
-        ctx.memory().data.insert_persisted(id, self);
+        ctx.data().insert_persisted(id, self);
     }
 
     pub fn from_memory_with_default_open(ctx: &Context, id: Id, default_open: bool) -> Self {
@@ -107,7 +98,7 @@ impl State {
 }
 
 /// Paint the arrow icon that indicated if the region is open or not
-pub(crate) fn paint_icon(ui: &mut Ui, openness: f32, response: &Response) {
+pub(crate) fn paint_default_icon(ui: &mut Ui, openness: f32, response: &Response) {
     let visuals = ui.style().interact(response);
     let stroke = visuals.fg_stroke;
 
@@ -126,6 +117,9 @@ pub(crate) fn paint_icon(ui: &mut Ui, openness: f32, response: &Response) {
     ui.painter().add(Shape::closed_line(points, stroke));
 }
 
+/// A function that paints an icon indicating if the region is open or not
+pub type IconPainter = Box<dyn FnOnce(&mut Ui, f32, &Response)>;
+
 /// A header which can be collapsed/expanded, revealing a contained [`Ui`] region.
 ///
 ///
@@ -150,6 +144,7 @@ pub struct CollapsingHeader {
     selectable: bool,
     selected: bool,
     show_background: bool,
+    icon: Option<IconPainter>,
 }
 
 impl CollapsingHeader {
@@ -171,6 +166,7 @@ impl CollapsingHeader {
             selectable: false,
             selected: false,
             show_background: false,
+            icon: None,
         }
     }
 
@@ -245,6 +241,28 @@ impl CollapsingHeader {
         self.show_background = show_background;
         self
     }
+
+    /// Use the provided function to render a different `CollapsingHeader` icon.
+    /// Defaults to a triangle that animates as the `CollapsingHeader` opens and closes.
+    ///
+    /// For example:
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// fn circle_icon(ui: &mut egui::Ui, openness: f32, response: &egui::Response) {
+    ///     let stroke = ui.style().interact(&response).fg_stroke;
+    ///     let radius = egui::lerp(2.0..=3.0, openness);
+    ///     ui.painter().circle_filled(response.rect.center(), radius, stroke.color);
+    /// }
+    ///
+    /// egui::CollapsingHeader::new("Circles")
+    ///   .icon(circle_icon)
+    ///   .show(ui, |ui| { ui.label("Hi!"); });
+    /// # });
+    /// ```
+    pub fn icon(mut self, icon_fn: impl FnOnce(&mut Ui, f32, &Response) + 'static) -> Self {
+        self.icon = Some(Box::new(icon_fn));
+        self
+    }
 }
 
 struct Prepared {
@@ -260,6 +278,7 @@ impl CollapsingHeader {
             "Horizontal collapsing is unimplemented"
         );
         let Self {
+            icon,
             text,
             default_open,
             open,
@@ -319,7 +338,7 @@ impl CollapsingHeader {
             if ui.visuals().collapsing_header_frame || self.show_background {
                 ui.painter().add(epaint::RectShape {
                     rect: header_response.rect.expand(visuals.expansion),
-                    corner_radius: visuals.corner_radius,
+                    rounding: visuals.rounding,
                     fill: visuals.bg_fill,
                     stroke: visuals.bg_stroke,
                     // stroke: Default::default(),
@@ -331,9 +350,8 @@ impl CollapsingHeader {
             {
                 let rect = rect.expand(visuals.expansion);
 
-                let corner_radius = 2.0;
                 ui.painter()
-                    .rect(rect, corner_radius, visuals.bg_fill, visuals.bg_stroke);
+                    .rect(rect, visuals.rounding, visuals.bg_fill, visuals.bg_stroke);
             }
 
             {
@@ -347,7 +365,11 @@ impl CollapsingHeader {
                     ..header_response.clone()
                 };
                 let openness = state.openness(ui.ctx(), id);
-                paint_icon(ui, openness, &icon_response);
+                if let Some(icon) = icon {
+                    icon(ui, openness, &icon_response);
+                } else {
+                    paint_default_icon(ui, openness, &icon_response);
+                }
             }
 
             text.paint_with_visuals(ui.painter(), text_pos, &visuals);
diff --git a/egui/src/containers/combo_box.rs b/egui/src/containers/combo_box.rs
index 71c4f063..14feb02c 100644
--- a/egui/src/containers/combo_box.rs
+++ b/egui/src/containers/combo_box.rs
@@ -27,6 +27,16 @@ pub struct ComboBox {
 }
 
 impl ComboBox {
+    /// Create new `ComboBox` with id and label
+    pub fn new(id_source: impl std::hash::Hash, label: impl Into<WidgetText>) -> Self {
+        Self {
+            id_source: Id::new(id_source),
+            label: Some(label.into()),
+            selected_text: Default::default(),
+            width: None,
+        }
+    }
+
     /// Label shown next to the combo box
     pub fn from_label(label: impl Into<WidgetText>) -> Self {
         let label = label.into();
@@ -196,6 +206,7 @@ fn combo_box_dyn<'c, R>(
         ScrollArea::vertical()
             .max_height(ui.spacing().combo_height)
             .show(ui, menu_contents)
+            .inner
     });
 
     InnerResponse {
@@ -239,7 +250,7 @@ fn button_frame(
             where_to_put_background,
             epaint::RectShape {
                 rect: outer_rect.expand(visuals.expansion),
-                corner_radius: visuals.corner_radius,
+                rounding: visuals.rounding,
                 fill: visuals.bg_fill,
                 stroke: visuals.bg_stroke,
             },
diff --git a/egui/src/containers/frame.rs b/egui/src/containers/frame.rs
index fd85819d..c5c5a61a 100644
--- a/egui/src/containers/frame.rs
+++ b/egui/src/containers/frame.rs
@@ -9,7 +9,7 @@ use epaint::*;
 pub struct Frame {
     /// On each side
     pub margin: Vec2,
-    pub corner_radius: f32,
+    pub rounding: Rounding,
     pub shadow: Shadow,
     pub fill: Color32,
     pub stroke: Stroke,
@@ -24,7 +24,7 @@ impl Frame {
     pub fn group(style: &Style) -> Self {
         Self {
             margin: Vec2::splat(6.0), // symmetric looks best in corners when nesting
-            corner_radius: style.visuals.widgets.noninteractive.corner_radius,
+            rounding: style.visuals.widgets.noninteractive.rounding,
             stroke: style.visuals.widgets.noninteractive.bg_stroke,
             ..Default::default()
         }
@@ -33,7 +33,7 @@ impl Frame {
     pub(crate) fn side_top_panel(style: &Style) -> Self {
         Self {
             margin: Vec2::new(8.0, 2.0),
-            corner_radius: 0.0,
+            rounding: Rounding::none(),
             fill: style.visuals.window_fill(),
             stroke: style.visuals.window_stroke(),
             ..Default::default()
@@ -43,7 +43,7 @@ impl Frame {
     pub(crate) fn central_panel(style: &Style) -> Self {
         Self {
             margin: Vec2::new(8.0, 8.0),
-            corner_radius: 0.0,
+            rounding: Rounding::none(),
             fill: style.visuals.window_fill(),
             stroke: Default::default(),
             ..Default::default()
@@ -53,7 +53,7 @@ impl Frame {
     pub fn window(style: &Style) -> Self {
         Self {
             margin: style.spacing.window_padding,
-            corner_radius: style.visuals.window_corner_radius,
+            rounding: style.visuals.window_rounding,
             shadow: style.visuals.window_shadow,
             fill: style.visuals.window_fill(),
             stroke: style.visuals.window_stroke(),
@@ -63,7 +63,7 @@ impl Frame {
     pub fn menu(style: &Style) -> Self {
         Self {
             margin: Vec2::splat(1.0),
-            corner_radius: style.visuals.widgets.noninteractive.corner_radius,
+            rounding: style.visuals.widgets.noninteractive.rounding,
             shadow: style.visuals.popup_shadow,
             fill: style.visuals.window_fill(),
             stroke: style.visuals.window_stroke(),
@@ -73,7 +73,7 @@ impl Frame {
     pub fn popup(style: &Style) -> Self {
         Self {
             margin: style.spacing.window_padding,
-            corner_radius: style.visuals.widgets.noninteractive.corner_radius,
+            rounding: style.visuals.widgets.noninteractive.rounding,
             shadow: style.visuals.popup_shadow,
             fill: style.visuals.window_fill(),
             stroke: style.visuals.window_stroke(),
@@ -84,7 +84,7 @@ impl Frame {
     pub fn dark_canvas(style: &Style) -> Self {
         Self {
             margin: Vec2::new(10.0, 10.0),
-            corner_radius: style.visuals.widgets.noninteractive.corner_radius,
+            rounding: style.visuals.widgets.noninteractive.rounding,
             fill: Color32::from_black_alpha(250),
             stroke: style.visuals.window_stroke(),
             ..Default::default()
@@ -103,8 +103,8 @@ impl Frame {
         self
     }
 
-    pub fn corner_radius(mut self, corner_radius: f32) -> Self {
-        self.corner_radius = corner_radius;
+    pub fn rounding(mut self, rounding: impl Into<Rounding>) -> Self {
+        self.rounding = rounding.into();
         self
     }
 
@@ -172,7 +172,7 @@ impl Frame {
     pub fn paint(&self, outer_rect: Rect) -> Shape {
         let Self {
             margin: _,
-            corner_radius,
+            rounding,
             shadow,
             fill,
             stroke,
@@ -180,7 +180,7 @@ impl Frame {
 
         let frame_shape = Shape::Rect(epaint::RectShape {
             rect: outer_rect,
-            corner_radius,
+            rounding,
             fill,
             stroke,
         });
@@ -188,7 +188,7 @@ impl Frame {
         if shadow == Default::default() {
             frame_shape
         } else {
-            let shadow = shadow.tessellate(outer_rect, corner_radius);
+            let shadow = shadow.tessellate(outer_rect, rounding);
             let shadow = Shape::Mesh(shadow);
             Shape::Vec(vec![shadow, frame_shape])
         }
diff --git a/egui/src/containers/panel.rs b/egui/src/containers/panel.rs
index 8bdea2a8..9fc6aae8 100644
--- a/egui/src/containers/panel.rs
+++ b/egui/src/containers/panel.rs
@@ -25,11 +25,11 @@ struct PanelState {
 
 impl PanelState {
     fn load(ctx: &Context, bar_id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(bar_id)
+        ctx.data().get_persisted(bar_id)
     }
 
     fn store(self, ctx: &Context, bar_id: Id) {
-        ctx.memory().data.insert_persisted(bar_id, self);
+        ctx.data().insert_persisted(bar_id, self);
     }
 }
 
@@ -199,7 +199,7 @@ impl SidePanel {
         let mut is_resizing = false;
         if resizable {
             let resize_id = id.with("__resize");
-            if let Some(pointer) = ui.input().pointer.latest_pos() {
+            if let Some(pointer) = ui.ctx().latest_pointer_pos() {
                 let we_are_on_top = ui
                     .ctx()
                     .layer_id_at(pointer)
@@ -284,7 +284,7 @@ impl SidePanel {
     /// Show the panel at the top level.
     pub fn show<R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
         self.show_dyn(ctx, Box::new(add_contents))
@@ -293,7 +293,7 @@ impl SidePanel {
     /// Show the panel at the top level.
     fn show_dyn<'c, R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
     ) -> InnerResponse<R> {
         let layer_id = LayerId::background();
@@ -485,7 +485,8 @@ impl TopBottomPanel {
         let mut is_resizing = false;
         if resizable {
             let resize_id = id.with("__resize");
-            if let Some(pointer) = ui.input().pointer.latest_pos() {
+            let latest_pos = ui.input().pointer.latest_pos();
+            if let Some(pointer) = latest_pos {
                 let we_are_on_top = ui
                     .ctx()
                     .layer_id_at(pointer)
@@ -570,7 +571,7 @@ impl TopBottomPanel {
     /// Show the panel at the top level.
     pub fn show<R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
         self.show_dyn(ctx, Box::new(add_contents))
@@ -579,7 +580,7 @@ impl TopBottomPanel {
     /// Show the panel at the top level.
     fn show_dyn<'c, R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
     ) -> InnerResponse<R> {
         let layer_id = LayerId::background();
@@ -670,7 +671,7 @@ impl CentralPanel {
     /// Show the panel at the top level.
     pub fn show<R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
         self.show_dyn(ctx, Box::new(add_contents))
@@ -679,7 +680,7 @@ impl CentralPanel {
     /// Show the panel at the top level.
     fn show_dyn<'c, R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
     ) -> InnerResponse<R> {
         let available_rect = ctx.available_rect();
diff --git a/egui/src/containers/popup.rs b/egui/src/containers/popup.rs
index 1194f12b..ffe36672 100644
--- a/egui/src/containers/popup.rs
+++ b/egui/src/containers/popup.rs
@@ -13,11 +13,11 @@ pub(crate) struct MonoState {
 
 impl MonoState {
     fn load(ctx: &Context) -> Option<Self> {
-        ctx.memory().data.get_temp(Id::null())
+        ctx.data().get_temp(Id::null())
     }
 
     fn store(self, ctx: &Context) {
-        ctx.memory().data.insert_temp(Id::null(), self);
+        ctx.data().insert_temp(Id::null(), self);
     }
 
     fn tooltip_size(&self, id: Id, index: usize) -> Option<Vec2> {
@@ -66,7 +66,11 @@ impl MonoState {
 /// }
 /// # });
 /// ```
-pub fn show_tooltip<R>(ctx: &CtxRef, id: Id, add_contents: impl FnOnce(&mut Ui) -> R) -> Option<R> {
+pub fn show_tooltip<R>(
+    ctx: &Context,
+    id: Id,
+    add_contents: impl FnOnce(&mut Ui) -> R,
+) -> Option<R> {
     show_tooltip_at_pointer(ctx, id, add_contents)
 }
 
@@ -88,7 +92,7 @@ pub fn show_tooltip<R>(ctx: &CtxRef, id: Id, add_contents: impl FnOnce(&mut Ui)
 /// # });
 /// ```
 pub fn show_tooltip_at_pointer<R>(
-    ctx: &CtxRef,
+    ctx: &Context,
     id: Id,
     add_contents: impl FnOnce(&mut Ui) -> R,
 ) -> Option<R> {
@@ -104,7 +108,7 @@ 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: &CtxRef,
+    ctx: &Context,
     id: Id,
     rect: &Rect,
     add_contents: impl FnOnce(&mut Ui) -> R,
@@ -129,7 +133,7 @@ pub fn show_tooltip_for<R>(
 ///
 /// Returns `None` if the tooltip could not be placed.
 pub fn show_tooltip_at<R>(
-    ctx: &CtxRef,
+    ctx: &Context,
     id: Id,
     suggested_position: Option<Pos2>,
     add_contents: impl FnOnce(&mut Ui) -> R,
@@ -146,7 +150,7 @@ pub fn show_tooltip_at<R>(
 }
 
 fn show_tooltip_at_avoid_dyn<'c, R>(
-    ctx: &CtxRef,
+    ctx: &Context,
     mut id: Id,
     suggested_position: Option<Pos2>,
     above: bool,
@@ -229,7 +233,7 @@ fn show_tooltip_at_avoid_dyn<'c, R>(
 /// }
 /// # });
 /// ```
-pub fn show_tooltip_text(ctx: &CtxRef, id: Id, text: impl Into<WidgetText>) -> Option<()> {
+pub fn show_tooltip_text(ctx: &Context, id: Id, text: impl Into<WidgetText>) -> Option<()> {
     show_tooltip(ctx, id, |ui| {
         crate::widgets::Label::new(text).ui(ui);
     })
@@ -237,7 +241,7 @@ pub fn show_tooltip_text(ctx: &CtxRef, id: Id, text: impl Into<WidgetText>) -> O
 
 /// Show a pop-over window.
 fn show_tooltip_area_dyn<'c, R>(
-    ctx: &CtxRef,
+    ctx: &Context,
     id: Id,
     window_pos: Pos2,
     add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
diff --git a/egui/src/containers/resize.rs b/egui/src/containers/resize.rs
index 903d669a..5dd46dbe 100644
--- a/egui/src/containers/resize.rs
+++ b/egui/src/containers/resize.rs
@@ -18,11 +18,11 @@ pub(crate) struct State {
 
 impl State {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(id)
+        ctx.data().get_persisted(id)
     }
 
     pub fn store(self, ctx: &Context, id: Id) {
-        ctx.memory().data.insert_persisted(id, self);
+        ctx.data().insert_persisted(id, self);
     }
 }
 
diff --git a/egui/src/containers/scroll_area.rs b/egui/src/containers/scroll_area.rs
index a79bf5df..d5c9e712 100644
--- a/egui/src/containers/scroll_area.rs
+++ b/egui/src/containers/scroll_area.rs
@@ -10,9 +10,9 @@ use crate::*;
 #[derive(Clone, Copy, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
-pub(crate) struct State {
+pub struct State {
     /// Positive offset means scrolling down/right
-    offset: Vec2,
+    pub offset: Vec2,
 
     show_scroll: [bool; 2],
 
@@ -43,14 +43,28 @@ impl Default for State {
 
 impl State {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(id)
+        ctx.data().get_persisted(id)
     }
 
     pub fn store(self, ctx: &Context, id: Id) {
-        ctx.memory().data.insert_persisted(id, self);
+        ctx.data().insert_persisted(id, self);
     }
 }
 
+pub struct ScrollAreaOutput<R> {
+    /// What the user closure returned.
+    pub inner: R,
+
+    /// `Id` of the `ScrollArea`.
+    pub id: Id,
+
+    /// The current state of the scroll area.
+    pub state: State,
+
+    /// Where on the screen the content is (excludes scroll bars).
+    pub inner_rect: Rect,
+}
+
 /// Add vertical and/or horizontal scrolling to a contained [`Ui`].
 ///
 /// ```
@@ -258,6 +272,7 @@ struct Prepared {
     /// width of the vertical bar, and the height of the horizontal bar?
     current_bar_use: Vec2,
     always_show_scroll: bool,
+    /// Where on the screen the content is (excludes scroll bars).
     inner_rect: Rect,
     content_ui: Ui,
     /// Relative coordinates: the offset and size of the view of the inner UI.
@@ -365,7 +380,11 @@ impl ScrollArea {
     /// Show the `ScrollArea`, and add the contents to the viewport.
     ///
     /// If the inner area can be very long, consider using [`Self::show_rows`] instead.
-    pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> R {
+    pub fn show<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui) -> R,
+    ) -> ScrollAreaOutput<R> {
         self.show_viewport_dyn(ui, Box::new(|ui, _viewport| add_contents(ui)))
     }
 
@@ -374,7 +393,7 @@ impl ScrollArea {
     /// ```
     /// # egui::__run_test_ui(|ui| {
     /// let text_style = egui::TextStyle::Body;
-    /// let row_height = ui.fonts()[text_style].row_height();
+    /// let row_height = ui.text_style_height(&text_style);
     /// // let row_height = ui.spacing().interact_size.y; // if you are adding buttons instead of labels.
     /// let total_rows = 10_000;
     /// egui::ScrollArea::vertical().show_rows(ui, row_height, total_rows, |ui, row_range| {
@@ -391,7 +410,7 @@ impl ScrollArea {
         row_height_sans_spacing: f32,
         total_rows: usize,
         add_contents: impl FnOnce(&mut Ui, std::ops::Range<usize>) -> R,
-    ) -> R {
+    ) -> ScrollAreaOutput<R> {
         let spacing = ui.spacing().item_spacing;
         let row_height_with_spacing = row_height_sans_spacing + spacing.y;
         self.show_viewport(ui, |ui, viewport| {
@@ -420,7 +439,11 @@ impl ScrollArea {
     ///
     /// `add_contents` is past the viewport, which is the relative view of the content.
     /// So if the passed rect has min = zero, then show the top left content (the user has not scrolled).
-    pub fn show_viewport<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui, Rect) -> R) -> R {
+    pub fn show_viewport<R>(
+        self,
+        ui: &mut Ui,
+        add_contents: impl FnOnce(&mut Ui, Rect) -> R,
+    ) -> ScrollAreaOutput<R> {
         self.show_viewport_dyn(ui, Box::new(add_contents))
     }
 
@@ -428,16 +451,23 @@ impl ScrollArea {
         self,
         ui: &mut Ui,
         add_contents: Box<dyn FnOnce(&mut Ui, Rect) -> R + 'c>,
-    ) -> R {
+    ) -> ScrollAreaOutput<R> {
         let mut prepared = self.begin(ui);
-        let ret = add_contents(&mut prepared.content_ui, prepared.viewport);
-        prepared.end(ui);
-        ret
+        let id = prepared.id;
+        let inner_rect = prepared.inner_rect;
+        let inner = add_contents(&mut prepared.content_ui, prepared.viewport);
+        let state = prepared.end(ui);
+        ScrollAreaOutput {
+            inner,
+            id,
+            state,
+            inner_rect,
+        }
     }
 }
 
 impl Prepared {
-    fn end(self, ui: &mut Ui) {
+    fn end(self, ui: &mut Ui) -> State {
         let Prepared {
             id,
             mut state,
@@ -523,12 +553,11 @@ impl Prepared {
             };
             let content_response = ui.interact(inner_rect, id.with("area"), sense);
 
-            let input = ui.input();
             if content_response.dragged() {
                 for d in 0..2 {
                     if has_bar[d] {
-                        state.offset[d] -= input.pointer.delta()[d];
-                        state.vel[d] = input.pointer.velocity()[d];
+                        state.offset[d] -= ui.input().pointer.delta()[d];
+                        state.vel[d] = ui.input().pointer.velocity()[d];
                         state.scroll_stuck_to_end[d] = false;
                     } else {
                         state.vel[d] = 0.0;
@@ -537,7 +566,7 @@ impl Prepared {
             } else {
                 let stop_speed = 20.0; // Pixels per second.
                 let friction_coeff = 1000.0; // Pixels per second squared.
-                let dt = input.unstable_dt;
+                let dt = ui.input().unstable_dt;
 
                 let friction = friction_coeff * dt;
                 if friction > state.vel.length() || state.vel.length() < stop_speed {
@@ -711,13 +740,13 @@ impl Prepared {
 
                 ui.painter().add(epaint::Shape::rect_filled(
                     outer_scroll_rect,
-                    visuals.corner_radius,
+                    visuals.rounding,
                     ui.visuals().extreme_bg_color,
                 ));
 
                 ui.painter().add(epaint::Shape::rect_filled(
                     handle_rect,
-                    visuals.corner_radius,
+                    visuals.rounding,
                     visuals.bg_fill,
                 ));
             }
@@ -748,6 +777,8 @@ impl Prepared {
         state.show_scroll = show_scroll_this_frame;
 
         state.store(ui.ctx(), id);
+
+        state
     }
 }
 
diff --git a/egui/src/containers/window.rs b/egui/src/containers/window.rs
index 4eceac70..9c439b26 100644
--- a/egui/src/containers/window.rs
+++ b/egui/src/containers/window.rs
@@ -235,7 +235,7 @@ impl<'open> Window<'open> {
     #[inline]
     pub fn show<R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> Option<InnerResponse<Option<R>>> {
         self.show_dyn(ctx, Box::new(add_contents))
@@ -243,7 +243,7 @@ impl<'open> Window<'open> {
 
     fn show_dyn<'c, R>(
         self,
-        ctx: &CtxRef,
+        ctx: &Context,
         add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>,
     ) -> Option<InnerResponse<Option<R>>> {
         let Window {
@@ -296,7 +296,8 @@ impl<'open> Window<'open> {
             .and_then(|window_interaction| {
                 // Calculate roughly how much larger the window size is compared to the inner rect
                 let title_bar_height = if with_title_bar {
-                    title.font_height(ctx.fonts(), &ctx.style()) + title_content_spacing
+                    let style = ctx.style();
+                    title.font_height(&ctx.fonts(), &style) + title_content_spacing
                 } else {
                     0.0
                 };
@@ -353,7 +354,7 @@ impl<'open> Window<'open> {
                         }
 
                         if scroll.has_any_bar() {
-                            scroll.show(ui, add_contents)
+                            scroll.show(ui, add_contents).inner
                         } else {
                             add_contents(ui)
                         }
@@ -698,42 +699,62 @@ fn paint_frame_interaction(
 ) {
     use epaint::tessellator::path::add_circle_quadrant;
 
-    let cr = ui.visuals().window_corner_radius;
+    let rounding = ui.visuals().window_rounding;
     let Rect { min, max } = rect;
 
     let mut points = Vec::new();
 
     if interaction.right && !interaction.bottom && !interaction.top {
-        points.push(pos2(max.x, min.y + cr));
-        points.push(pos2(max.x, max.y - cr));
+        points.push(pos2(max.x, min.y + rounding.ne));
+        points.push(pos2(max.x, max.y - rounding.se));
     }
     if interaction.right && interaction.bottom {
-        points.push(pos2(max.x, min.y + cr));
-        points.push(pos2(max.x, max.y - cr));
-        add_circle_quadrant(&mut points, pos2(max.x - cr, max.y - cr), cr, 0.0);
+        points.push(pos2(max.x, min.y + rounding.ne));
+        points.push(pos2(max.x, max.y - rounding.se));
+        add_circle_quadrant(
+            &mut points,
+            pos2(max.x - rounding.se, max.y - rounding.se),
+            rounding.se,
+            0.0,
+        );
     }
     if interaction.bottom {
-        points.push(pos2(max.x - cr, max.y));
-        points.push(pos2(min.x + cr, max.y));
+        points.push(pos2(max.x - rounding.se, max.y));
+        points.push(pos2(min.x + rounding.sw, max.y));
     }
     if interaction.left && interaction.bottom {
-        add_circle_quadrant(&mut points, pos2(min.x + cr, max.y - cr), cr, 1.0);
+        add_circle_quadrant(
+            &mut points,
+            pos2(min.x + rounding.sw, max.y - rounding.sw),
+            rounding.sw,
+            1.0,
+        );
     }
     if interaction.left {
-        points.push(pos2(min.x, max.y - cr));
-        points.push(pos2(min.x, min.y + cr));
+        points.push(pos2(min.x, max.y - rounding.sw));
+        points.push(pos2(min.x, min.y + rounding.nw));
     }
     if interaction.left && interaction.top {
-        add_circle_quadrant(&mut points, pos2(min.x + cr, min.y + cr), cr, 2.0);
+        add_circle_quadrant(
+            &mut points,
+            pos2(min.x + rounding.nw, min.y + rounding.nw),
+            rounding.nw,
+            2.0,
+        );
     }
     if interaction.top {
-        points.push(pos2(min.x + cr, min.y));
-        points.push(pos2(max.x - cr, min.y));
+        points.push(pos2(min.x + rounding.nw, min.y));
+        points.push(pos2(max.x - rounding.ne, min.y));
     }
     if interaction.right && interaction.top {
-        add_circle_quadrant(&mut points, pos2(max.x - cr, min.y + cr), cr, 3.0);
-        points.push(pos2(max.x, min.y + cr));
-        points.push(pos2(max.x, max.y - cr));
+        add_circle_quadrant(
+            &mut points,
+            pos2(max.x - rounding.ne, min.y + rounding.ne),
+            rounding.ne,
+            3.0,
+        );
+        points.push(pos2(max.x, min.y + rounding.ne));
+        points.push(pos2(max.x, max.y - rounding.se));
     }
     ui.painter().add(Shape::line(points, visuals.bg_stroke));
 }
@@ -741,9 +762,16 @@ fn paint_frame_interaction(
 // ----------------------------------------------------------------------------
 
 struct TitleBar {
+    /// A title Id used for dragging windows
     id: Id,
+    /// Prepared text in the title
     title_galley: WidgetTextGalley,
+    /// Size of the title bar in a collapsed state (if window is collapsible),
+    /// which includes all necessary space for showing the expand button, the
+    /// title and the close button.
     min_rect: Rect,
+    /// Size of the title bar in an expanded state. This size become known only
+    /// after expanding window and painting its content
     rect: Rect,
 }
 
@@ -757,7 +785,7 @@ fn show_title_bar(
 ) -> TitleBar {
     let inner_response = ui.horizontal(|ui| {
         let height = title
-            .font_height(ui.fonts(), ui.style())
+            .font_height(&ui.fonts(), ui.style())
             .max(ui.spacing().interact_size.y);
         ui.set_min_height(height);
 
@@ -775,7 +803,7 @@ fn show_title_bar(
                 collapsing.toggle(ui);
             }
             let openness = collapsing.openness(ui.ctx(), collapsing_id);
-            collapsing_header::paint_icon(ui, openness, &collapse_button_response);
+            collapsing_header::paint_default_icon(ui, openness, &collapse_button_response);
         }
 
         let title_galley = title.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Heading);
@@ -804,6 +832,20 @@ fn show_title_bar(
 }
 
 impl TitleBar {
+    /// Finishes painting of the title bar when the window content size already known.
+    ///
+    /// # Parameters
+    ///
+    /// - `ui`:
+    /// - `outer_rect`:
+    /// - `content_response`: if `None`, window is collapsed at this frame, otherwise contains
+    ///   a result of rendering the window content
+    /// - `open`: if `None`, no "Close" button will be rendered, otherwise renders and processes
+    ///   the "Close" button and writes a `false` if window was closed
+    /// - `collapsing`: holds the current expanding state. Can be changed by double click on the
+    ///   title if `collapsible` is `true`
+    /// - `collapsible`: if `true`, double click on the title bar will be handled for a change
+    ///   of `collapsing` state
     fn ui(
         mut self,
         ui: &mut Ui,
@@ -857,6 +899,11 @@ impl TitleBar {
         }
     }
 
+    /// Paints the "Close" button at the right side of the title bar
+    /// and processes clicks on it.
+    ///
+    /// The button is square and its size is determined by the
+    /// [`crate::style::Spacing::icon_width`] setting.
     fn close_button_ui(&self, ui: &mut Ui) -> Response {
         let button_size = Vec2::splat(ui.spacing().icon_width);
         let pad = (self.rect.height() - button_size.y) / 2.0; // calculated so that the icon is on the diagonal (if window padding is symmetrical)
@@ -872,6 +919,16 @@ impl TitleBar {
     }
 }
 
+/// Paints the "Close" button of the window and processes clicks on it.
+///
+/// The close button is just an `X` symbol painted by a current stroke
+/// for foreground elements (such as a label text).
+///
+/// # Parameters
+/// - `ui`:
+/// - `rect`: The rectangular area to fit the button in
+///
+/// Returns the result of a click on a button if it was pressed
 fn close_button(ui: &mut Ui, rect: Rect) -> Response {
     let close_id = ui.auto_id_with("window_close_button");
     let response = ui.interact(rect, close_id, Sense::click());
@@ -880,9 +937,9 @@ fn close_button(ui: &mut Ui, rect: Rect) -> Response {
     let visuals = ui.style().interact(&response);
     let rect = rect.shrink(2.0).expand(visuals.expansion);
     let stroke = visuals.fg_stroke;
-    ui.painter()
+    ui.painter() // paints \
         .line_segment([rect.left_top(), rect.right_bottom()], stroke);
-    ui.painter()
+    ui.painter() // paints /
         .line_segment([rect.right_top(), rect.left_bottom()], stroke);
     response
 }
diff --git a/egui/src/context.rs b/egui/src/context.rs
index ad5c8482..3695b91c 100644
--- a/egui/src/context.rs
+++ b/egui/src/context.rs
@@ -1,40 +1,129 @@
 // #![warn(missing_docs)]
 
-use std::sync::{
-    atomic::{AtomicU32, Ordering::SeqCst},
-    Arc,
-};
-
 use crate::{
-    animation_manager::AnimationManager,
-    data::output::Output,
-    frame_state::FrameState,
-    input_state::*,
-    layers::GraphicLayers,
-    menu::ContextMenuSystem,
-    mutex::{Mutex, MutexGuard},
-    *,
+    animation_manager::AnimationManager, data::output::Output, frame_state::FrameState,
+    input_state::*, layers::GraphicLayers, memory::Options, TextureHandle, *,
 };
-use epaint::{stats::*, text::Fonts, *};
+use epaint::{mutex::*, stats::*, text::Fonts, TessellationOptions, *};
 
 // ----------------------------------------------------------------------------
 
-/// A wrapper around [`Arc`](std::sync::Arc)`<`[`Context`]`>`.
-/// This is how you will normally create and access a [`Context`].
+struct WrappedTextureManager(Arc<RwLock<epaint::TextureManager>>);
+
+impl Default for WrappedTextureManager {
+    fn default() -> Self {
+        let mut tex_mngr = epaint::textures::TextureManager::default();
+
+        // Will be filled in later
+        let font_id = tex_mngr.alloc(
+            "egui_font_texture".into(),
+            epaint::AlphaImage::new([0, 0]).into(),
+        );
+        assert_eq!(font_id, TextureId::default());
+
+        Self(Arc::new(RwLock::new(tex_mngr)))
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Default)]
+struct ContextImpl {
+    /// `None` until the start of the first frame.
+    fonts: Option<Fonts>,
+    memory: Memory,
+    animation_manager: AnimationManager,
+    tex_manager: WrappedTextureManager,
+
+    input: InputState,
+
+    /// State that is collected during a frame and then cleared
+    frame_state: FrameState,
+
+    // The output of a frame:
+    graphics: GraphicLayers,
+    output: Output,
+
+    paint_stats: PaintStats,
+
+    /// While positive, keep requesting repaints. Decrement at the end of each frame.
+    repaint_requests: u32,
+}
+
+impl ContextImpl {
+    fn begin_frame_mut(&mut self, new_raw_input: RawInput) {
+        self.memory.begin_frame(&self.input, &new_raw_input);
+
+        self.input = std::mem::take(&mut self.input).begin_frame(new_raw_input);
+
+        if let Some(new_pixels_per_point) = self.memory.new_pixels_per_point.take() {
+            self.input.pixels_per_point = new_pixels_per_point;
+        }
+
+        self.frame_state.begin_frame(&self.input);
+
+        self.update_fonts_mut();
+
+        // Ensure we register the background area so panels and background ui can catch clicks:
+        let screen_rect = self.input.screen_rect();
+        self.memory.areas.set_state(
+            LayerId::background(),
+            containers::area::State {
+                pos: screen_rect.min,
+                size: screen_rect.size(),
+                interactable: true,
+            },
+        );
+    }
+
+    /// Load fonts unless already loaded.
+    fn update_fonts_mut(&mut self) {
+        let pixels_per_point = self.input.pixels_per_point();
+        let max_texture_side = self.input.raw.max_texture_side;
+
+        if let Some(font_definitions) = self.memory.new_font_definitions.take() {
+            let fonts = Fonts::new(pixels_per_point, max_texture_side, font_definitions);
+            self.fonts = Some(fonts);
+        }
+
+        let fonts = self.fonts.get_or_insert_with(|| {
+            let font_definitions = FontDefinitions::default();
+            Fonts::new(pixels_per_point, max_texture_side, font_definitions)
+        });
+
+        fonts.begin_frame(pixels_per_point, max_texture_side);
+
+        if self.memory.options.preload_font_glyphs {
+            // Preload the most common characters for the most common fonts.
+            // This is not very important to do, but may a few GPU operations.
+            for font_id in self.memory.options.style.text_styles.values() {
+                fonts.lock().fonts.font(font_id).preload_common_characters();
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Your handle to egui.
 ///
-/// Almost all methods are marked `&self`, `Context` has interior mutability (protected by mutexes).
+/// This is the first thing you need when working with egui.
+/// Contains the [`InputState`], [`Memory`], [`Output`], and more.
 ///
-/// [`CtxRef`] is cheap to clone, and any clones refers to the same mutable data.
+/// [`Context`] is cheap to clone, and any clones refers to the same mutable data
+/// ([`Context`] uses refcounting internally).
 ///
-/// A [`CtxRef`] is only valid for the duration of a frame, and so you should not store a [`CtxRef`] between frames.
-/// A new [`CtxRef`] is created each frame by calling [`Self::run`].
+/// All methods are marked `&self`; `Context` has interior mutability (protected by a mutex).
+///
+///
+/// You can store
 ///
 /// # Example:
 ///
 /// ``` no_run
 /// # fn handle_output(_: egui::Output) {}
 /// # fn paint(_: Vec<egui::ClippedMesh>) {}
-/// let mut ctx = egui::CtxRef::default();
+/// let mut ctx = egui::Context::default();
 ///
 /// // Game loop:
 /// loop {
@@ -53,58 +142,46 @@ use epaint::{stats::*, text::Fonts, *};
 /// }
 /// ```
 #[derive(Clone)]
-pub struct CtxRef(std::sync::Arc<Context>);
+pub struct Context(Arc<RwLock<ContextImpl>>);
 
-impl std::ops::Deref for CtxRef {
-    type Target = Context;
-
-    fn deref(&self) -> &Context {
-        &*self.0
-    }
-}
-
-impl AsRef<Context> for CtxRef {
-    fn as_ref(&self) -> &Context {
-        self.0.as_ref()
-    }
-}
-
-impl std::borrow::Borrow<Context> for CtxRef {
-    fn borrow(&self) -> &Context {
-        self.0.borrow()
-    }
-}
-
-impl std::cmp::PartialEq for CtxRef {
-    fn eq(&self, other: &CtxRef) -> bool {
+impl std::cmp::PartialEq for Context {
+    fn eq(&self, other: &Context) -> bool {
         Arc::ptr_eq(&self.0, &other.0)
     }
 }
 
-impl Default for CtxRef {
+impl Default for Context {
     fn default() -> Self {
-        Self(Arc::new(Context {
+        Self(Arc::new(RwLock::new(ContextImpl {
             // Start with painting an extra frame to compensate for some widgets
             // that take two frames before they "settle":
-            repaint_requests: AtomicU32::new(1),
-            ..Context::default()
-        }))
+            repaint_requests: 1,
+            ..ContextImpl::default()
+        })))
     }
 }
 
-impl CtxRef {
+impl Context {
+    fn read(&self) -> RwLockReadGuard<'_, ContextImpl> {
+        self.0.read()
+    }
+
+    fn write(&self) -> RwLockWriteGuard<'_, ContextImpl> {
+        self.0.write()
+    }
+
     /// Run the ui code for one frame.
     ///
     /// Put your widgets into a [`SidePanel`], [`TopBottomPanel`], [`CentralPanel`], [`Window`] or [`Area`].
     ///
     /// This will modify the internal reference to point to a new generation of [`Context`].
-    /// Any old clones of this [`CtxRef`] will refer to the old [`Context`], which will not get new input.
+    /// Any old clones of this [`Context`] will refer to the old [`Context`], which will not get new input.
     ///
     /// You can alternatively run [`Self::begin_frame`] and [`Context::end_frame`].
     ///
-    /// ``` rust
+    /// ```
     /// // One egui context that you keep reusing:
-    /// let mut ctx = egui::CtxRef::default();
+    /// let mut ctx = egui::Context::default();
     ///
     /// // Each frame:
     /// let input = egui::RawInput::default();
@@ -117,9 +194,9 @@ impl CtxRef {
     /// ```
     #[must_use]
     pub fn run(
-        &mut self,
+        &self,
         new_input: RawInput,
-        run_ui: impl FnOnce(&CtxRef),
+        run_ui: impl FnOnce(&Context),
     ) -> (Output, Vec<ClippedShape>) {
         self.begin_frame(new_input);
         run_ui(self);
@@ -128,9 +205,9 @@ impl CtxRef {
 
     /// An alternative to calling [`Self::run`].
     ///
-    /// ``` rust
+    /// ```
     /// // One egui context that you keep reusing:
-    /// let mut ctx = egui::CtxRef::default();
+    /// let mut ctx = egui::Context::default();
     ///
     /// // Each frame:
     /// let input = egui::RawInput::default();
@@ -143,10 +220,8 @@ impl CtxRef {
     /// let (output, shapes) = ctx.end_frame();
     /// // handle output, paint shapes
     /// ```
-    pub fn begin_frame(&mut self, new_input: RawInput) {
-        let mut self_: Context = (*self.0).clone();
-        self_.begin_frame_mut(new_input);
-        *self = Self(Arc::new(self_));
+    pub fn begin_frame(&self, new_input: RawInput) {
+        self.write().begin_frame_mut(new_input);
     }
 
     // ---------------------------------------------------------------------
@@ -167,7 +242,7 @@ impl CtxRef {
             let show_error = |pos: Pos2, text: String| {
                 let painter = self.debug_painter();
                 let rect = painter.error(pos, text);
-                if let Some(pointer_pos) = self.input.pointer.hover_pos() {
+                if let Some(pointer_pos) = self.pointer_hover_pos() {
                     if rect.contains(pointer_pos) {
                         painter.error(
                             rect.left_bottom() + vec2(2.0, 4.0),
@@ -244,14 +319,19 @@ impl CtxRef {
             changed: false, // must be set by the widget itself
         };
 
-        let mut memory = self.memory();
-
         if !enabled || !sense.focusable || !layer_id.allow_interaction() {
             // Not interested or allowed input:
-            memory.surrender_focus(id);
+            self.memory().surrender_focus(id);
             return response;
         }
 
+        self.register_interaction_id(id, rect);
+
+        let clicked_elsewhere = response.clicked_elsewhere();
+        let ctx_impl = &mut *self.write();
+        let memory = &mut ctx_impl.memory;
+        let input = &mut ctx_impl.input;
+
         // We only want to focus labels if the screen reader is on.
         let interested_in_focus =
             sense.interactive() || sense.focusable && memory.options.screen_reader;
@@ -262,14 +342,12 @@ impl CtxRef {
 
         if sense.click
             && memory.has_focus(response.id)
-            && (self.input().key_pressed(Key::Space) || self.input().key_pressed(Key::Enter))
+            && (input.key_pressed(Key::Space) || input.key_pressed(Key::Enter))
         {
             // Space/enter works like a primary click for e.g. selected buttons
             response.clicked[PointerButton::Primary as usize] = true;
         }
 
-        self.register_interaction_id(id, rect);
-
         if sense.click || sense.drag {
             memory.interaction.click_interest |= hovered && sense.click;
             memory.interaction.drag_interest |= hovered && sense.drag;
@@ -278,7 +356,7 @@ impl CtxRef {
             response.is_pointer_button_down_on =
                 memory.interaction.click_id == Some(id) || response.dragged;
 
-            for pointer_event in &self.input.pointer.pointer_events {
+            for pointer_event in &input.pointer.pointer_events {
                 match pointer_event {
                     PointerEvent::Moved(_) => {}
                     PointerEvent::Pressed(_) => {
@@ -325,14 +403,14 @@ impl CtxRef {
         }
 
         if response.is_pointer_button_down_on {
-            response.interact_pointer_pos = self.input().pointer.interact_pos();
+            response.interact_pointer_pos = input.pointer.interact_pos();
         }
 
-        if self.input.pointer.any_down() {
+        if input.pointer.any_down() {
             response.hovered &= response.is_pointer_button_down_on; // we don't hover widgets while interacting with *other* widgets
         }
 
-        if memory.has_focus(response.id) && response.clicked_elsewhere() {
+        if memory.has_focus(response.id) && clicked_elsewhere {
             memory.surrender_focus(id);
         }
 
@@ -346,134 +424,119 @@ impl CtxRef {
 
     /// Get a full-screen painter for a new or existing layer
     pub fn layer_painter(&self, layer_id: LayerId) -> Painter {
-        Painter::new(self.clone(), layer_id, self.input.screen_rect())
+        let screen_rect = self.input().screen_rect();
+        Painter::new(self.clone(), layer_id, screen_rect)
     }
 
     /// Paint on top of everything else
     pub fn debug_painter(&self) -> Painter {
         Self::layer_painter(self, LayerId::debug())
     }
-}
 
-// ----------------------------------------------------------------------------
-
-/// Your handle to egui.
-///
-/// This is the first thing you need when working with egui.
-/// Use [`CtxRef`] to create and refer to a [`Context`].
-///
-/// Contains the [`InputState`], [`Memory`], [`Output`], and more.
-///
-/// Almost all methods are marked `&self`, [`Context`] has interior mutability (protected by mutexes).
-/// Multi-threaded access to a [`Context`] is behind the feature flag `multi_threaded`.
-/// Normally you'd always do all ui work on one thread, or perhaps use multiple contexts,
-/// but if you really want to access the same [`Context`] from multiple threads, it *SHOULD* be fine,
-/// but you are likely the first person to try it.
-#[derive(Default)]
-pub struct Context {
-    // We clone the Context each frame so we can set a new `input`.
-    // This is so we can avoid a mutex lock to access the `InputState`.
-    // This means everything else needs to be behind an Arc.
-    // We can probably come up with a nicer design.
-    //
-    /// `None` until the start of the first frame.
-    fonts: Option<Arc<Fonts>>,
-    memory: Arc<Mutex<Memory>>,
-    animation_manager: Arc<Mutex<AnimationManager>>,
-    context_menu_system: Arc<Mutex<ContextMenuSystem>>,
-
-    input: InputState,
-
-    /// State that is collected during a frame and then cleared
-    frame_state: Arc<Mutex<FrameState>>,
-
-    // The output of a frame:
-    graphics: Arc<Mutex<GraphicLayers>>,
-    output: Arc<Mutex<Output>>,
-
-    paint_stats: Arc<Mutex<PaintStats>>,
-
-    /// While positive, keep requesting repaints. Decrement at the end of each frame.
-    repaint_requests: AtomicU32,
-}
-
-impl Clone for Context {
-    fn clone(&self) -> Self {
-        Context {
-            fonts: self.fonts.clone(),
-            memory: self.memory.clone(),
-            animation_manager: self.animation_manager.clone(),
-            input: self.input.clone(),
-            frame_state: self.frame_state.clone(),
-            graphics: self.graphics.clone(),
-            output: self.output.clone(),
-            paint_stats: self.paint_stats.clone(),
-            repaint_requests: self.repaint_requests.load(SeqCst).into(),
-            context_menu_system: self.context_menu_system.clone(),
-        }
-    }
-}
-
-impl Context {
     /// How much space is still available after panels has been added.
     /// This is the "background" area, what egui doesn't cover with panels (but may cover with windows).
     /// This is also the area to which windows are constrained.
     pub fn available_rect(&self) -> Rect {
-        self.frame_state.lock().available_rect()
+        self.frame_state().available_rect()
     }
+}
 
+/// ## Borrows parts of [`Context`]
+impl Context {
     /// Stores all the egui state.
+    ///
     /// If you want to store/restore egui, serialize this.
-    pub fn memory(&self) -> MutexGuard<'_, Memory> {
-        self.memory.lock()
+    #[inline]
+    pub fn memory(&self) -> RwLockWriteGuard<'_, Memory> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.memory)
     }
 
-    pub(crate) fn context_menu_system(&self) -> MutexGuard<'_, ContextMenuSystem> {
-        self.context_menu_system.lock()
+    /// Stores superficial widget state.
+    #[inline]
+    pub fn data(&self) -> RwLockWriteGuard<'_, crate::util::IdTypeMap> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.memory.data)
     }
 
-    pub(crate) fn graphics(&self) -> MutexGuard<'_, GraphicLayers> {
-        self.graphics.lock()
+    #[inline]
+    pub(crate) fn graphics(&self) -> RwLockWriteGuard<'_, GraphicLayers> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.graphics)
     }
 
     /// What egui outputs each frame.
-    pub fn output(&self) -> MutexGuard<'_, Output> {
-        self.output.lock()
+    #[inline]
+    pub fn output(&self) -> RwLockWriteGuard<'_, Output> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.output)
     }
 
-    pub(crate) fn frame_state(&self) -> MutexGuard<'_, FrameState> {
-        self.frame_state.lock()
+    #[inline]
+    pub(crate) fn frame_state(&self) -> RwLockWriteGuard<'_, FrameState> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.frame_state)
     }
 
+    /// Access the [`InputState`].
+    ///
+    /// Note that this locks the [`Context`], so be careful with if-let bindings:
+    ///
+    /// ```
+    /// # let mut ctx = egui::Context::default();
+    /// if let Some(pos) = ctx.input().pointer.hover_pos() {
+    ///     // ⚠️ Using `ctx` again here will lead to a dead-lock!
+    /// }
+    ///
+    /// if let Some(pos) = { ctx.input().pointer.hover_pos() } {
+    ///     // This is fine!
+    /// }
+    ///
+    /// let pos = ctx.input().pointer.hover_pos();
+    /// if let Some(pos) = pos {
+    ///     // This is fine!
+    /// }
+    /// ```
+    #[inline]
+    pub fn input(&self) -> RwLockReadGuard<'_, InputState> {
+        RwLockReadGuard::map(self.read(), |c| &c.input)
+    }
+
+    #[inline]
+    pub fn input_mut(&self) -> RwLockWriteGuard<'_, InputState> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.input)
+    }
+
+    /// Not valid until first call to [`Context::run()`].
+    /// That's because since we don't know the proper `pixels_per_point` until then.
+    #[inline]
+    pub fn fonts(&self) -> RwLockReadGuard<'_, Fonts> {
+        RwLockReadGuard::map(self.read(), |c| {
+            c.fonts
+                .as_ref()
+                .expect("No fonts available until first call to Context::run()")
+        })
+    }
+
+    #[inline]
+    fn fonts_mut(&self) -> RwLockWriteGuard<'_, Option<Fonts>> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.fonts)
+    }
+
+    #[inline]
+    pub fn options(&self) -> RwLockWriteGuard<'_, Options> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.memory.options)
+    }
+
+    /// Change the options used by the tessellator.
+    #[inline]
+    pub fn tessellation_options(&self) -> RwLockWriteGuard<'_, TessellationOptions> {
+        RwLockWriteGuard::map(self.write(), |c| &mut c.memory.options.tessellation_options)
+    }
+}
+
+impl Context {
     /// Call this if there is need to repaint the UI, i.e. if you are showing an animation.
     /// If this is called at least once in a frame, then there will be another frame right after this.
     /// Call as many times as you wish, only one repaint will be issued.
     pub fn request_repaint(&self) {
         // request two frames of repaint, just to cover some corner cases (frame delays):
-        let times_to_repaint = 2;
-        self.repaint_requests.store(times_to_repaint, SeqCst);
-    }
-
-    #[inline(always)]
-    pub fn input(&self) -> &InputState {
-        &self.input
-    }
-
-    /// Not valid until first call to [`CtxRef::run()`].
-    /// That's because since we don't know the proper `pixels_per_point` until then.
-    pub fn fonts(&self) -> &Fonts {
-        &*self
-            .fonts
-            .as_ref()
-            .expect("No fonts available until first call to CtxRef::run()")
-    }
-
-    /// The egui font image, containing font characters etc.
-    ///
-    /// Not valid until first call to [`CtxRef::run()`].
-    /// That's because since we don't know the proper `pixels_per_point` until then.
-    pub fn font_image(&self) -> Arc<epaint::FontImage> {
-        self.fonts().font_image()
+        self.write().repaint_requests = 2;
     }
 
     /// Tell `egui` which fonts to use.
@@ -483,9 +546,9 @@ impl Context {
     ///
     /// The new fonts will become active at the start of the next frame.
     pub fn set_fonts(&self, font_definitions: FontDefinitions) {
-        if let Some(current_fonts) = &self.fonts {
+        if let Some(current_fonts) = &*self.fonts_mut() {
             // NOTE: this comparison is expensive since it checks TTF data for equality
-            if current_fonts.definitions() == &font_definitions {
+            if current_fonts.lock().fonts.definitions() == &font_definitions {
                 return; // no change - save us from reloading font textures
             }
         }
@@ -495,7 +558,7 @@ impl Context {
 
     /// The [`Style`] used by all subsequent windows, panels etc.
     pub fn style(&self) -> Arc<Style> {
-        self.memory().options.style.clone()
+        self.options().style.clone()
     }
 
     /// The [`Style`] used by all new windows, panels etc.
@@ -504,13 +567,13 @@ impl Context {
     ///
     /// Example:
     /// ```
-    /// # let mut ctx = egui::CtxRef::default();
+    /// # let mut ctx = egui::Context::default();
     /// let mut style: egui::Style = (*ctx.style()).clone();
     /// style.spacing.item_spacing = egui::vec2(10.0, 20.0);
     /// ctx.set_style(style);
     /// ```
     pub fn set_style(&self, style: impl Into<Arc<Style>>) {
-        self.memory().options.style = style.into();
+        self.options().style = style.into();
     }
 
     /// The [`Visuals`] used by all subsequent windows, panels etc.
@@ -519,17 +582,17 @@ impl Context {
     ///
     /// Example:
     /// ```
-    /// # let mut ctx = egui::CtxRef::default();
+    /// # let mut ctx = egui::Context::default();
     /// ctx.set_visuals(egui::Visuals::light()); // Switch to light mode
     /// ```
     pub fn set_visuals(&self, visuals: crate::Visuals) {
-        std::sync::Arc::make_mut(&mut self.memory().options.style).visuals = visuals;
+        std::sync::Arc::make_mut(&mut self.options().style).visuals = visuals;
     }
 
     /// The number of physical pixels for each logical point.
     #[inline(always)]
     pub fn pixels_per_point(&self) -> f32 {
-        self.input.pixels_per_point()
+        self.input().pixels_per_point()
     }
 
     /// Set the number of physical pixels for each logical point.
@@ -569,6 +632,54 @@ impl Context {
         }
     }
 
+    /// Allocate a texture.
+    ///
+    /// In order to display an image you must convert it to a texture using this function.
+    ///
+    /// Make sure to only call this once for each image, i.e. NOT in your main GUI code.
+    ///
+    /// The given name can be useful for later debugging, and will be visible if you call [`Self::texture_ui`].
+    ///
+    /// For how to load an image, see [`ImageData`] and [`ColorImage::from_rgba_unmultiplied`].
+    ///
+    /// ```
+    /// struct MyImage {
+    ///     texture: Option<egui::TextureHandle>,
+    /// }
+    ///
+    /// impl MyImage {
+    ///     fn ui(&mut self, ui: &mut egui::Ui) {
+    ///         let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+    ///             // Load the texture only once.
+    ///             ui.ctx().load_texture("my-image", egui::ColorImage::example())
+    ///         });
+    ///
+    ///         // Show the image:
+    ///         ui.image(texture, texture.size_vec2());
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Se also [`crate::ImageData`], [`crate::Ui::image`] and [`crate::ImageButton`].
+    pub fn load_texture(
+        &self,
+        name: impl Into<String>,
+        image: impl Into<ImageData>,
+    ) -> TextureHandle {
+        let tex_mngr = self.tex_manager();
+        let tex_id = tex_mngr.write().alloc(name.into(), image.into());
+        TextureHandle::new(tex_mngr, tex_id)
+    }
+
+    /// Low-level texture manager.
+    ///
+    /// In general it is easier to use [`Self::load_texture`] and [`TextureHandle`].
+    ///
+    /// You can show stats about the allocated textures using [`Self::texture_ui`].
+    pub fn tex_manager(&self) -> Arc<RwLock<epaint::textures::TextureManager>> {
+        self.read().tex_manager.0.clone()
+    }
+
     // ---------------------------------------------------------------------
 
     /// Constrain the position of a window/area so it fits within the provided boundary.
@@ -604,75 +715,42 @@ impl Context {
 
         Rect::from_min_size(pos, window.size())
     }
+}
 
-    // ---------------------------------------------------------------------
-
-    fn begin_frame_mut(&mut self, new_raw_input: RawInput) {
-        self.memory().begin_frame(&self.input, &new_raw_input);
-
-        let mut input = std::mem::take(&mut self.input);
-        if let Some(new_pixels_per_point) = self.memory().new_pixels_per_point.take() {
-            input.pixels_per_point = new_pixels_per_point;
-        }
-
-        self.input = input.begin_frame(new_raw_input);
-        self.frame_state.lock().begin_frame(&self.input);
-
-        self.update_fonts(self.input.pixels_per_point());
-
-        // Ensure we register the background area so panels and background ui can catch clicks:
-        let screen_rect = self.input.screen_rect();
-        self.memory().areas.set_state(
-            LayerId::background(),
-            containers::area::State {
-                pos: screen_rect.min,
-                size: screen_rect.size(),
-                interactable: true,
-            },
-        );
-    }
-
-    /// Load fonts unless already loaded.
-    fn update_fonts(&mut self, pixels_per_point: f32) {
-        let new_font_definitions = self.memory().new_font_definitions.take();
-
-        let pixels_per_point_changed = match &self.fonts {
-            None => true,
-            Some(current_fonts) => {
-                (current_fonts.pixels_per_point() - pixels_per_point).abs() > 1e-3
-            }
-        };
-
-        if self.fonts.is_none() || new_font_definitions.is_some() || pixels_per_point_changed {
-            self.fonts = Some(Arc::new(Fonts::new(
-                pixels_per_point,
-                new_font_definitions.unwrap_or_else(|| {
-                    self.fonts
-                        .as_ref()
-                        .map(|font| font.definitions().clone())
-                        .unwrap_or_default()
-                }),
-            )));
-        }
-    }
-
+impl Context {
     /// Call at the end of each frame.
     /// Returns what has happened this frame [`crate::Output`] as well as what you need to paint.
     /// You can transform the returned shapes into triangles with a call to [`Context::tessellate`].
     #[must_use]
     pub fn end_frame(&self) -> (Output, Vec<ClippedShape>) {
-        if self.input.wants_repaint() {
+        if self.input().wants_repaint() {
             self.request_repaint();
         }
 
-        self.memory()
-            .end_frame(&self.input, &self.frame_state().used_ids);
+        {
+            let ctx_impl = &mut *self.write();
+            ctx_impl
+                .memory
+                .end_frame(&ctx_impl.input, &ctx_impl.frame_state.used_ids);
 
-        self.fonts().end_frame();
+            let font_image_delta = ctx_impl.fonts.as_ref().unwrap().font_image_delta();
+            if let Some(font_image_delta) = font_image_delta {
+                ctx_impl
+                    .tex_manager
+                    .0
+                    .write()
+                    .set(TextureId::default(), font_image_delta);
+            }
+
+            ctx_impl
+                .output
+                .textures_delta
+                .append(ctx_impl.tex_manager.0.write().take_delta());
+        }
 
         let mut output: Output = std::mem::take(&mut self.output());
-        if self.repaint_requests.load(SeqCst) > 0 {
-            self.repaint_requests.fetch_sub(1, SeqCst);
+        if self.read().repaint_requests > 0 {
+            self.write().repaint_requests -= 1;
             output.needs_repaint = true;
         }
 
@@ -681,8 +759,11 @@ impl Context {
     }
 
     fn drain_paint_lists(&self) -> Vec<ClippedShape> {
-        let memory = self.memory();
-        self.graphics().drain(memory.areas.order()).collect()
+        let ctx_impl = &mut *self.write();
+        ctx_impl
+            .graphics
+            .drain(ctx_impl.memory.areas.order())
+            .collect()
     }
 
     /// Tessellate the given shapes into triangle meshes.
@@ -691,16 +772,16 @@ impl Context {
         // shapes are the same, but just comparing the shapes takes about 50% of the time
         // it takes to tessellate them, so it is not a worth optimization.
 
-        let mut tessellation_options = self.memory().options.tessellation_options;
+        let mut tessellation_options = *self.tessellation_options();
         tessellation_options.pixels_per_point = self.pixels_per_point();
         tessellation_options.aa_size = 1.0 / self.pixels_per_point();
         let paint_stats = PaintStats::from_shapes(&shapes);
         let clipped_meshes = tessellator::tessellate_shapes(
             shapes,
             tessellation_options,
-            self.fonts().font_image().size(),
+            self.fonts().font_image_size(),
         );
-        *self.paint_stats.lock() = paint_stats.with_clipped_meshes(&clipped_meshes);
+        self.write().paint_stats = paint_stats.with_clipped_meshes(&clipped_meshes);
         clipped_meshes
     }
 
@@ -725,7 +806,8 @@ impl Context {
 
     /// Is the pointer (mouse/touch) over any egui area?
     pub fn is_pointer_over_area(&self) -> bool {
-        if let Some(pointer_pos) = self.input.pointer.interact_pos() {
+        let pointer_pos = self.input().pointer.interact_pos();
+        if let Some(pointer_pos) = pointer_pos {
             if let Some(layer) = self.layer_id_at(pointer_pos) {
                 if layer.order == Order::Background {
                     !self.frame_state().unused_rect.contains(pointer_pos)
@@ -759,14 +841,45 @@ impl Context {
     pub fn wants_keyboard_input(&self) -> bool {
         self.memory().interaction.focus.focused().is_some()
     }
+}
 
-    // ---------------------------------------------------------------------
+// Ergonomic methods to forward some calls often used in 'if let' without holding the borrow
+impl Context {
+    /// Latest reported pointer position.
+    /// When tapping a touch screen, this will be `None`.
+    #[inline(always)]
+    pub(crate) fn latest_pointer_pos(&self) -> Option<Pos2> {
+        self.input().pointer.latest_pos()
+    }
 
+    /// If it is a good idea to show a tooltip, where is pointer?
+    #[inline(always)]
+    pub fn pointer_hover_pos(&self) -> Option<Pos2> {
+        self.input().pointer.hover_pos()
+    }
+
+    /// If you detect a click or drag and wants to know where it happened, use this.
+    ///
+    /// Latest position of the mouse, but ignoring any [`Event::PointerGone`]
+    /// if there were interactions this frame.
+    /// When tapping a touch screen, this will be the location of the touch.
+    #[inline(always)]
+    pub fn pointer_interact_pos(&self) -> Option<Pos2> {
+        self.input().pointer.interact_pos()
+    }
+
+    /// Calls [`InputState::multi_touch`].
+    pub fn multi_touch(&self) -> Option<MultiTouchInfo> {
+        self.input().multi_touch()
+    }
+}
+
+impl Context {
     /// Move all the graphics at the given layer.
     /// Can be used to implement drag-and-drop (see relevant demo).
     pub fn translate_layer(&self, layer_id: LayerId, delta: Vec2) {
         if delta != Vec2::ZERO {
-            self.graphics().list(layer_id).lock().translate(delta);
+            self.graphics().list(layer_id).translate(delta);
         }
     }
 
@@ -777,7 +890,8 @@ impl Context {
     }
 
     pub(crate) fn rect_contains_pointer(&self, layer_id: LayerId, rect: Rect) -> bool {
-        if let Some(pointer_pos) = self.input.pointer.interact_pos() {
+        let pointer_pos = self.input().pointer.interact_pos();
+        if let Some(pointer_pos) = pointer_pos {
             rect.contains(pointer_pos) && self.layer_id_at(pointer_pos) == Some(layer_id)
         } else {
             false
@@ -786,14 +900,14 @@ impl Context {
 
     // ---------------------------------------------------------------------
 
-    /// Wether or not to debug widget layout on hover.
+    /// Whether or not to debug widget layout on hover.
     pub fn debug_on_hover(&self) -> bool {
-        self.memory().options.style.debug.debug_on_hover
+        self.options().style.debug.debug_on_hover
     }
 
-    /// Turn on/off wether or not to debug widget layout on hover.
+    /// Turn on/off whether or not to debug widget layout on hover.
     pub fn set_debug_on_hover(&self, debug_on_hover: bool) {
-        let mut style = (*self.memory().options.style).clone();
+        let mut style = (*self.options().style).clone();
         style.debug.debug_on_hover = debug_on_hover;
         self.set_style(style);
     }
@@ -817,10 +931,12 @@ impl Context {
 
     /// Like [`Self::animate_bool`] but allows you to control the animation time.
     pub fn animate_bool_with_time(&self, id: Id, value: bool, animation_time: f32) -> f32 {
-        let animated_value =
-            self.animation_manager
-                .lock()
-                .animate_bool(&self.input, animation_time, id, value);
+        let animated_value = {
+            let ctx_impl = &mut *self.write();
+            ctx_impl
+                .animation_manager
+                .animate_bool(&ctx_impl.input, animation_time, id, value)
+        };
         let animation_in_progress = 0.0 < animated_value && animated_value < 1.0;
         if animation_in_progress {
             self.request_repaint();
@@ -828,9 +944,27 @@ impl Context {
         animated_value
     }
 
+    /// Allows you to smoothly change the f32 value.
+    /// At the first call the value is written to memory.
+    /// When it is called with a new value, it linearly interpolates to it in the given time.
+    pub fn animate_value_with_time(&self, id: Id, value: f32, animation_time: f32) -> f32 {
+        let animated_value = {
+            let ctx_impl = &mut *self.write();
+            ctx_impl
+                .animation_manager
+                .animate_value(&ctx_impl.input, animation_time, id, value)
+        };
+        let animation_in_progress = animated_value != value;
+        if animation_in_progress {
+            self.request_repaint();
+        }
+
+        animated_value
+    }
+
     /// Clear memory of any animations.
     pub fn clear_animations(&self) {
-        *self.animation_manager.lock() = Default::default();
+        self.write().animation_manager = Default::default();
     }
 }
 
@@ -844,22 +978,13 @@ impl Context {
                 self.style_ui(ui);
             });
 
-        CollapsingHeader::new("🔠 Fonts")
-            .default_open(false)
-            .show(ui, |ui| {
-                let mut font_definitions = self.fonts().definitions().clone();
-                font_definitions.ui(ui);
-                self.fonts().font_image().ui(ui);
-                self.set_fonts(font_definitions);
-            });
-
         CollapsingHeader::new("✒ Painting")
             .default_open(true)
             .show(ui, |ui| {
-                let mut tessellation_options = self.memory().options.tessellation_options;
+                let mut tessellation_options = self.options().tessellation_options;
                 tessellation_options.ui(ui);
                 ui.vertical_centered(|ui| reset_button(ui, &mut tessellation_options));
-                self.memory().options.tessellation_options = tessellation_options;
+                *self.tessellation_options() = tessellation_options;
             });
     }
 
@@ -891,16 +1016,12 @@ impl Context {
         .on_hover_text("Is egui currently listening for text input?");
 
         let pointer_pos = self
-            .input()
-            .pointer
-            .hover_pos()
+            .pointer_hover_pos()
             .map_or_else(String::new, |pos| format!("{:?}", pos));
         ui.label(format!("Pointer pos: {}", pointer_pos));
 
         let top_layer = self
-            .input()
-            .pointer
-            .hover_pos()
+            .pointer_hover_pos()
             .and_then(|pos| self.layer_id_at(pos))
             .map_or_else(String::new, |layer| layer.short_debug_format());
         ui.label(format!("Top layer under mouse: {}", top_layer));
@@ -916,13 +1037,87 @@ impl Context {
 
         CollapsingHeader::new("📥 Input")
             .default_open(false)
-            .show(ui, |ui| ui.input().clone().ui(ui));
+            .show(ui, |ui| {
+                let input = ui.input().clone();
+                input.ui(ui);
+            });
 
         CollapsingHeader::new("📊 Paint stats")
-            .default_open(true)
+            .default_open(false)
             .show(ui, |ui| {
-                self.paint_stats.lock().ui(ui);
+                let paint_stats = self.write().paint_stats;
+                paint_stats.ui(ui);
             });
+
+        CollapsingHeader::new("🖼 Textures")
+            .default_open(false)
+            .show(ui, |ui| {
+                self.texture_ui(ui);
+            });
+
+        CollapsingHeader::new("🔠 Font texture")
+            .default_open(false)
+            .show(ui, |ui| {
+                let font_image_size = self.fonts().font_image_size();
+                crate::introspection::font_texture_ui(ui, font_image_size);
+            });
+    }
+
+    /// Show stats about the allocated textures.
+    pub fn texture_ui(&self, ui: &mut crate::Ui) {
+        let tex_mngr = self.tex_manager();
+        let tex_mngr = tex_mngr.read();
+
+        let mut textures: Vec<_> = tex_mngr.allocated().collect();
+        textures.sort_by_key(|(id, _)| *id);
+
+        let mut bytes = 0;
+        for (_, tex) in &textures {
+            bytes += tex.bytes_used();
+        }
+
+        ui.label(format!(
+            "{} allocated texture(s), using {:.1} MB",
+            textures.len(),
+            bytes as f64 * 1e-6
+        ));
+        let max_preview_size = Vec2::new(48.0, 32.0);
+
+        ui.group(|ui| {
+            ScrollArea::vertical()
+                .max_height(300.0)
+                .auto_shrink([false, true])
+                .show(ui, |ui| {
+                    ui.style_mut().override_text_style = Some(TextStyle::Monospace);
+                    Grid::new("textures")
+                        .striped(true)
+                        .num_columns(4)
+                        .spacing(Vec2::new(16.0, 2.0))
+                        .min_row_height(max_preview_size.y)
+                        .show(ui, |ui| {
+                            for (&texture_id, meta) in textures {
+                                let [w, h] = meta.size;
+
+                                let mut size = Vec2::new(w as f32, h as f32);
+                                size *= (max_preview_size.x / size.x).min(1.0);
+                                size *= (max_preview_size.y / size.y).min(1.0);
+                                ui.image(texture_id, size).on_hover_ui(|ui| {
+                                    // show larger on hover
+                                    let max_size = 0.5 * ui.ctx().input().screen_rect().size();
+                                    let mut size = Vec2::new(w as f32, h as f32);
+                                    size *= max_size.x / size.x.max(max_size.x);
+                                    size *= max_size.y / size.y.max(max_size.y);
+                                    ui.image(texture_id, size);
+                                });
+
+                                ui.label(format!("{} x {}", w, h));
+                                ui.label(format!("{:.3} MB", meta.bytes_used() as f64 * 1e-6));
+                                ui.label(format!("{:?}", meta.name));
+                                ui.end_row();
+                            }
+                        });
+                });
+        });
     }
 
     pub fn memory_ui(&self, ui: &mut crate::Ui) {
@@ -934,8 +1129,8 @@ impl Context {
             *self.memory() = Default::default();
         }
 
-        let num_state = self.memory().data.len();
-        let num_serialized = self.memory().data.count_serialized();
+        let num_state = self.data().len();
+        let num_serialized = self.data().count_serialized();
         ui.label(format!(
             "{} widget states stored (of which {} are serialized).",
             num_state, num_serialized
@@ -979,13 +1174,10 @@ impl Context {
         ui.horizontal(|ui| {
             ui.label(format!(
                 "{} collapsing headers",
-                self.memory()
-                    .data
-                    .count::<containers::collapsing_header::State>()
+                self.data().count::<containers::collapsing_header::State>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory()
-                    .data
+                self.data()
                     .remove_by_type::<containers::collapsing_header::State>();
             }
         });
@@ -993,30 +1185,30 @@ impl Context {
         ui.horizontal(|ui| {
             ui.label(format!(
                 "{} menu bars",
-                self.memory().data.count::<menu::BarState>()
+                self.data().count::<menu::BarState>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory().data.remove_by_type::<menu::BarState>();
+                self.data().remove_by_type::<menu::BarState>();
             }
         });
 
         ui.horizontal(|ui| {
             ui.label(format!(
                 "{} scroll areas",
-                self.memory().data.count::<scroll_area::State>()
+                self.data().count::<scroll_area::State>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory().data.remove_by_type::<scroll_area::State>();
+                self.data().remove_by_type::<scroll_area::State>();
             }
         });
 
         ui.horizontal(|ui| {
             ui.label(format!(
                 "{} resize areas",
-                self.memory().data.count::<resize::State>()
+                self.data().count::<resize::State>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory().data.remove_by_type::<resize::State>();
+                self.data().remove_by_type::<resize::State>();
             }
         });
 
diff --git a/egui/src/data/input.rs b/egui/src/data/input.rs
index 27a07a0c..21234b65 100644
--- a/egui/src/data/input.rs
+++ b/egui/src/data/input.rs
@@ -28,6 +28,13 @@ pub struct RawInput {
     /// Set this the first frame, whenever it changes, or just on every frame.
     pub pixels_per_point: Option<f32>,
 
+    /// Maximum size of one side of the font texture.
+    ///
+    /// Ask your graphics drivers about this. This corresponds to `GL_MAX_TEXTURE_SIZE`.
+    ///
+    /// The default is a very small (but very portable) 2048.
+    pub max_texture_side: usize,
+
     /// Monotonically increasing time, in seconds. Relative to whatever. Used for animations.
     /// If `None` is provided, egui will assume a time delta of `predicted_dt` (default 1/60 seconds).
     pub time: Option<f64>,
@@ -62,6 +69,7 @@ impl Default for RawInput {
         Self {
             screen_rect: None,
             pixels_per_point: None,
+            max_texture_side: 2048,
             time: None,
             predicted_dt: 1.0 / 60.0,
             modifiers: Modifiers::default(),
@@ -81,6 +89,7 @@ impl RawInput {
         RawInput {
             screen_rect: self.screen_rect.take(),
             pixels_per_point: self.pixels_per_point.take(),
+            max_texture_side: self.max_texture_side,
             time: self.time.take(),
             predicted_dt: self.predicted_dt,
             modifiers: self.modifiers,
@@ -95,6 +104,7 @@ impl RawInput {
         let Self {
             screen_rect,
             pixels_per_point,
+            max_texture_side,
             time,
             predicted_dt,
             modifiers,
@@ -105,6 +115,7 @@ impl RawInput {
 
         self.screen_rect = screen_rect.or(self.screen_rect);
         self.pixels_per_point = pixels_per_point.or(self.pixels_per_point);
+        self.max_texture_side = max_texture_side; // use latest
         self.time = time; // use latest time
         self.predicted_dt = predicted_dt; // use latest dt
         self.modifiers = modifiers; // use latest
@@ -135,7 +146,7 @@ pub struct DroppedFile {
     /// Set by the `egui_web` backend.
     pub last_modified: Option<std::time::SystemTime>,
     /// Set by the `egui_web` backend.
-    pub bytes: Option<std::sync::Arc<[u8]>>,
+    pub bytes: Option<epaint::mutex::Arc<[u8]>>,
 }
 
 /// An input event generated by the integration.
@@ -148,7 +159,9 @@ pub enum Event {
     Copy,
     /// The integration detected a "cut" event (e.g. Cmd+X).
     Cut,
-    /// Text input, e.g. via keyboard or paste action.
+    /// The integration detected a "paste" event (e.g. Cmd+V).
+    Paste(String),
+    /// Text input, e.g. via keyboard.
     ///
     /// When the user presses enter/return, do not send a `Text` (just [`Key::Enter`]).
     Text(String),
@@ -178,6 +191,8 @@ pub enum Event {
     /// The direction of the vector indicates how to move the _content_ that is being viewed.
     /// So if you get positive values, the content being viewed should move to the right and down,
     /// revealing new things to the left and up.
+    ///
+    /// Shift-scroll should result in horizontal scrolling (it is up to the integrations to do this).
     Scroll(Vec2),
 
     /// Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).
@@ -353,6 +368,7 @@ impl RawInput {
         let Self {
             screen_rect,
             pixels_per_point,
+            max_texture_side,
             time,
             predicted_dt,
             modifiers,
@@ -366,6 +382,7 @@ impl RawInput {
             .on_hover_text(
                 "Also called HDPI factor.\nNumber of physical pixels per each logical pixel.",
             );
+        ui.label(format!("max_texture_side: {}", max_texture_side));
         if let Some(time) = time {
             ui.label(format!("time: {:.3} s", time));
         } else {
@@ -373,10 +390,13 @@ impl RawInput {
         }
         ui.label(format!("predicted_dt: {:.1} ms", 1e3 * predicted_dt));
         ui.label(format!("modifiers: {:#?}", modifiers));
-        ui.label(format!("events: {:?}", events))
-            .on_hover_text("key presses etc");
         ui.label(format!("hovered_files: {}", hovered_files.len()));
         ui.label(format!("dropped_files: {}", dropped_files.len()));
+        ui.scope(|ui| {
+            ui.set_min_height(150.0);
+            ui.label(format!("events: {:#?}", events))
+                .on_hover_text("key presses etc");
+        });
     }
 }
 
diff --git a/egui/src/data/output.rs b/egui/src/data/output.rs
index 9947df86..664808b5 100644
--- a/egui/src/data/output.rs
+++ b/egui/src/data/output.rs
@@ -35,6 +35,9 @@ pub struct Output {
 
     /// Screen-space position of text edit cursor (used for IME).
     pub text_cursor_pos: Option<crate::Pos2>,
+
+    /// Texture changes since last frame.
+    pub textures_delta: epaint::textures::TexturesDelta,
 }
 
 impl Output {
@@ -71,6 +74,7 @@ impl Output {
             mut events,
             mutable_text_under_cursor,
             text_cursor_pos,
+            textures_delta,
         } = newer;
 
         self.cursor_icon = cursor_icon;
@@ -84,6 +88,7 @@ impl Output {
         self.events.append(&mut events);
         self.mutable_text_under_cursor = mutable_text_under_cursor;
         self.text_cursor_pos = text_cursor_pos.or(self.text_cursor_pos);
+        self.textures_delta.append(textures_delta);
     }
 
     /// Take everything ephemeral (everything except `cursor_icon` currently)
diff --git a/egui/src/frame_state.rs b/egui/src/frame_state.rs
index c2f03aeb..848dc415 100644
--- a/egui/src/frame_state.rs
+++ b/egui/src/frame_state.rs
@@ -72,7 +72,7 @@ impl FrameState {
     pub(crate) fn available_rect(&self) -> Rect {
         crate::egui_assert!(
             self.available_rect.is_finite(),
-            "Called `available_rect()` before `CtxRef::run()`"
+            "Called `available_rect()` before `Context::run()`"
         );
         self.available_rect
     }
diff --git a/egui/src/grid.rs b/egui/src/grid.rs
index 2aba3ca6..fe37337f 100644
--- a/egui/src/grid.rs
+++ b/egui/src/grid.rs
@@ -9,11 +9,11 @@ pub(crate) struct State {
 
 impl State {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(id)
+        ctx.data().get_persisted(id)
     }
 
     pub fn store(self, ctx: &Context, id: Id) {
-        ctx.memory().data.insert_persisted(id, self);
+        ctx.data().insert_persisted(id, self);
     }
 
     fn set_min_col_width(&mut self, col: usize, width: f32) {
@@ -45,8 +45,8 @@ impl State {
 // ----------------------------------------------------------------------------
 
 pub(crate) struct GridLayout {
-    ctx: CtxRef,
-    style: std::sync::Arc<Style>,
+    ctx: Context,
+    style: epaint::mutex::Arc<Style>,
     id: Id,
 
     /// State previous frame (if any).
diff --git a/egui/src/id.rs b/egui/src/id.rs
index da79bb2a..1b4883ff 100644
--- a/egui/src/id.rs
+++ b/egui/src/id.rs
@@ -8,7 +8,7 @@
 /// moved outside the slider.
 ///
 /// For some widgets `Id`s are also used to persist some state about the
-/// widgets, such as Window position or wether not a collapsing header region is open.
+/// widgets, such as Window position or whether not a collapsing header region is open.
 ///
 /// This implies that the `Id`s must be unique.
 ///
@@ -19,7 +19,7 @@
 ///
 /// For things that need to persist state even after moving (windows, collapsing headers)
 /// the location of the widgets is obviously not good enough. For instance,
-/// a collapsing region needs to remember wether or not it is open even
+/// a collapsing region needs to remember whether or not it is open even
 /// if the layout next frame is different and the collapsing is not lower down
 /// on the screen.
 ///
diff --git a/egui/src/input_state.rs b/egui/src/input_state.rs
index f2cbddf7..6395b54f 100644
--- a/egui/src/input_state.rs
+++ b/egui/src/input_state.rs
@@ -261,7 +261,8 @@ impl InputState {
     /// # egui::__run_test_ui(|ui| {
     /// let mut zoom = 1.0; // no zoom
     /// let mut rotation = 0.0; // no rotation
-    /// if let Some(multi_touch) = ui.input().multi_touch() {
+    /// let multi_touch = ui.input().multi_touch();
+    /// if let Some(multi_touch) = multi_touch {
     ///     zoom *= multi_touch.zoom_delta;
     ///     rotation += multi_touch.rotation_delta;
     /// }
@@ -699,7 +700,12 @@ impl InputState {
             events,
         } = self;
 
-        ui.style_mut().body_text_style = epaint::TextStyle::Monospace;
+        ui.style_mut()
+            .text_styles
+            .get_mut(&crate::TextStyle::Body)
+            .unwrap()
+            .family = crate::FontFamily::Monospace;
+
         ui.collapsing("Raw Input", |ui| raw.ui(ui));
 
         crate::containers::CollapsingHeader::new("🖱 Pointer")
@@ -729,8 +735,11 @@ impl InputState {
         ui.label(format!("predicted_dt: {:.1} ms", 1e3 * predicted_dt));
         ui.label(format!("modifiers: {:#?}", modifiers));
         ui.label(format!("keys_down: {:?}", keys_down));
-        ui.label(format!("events: {:?}", events))
-            .on_hover_text("key presses etc");
+        ui.scope(|ui| {
+            ui.set_min_height(150.0);
+            ui.label(format!("events: {:#?}", events))
+                .on_hover_text("key presses etc");
+        });
     }
 }
 
diff --git a/egui/src/input_state/touch_state.rs b/egui/src/input_state/touch_state.rs
index e6437063..82df96b5 100644
--- a/egui/src/input_state/touch_state.rs
+++ b/egui/src/input_state/touch_state.rs
@@ -7,6 +7,7 @@ use crate::{
 };
 
 /// All you probably need to know about a multi-touch gesture.
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub struct MultiTouchInfo {
     /// Point in time when the gesture started.
     pub start_time: f64,
diff --git a/egui/src/introspection.rs b/egui/src/introspection.rs
index f6fe1273..d0b34638 100644
--- a/egui/src/introspection.rs
+++ b/egui/src/introspection.rs
@@ -1,75 +1,79 @@
-//! uis for egui types.
+//! Showing UI:s for egui/epaint types.
 use crate::*;
 
-impl Widget for &epaint::FontImage {
-    fn ui(self, ui: &mut Ui) -> Response {
-        use epaint::Mesh;
-
-        ui.vertical(|ui| {
-            // Show font texture in demo Ui
-            ui.label(format!(
-                "Texture size: {} x {} (hover to zoom)",
-                self.width, self.height
-            ));
-            if self.width <= 1 || self.height <= 1 {
-                return;
-            }
-            let mut size = vec2(self.width as f32, self.height as f32);
-            if size.x > ui.available_width() {
-                size *= ui.available_width() / size.x;
-            }
-            let (rect, response) = ui.allocate_at_least(size, Sense::hover());
-            let mut mesh = Mesh::default();
-            mesh.add_rect_with_uv(
-                rect,
-                [pos2(0.0, 0.0), pos2(1.0, 1.0)].into(),
-                Color32::WHITE,
-            );
-            ui.painter().add(Shape::mesh(mesh));
-
-            let (tex_w, tex_h) = (self.width as f32, self.height as f32);
-
-            response
-                .on_hover_cursor(CursorIcon::ZoomIn)
-                .on_hover_ui_at_pointer(|ui| {
-                    if let Some(pos) = ui.input().pointer.latest_pos() {
-                        let (_id, zoom_rect) = ui.allocate_space(vec2(128.0, 128.0));
-                        let u = remap_clamp(pos.x, rect.x_range(), 0.0..=tex_w);
-                        let v = remap_clamp(pos.y, rect.y_range(), 0.0..=tex_h);
-
-                        let texel_radius = 32.0;
-                        let u = u.at_least(texel_radius).at_most(tex_w - texel_radius);
-                        let v = v.at_least(texel_radius).at_most(tex_h - texel_radius);
-
-                        let uv_rect = Rect::from_min_max(
-                            pos2((u - texel_radius) / tex_w, (v - texel_radius) / tex_h),
-                            pos2((u + texel_radius) / tex_w, (v + texel_radius) / tex_h),
-                        );
-                        let mut mesh = Mesh::default();
-                        mesh.add_rect_with_uv(zoom_rect, uv_rect, Color32::WHITE);
-                        ui.painter().add(Shape::mesh(mesh));
-                    }
-                });
-        })
-        .response
-    }
+pub fn font_family_ui(ui: &mut Ui, font_family: &mut FontFamily) {
+    let families = ui.fonts().families();
+    ui.horizontal(|ui| {
+        for alternative in families {
+            let text = alternative.to_string();
+            ui.radio_value(font_family, alternative, text);
+        }
+    });
 }
 
-impl Widget for &mut epaint::text::FontDefinitions {
-    fn ui(self, ui: &mut Ui) -> Response {
-        ui.vertical(|ui| {
-            for (text_style, (_family, size)) in self.family_and_size.iter_mut() {
-                // TODO: radio button for family
-                ui.add(
-                    Slider::new(size, 4.0..=40.0)
-                        .max_decimals(0)
-                        .text(format!("{:?}", text_style)),
-                );
-            }
-            crate::reset_button(ui, self);
-        })
-        .response
-    }
+pub fn font_id_ui(ui: &mut Ui, font_id: &mut FontId) {
+    let families = ui.fonts().families();
+    ui.horizontal(|ui| {
+        ui.add(Slider::new(&mut font_id.size, 4.0..=40.0).max_decimals(0));
+        for alternative in families {
+            let text = alternative.to_string();
+            ui.radio_value(&mut font_id.family, alternative, text);
+        }
+    });
+}
+
+// Show font texture in demo Ui
+pub(crate) fn font_texture_ui(ui: &mut Ui, [width, height]: [usize; 2]) -> Response {
+    use epaint::Mesh;
+
+    ui.vertical(|ui| {
+        let color = if ui.visuals().dark_mode {
+            Color32::WHITE
+        } else {
+            Color32::BLACK
+        };
+
+        ui.label(format!(
+            "Texture size: {} x {} (hover to zoom)",
+            width, height
+        ));
+        if width <= 1 || height <= 1 {
+            return;
+        }
+        let mut size = vec2(width as f32, height as f32);
+        if size.x > ui.available_width() {
+            size *= ui.available_width() / size.x;
+        }
+        let (rect, response) = ui.allocate_at_least(size, Sense::hover());
+        let mut mesh = Mesh::default();
+        mesh.add_rect_with_uv(rect, [pos2(0.0, 0.0), pos2(1.0, 1.0)].into(), color);
+        ui.painter().add(Shape::mesh(mesh));
+
+        let (tex_w, tex_h) = (width as f32, height as f32);
+
+        response
+            .on_hover_cursor(CursorIcon::ZoomIn)
+            .on_hover_ui_at_pointer(|ui| {
+                if let Some(pos) = ui.ctx().latest_pointer_pos() {
+                    let (_id, zoom_rect) = ui.allocate_space(vec2(128.0, 128.0));
+                    let u = remap_clamp(pos.x, rect.x_range(), 0.0..=tex_w);
+                    let v = remap_clamp(pos.y, rect.y_range(), 0.0..=tex_h);
+
+                    let texel_radius = 32.0;
+                    let u = u.at_least(texel_radius).at_most(tex_w - texel_radius);
+                    let v = v.at_least(texel_radius).at_most(tex_h - texel_radius);
+
+                    let uv_rect = Rect::from_min_max(
+                        pos2((u - texel_radius) / tex_w, (v - texel_radius) / tex_h),
+                        pos2((u + texel_radius) / tex_w, (v + texel_radius) / tex_h),
+                    );
+                    let mut mesh = Mesh::default();
+                    mesh.add_rect_with_uv(zoom_rect, uv_rect, color);
+                    ui.painter().add(Shape::mesh(mesh));
+                }
+            });
+    })
+    .response
 }
 
 impl Widget for &epaint::stats::PaintStats {
@@ -77,11 +81,11 @@ impl Widget for &epaint::stats::PaintStats {
         ui.vertical(|ui| {
             ui.label(
                 "egui generates intermediate level shapes like circles and text. \
-            These are later tessellated into triangles.",
+                These are later tessellated into triangles.",
             );
             ui.add_space(10.0);
 
-            ui.style_mut().body_text_style = TextStyle::Monospace;
+            ui.style_mut().override_text_style = Some(TextStyle::Monospace);
 
             let epaint::stats::PaintStats {
                 shapes,
@@ -124,7 +128,7 @@ impl Widget for &epaint::stats::PaintStats {
     }
 }
 
-pub fn label(ui: &mut Ui, alloc_info: &epaint::stats::AllocInfo, what: &str) -> Response {
+fn label(ui: &mut Ui, alloc_info: &epaint::stats::AllocInfo, what: &str) -> Response {
     ui.add(Label::new(alloc_info.format(what)).wrap(false))
 }
 
@@ -140,9 +144,17 @@ impl Widget for &mut epaint::TessellationOptions {
                 debug_paint_clip_rects,
                 debug_paint_text_rects,
                 debug_ignore_clip_rects,
+                bezier_tolerance,
+                epsilon: _,
             } = self;
             ui.checkbox(anti_alias, "Antialias")
                 .on_hover_text("Turn off for small performance gain.");
+            ui.add(
+                crate::widgets::Slider::new(bezier_tolerance, 0.0001..=10.0)
+                    .logarithmic(true)
+                    .show_value(true)
+                    .text("Spline Tolerance"),
+            );
             ui.collapsing("debug", |ui| {
                 ui.checkbox(
                     coarse_tessellation_culling,
diff --git a/egui/src/layers.rs b/egui/src/layers.rs
index 69a13a37..578d505a 100644
--- a/egui/src/layers.rs
+++ b/egui/src/layers.rs
@@ -2,9 +2,7 @@
 //! are sometimes painted behind or in front of other things.
 
 use crate::{Id, *};
-use epaint::mutex::Mutex;
 use epaint::{ClippedShape, Shape};
-use std::sync::Arc;
 
 /// Different layer categories
 #[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
@@ -153,10 +151,10 @@ impl PaintList {
 }
 
 #[derive(Clone, Default)]
-pub(crate) struct GraphicLayers([IdMap<Arc<Mutex<PaintList>>>; Order::COUNT]);
+pub(crate) struct GraphicLayers([IdMap<PaintList>; Order::COUNT]);
 
 impl GraphicLayers {
-    pub fn list(&mut self, layer_id: LayerId) -> &Arc<Mutex<PaintList>> {
+    pub fn list(&mut self, layer_id: LayerId) -> &mut PaintList {
         self.0[layer_id.order as usize]
             .entry(layer_id.id)
             .or_default()
@@ -171,20 +169,20 @@ impl GraphicLayers {
             // If a layer is empty at the start of the frame
             // then nobody has added to it, and it is old and defunct.
             // Free it to save memory:
-            order_map.retain(|_, list| !list.lock().is_empty());
+            order_map.retain(|_, list| !list.is_empty());
 
             // First do the layers part of area_order:
             for layer_id in area_order {
                 if layer_id.order == order {
                     if let Some(list) = order_map.get_mut(&layer_id.id) {
-                        all_shapes.append(&mut list.lock().0);
+                        all_shapes.append(&mut list.0);
                     }
                 }
             }
 
             // Also draw areas that are missing in `area_order`:
             for shapes in order_map.values_mut() {
-                all_shapes.append(&mut shapes.lock().0);
+                all_shapes.append(&mut shapes.0);
             }
         }
 
diff --git a/egui/src/layout.rs b/egui/src/layout.rs
index 433242ca..a9642c86 100644
--- a/egui/src/layout.rs
+++ b/egui/src/layout.rs
@@ -77,7 +77,6 @@ impl Region {
 /// Layout direction, one of `LeftToRight`, `RightToLeft`, `TopDown`, `BottomUp`.
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub enum Direction {
     LeftToRight,
     RightToLeft,
diff --git a/egui/src/lib.rs b/egui/src/lib.rs
index eb4c8d70..646780f3 100644
--- a/egui/src/lib.rs
+++ b/egui/src/lib.rs
@@ -1,6 +1,6 @@
 //! `egui`:  an easy-to-use GUI in pure Rust!
 //!
-//! Try the live web demo: <https://emilk.github.io/egui/index.html>. Read more about egui at <https://github.com/emilk/egui>.
+//! Try the live web demo: <https://www.egui.rs/#demo>. Read more about egui at <https://github.com/emilk/egui>.
 //!
 //! `egui` is in heavy development, with each new version having breaking changes.
 //! You need to have rust 1.56.0 or later to use `egui`.
@@ -8,13 +8,13 @@
 //! To quickly get started with egui, you can take a look at [`eframe_template`](https://github.com/emilk/eframe_template)
 //! which uses [`eframe`](https://docs.rs/eframe).
 //!
-//! To create a GUI using egui you first need a [`CtxRef`] (by convention referred to by `ctx`).
+//! To create a GUI using egui you first need a [`Context`] (by convention referred to by `ctx`).
 //! Then you add a [`Window`] or a [`SidePanel`] to get a [`Ui`], which is what you'll be using to add all the buttons and labels that you need.
 //!
 //!
 //! # Using egui
 //!
-//! To see what is possible to build with egui you can check out the online demo at <https://emilk.github.io/egui/#demo>.
+//! To see what is possible to build with egui you can check out the online demo at <https://www.egui.rs/#demo>.
 //!
 //! If you like the "learning by doing" approach, clone <https://github.com/emilk/eframe_template> and get started using egui right away.
 //!
@@ -58,7 +58,7 @@
 //!
 //! ### Quick start
 //!
-//! ``` rust
+//! ```
 //! # egui::__run_test_ui(|ui| {
 //! # let mut my_string = String::new();
 //! # let mut my_boolean = true;
@@ -113,7 +113,7 @@
 //! # fn handle_output(_: egui::Output) {}
 //! # fn paint(_: Vec<egui::ClippedMesh>) {}
 //! # fn gather_input() -> egui::RawInput { egui::RawInput::default() }
-//! let mut ctx = egui::CtxRef::default();
+//! let mut ctx = egui::Context::default();
 //!
 //! // Game loop:
 //! loop {
@@ -218,7 +218,7 @@
 //! 2. Wrap your panel contents in a [`ScrollArea`], or use [`Window::vscroll`] and [`Window::hscroll`].
 //! 3. Use a justified layout:
 //!
-//! ``` rust
+//! ```
 //! # egui::__run_test_ui(|ui| {
 //! ui.with_layout(egui::Layout::top_down_justified(egui::Align::Center), |ui| {
 //!     ui.button("I am becoming wider as needed");
@@ -228,7 +228,7 @@
 //!
 //! 4. Fill in extra space with emptiness:
 //!
-//! ``` rust
+//! ```
 //! # egui::__run_test_ui(|ui| {
 //! ui.allocate_space(ui.available_size()); // put this LAST in your panel/window code
 //! # });
@@ -364,7 +364,7 @@ mod frame_state;
 pub(crate) mod grid;
 mod id;
 mod input_state;
-mod introspection;
+pub mod introspection;
 pub mod layers;
 mod layout;
 mod memory;
@@ -385,20 +385,22 @@ pub use epaint::emath;
 pub use emath::{lerp, pos2, remap, remap_clamp, vec2, Align, Align2, NumExt, Pos2, Rect, Vec2};
 pub use epaint::{
     color, mutex,
-    text::{FontData, FontDefinitions, FontFamily, TextStyle},
-    ClippedMesh, Color32, FontImage, Rgba, Shape, Stroke, TextureId,
+    text::{FontData, FontDefinitions, FontFamily, FontId},
+    textures::TexturesDelta,
+    AlphaImage, ClippedMesh, Color32, ColorImage, ImageData, Rgba, Rounding, Shape, Stroke,
+    TextureHandle, TextureId,
 };
 
 pub mod text {
     pub use epaint::text::{
         FontData, FontDefinitions, FontFamily, Fonts, Galley, LayoutJob, LayoutSection, TextFormat,
-        TextStyle, TAB_SIZE,
+        TAB_SIZE,
     };
 }
 
 pub use {
     containers::*,
-    context::{Context, CtxRef},
+    context::Context,
     data::{
         input::*,
         output::{self, CursorIcon, Output, WidgetInfo},
@@ -412,7 +414,7 @@ pub use {
     painter::Painter,
     response::{InnerResponse, Response},
     sense::Sense,
-    style::{Style, Visuals},
+    style::{FontSelection, Style, TextStyle, Visuals},
     text::{Galley, TextFormat},
     ui::Ui,
     widget_text::{RichText, WidgetText},
@@ -509,7 +511,7 @@ macro_rules! egui_assert {
 
 // ----------------------------------------------------------------------------
 
-/// egui supports around 1216 emojis in total.
+/// The default egui fonts supports around 1216 emojis in total.
 /// Here are some of the most useful:
 /// ∞⊗⎗⎘⎙⏏⏴⏵⏶⏷
 /// ⏩⏪⏭⏮⏸⏹⏺■▶📾🔀🔁🔃
@@ -524,7 +526,7 @@ macro_rules! egui_assert {
 ///
 /// NOTE: In egui all emojis are monochrome!
 ///
-/// You can explore them all in the Font Book in [the online demo](https://emilk.github.io/egui/).
+/// You can explore them all in the Font Book in [the online demo](https://www.egui.rs/#demo).
 ///
 /// In addition, egui supports a few special emojis that are not part of the unicode standard.
 /// This module contains some of them:
@@ -574,8 +576,8 @@ pub enum WidgetType {
 // ----------------------------------------------------------------------------
 
 /// For use in tests; especially doctests.
-pub fn __run_test_ctx(mut run_ui: impl FnMut(&CtxRef)) {
-    let mut ctx = CtxRef::default();
+pub fn __run_test_ctx(mut run_ui: impl FnMut(&Context)) {
+    let ctx = Context::default();
     let _ = ctx.run(Default::default(), |ctx| {
         run_ui(ctx);
     });
@@ -583,7 +585,7 @@ pub fn __run_test_ctx(mut run_ui: impl FnMut(&CtxRef)) {
 
 /// For use in tests; especially doctests.
 pub fn __run_test_ui(mut add_contents: impl FnMut(&mut Ui)) {
-    let mut ctx = CtxRef::default();
+    let ctx = Context::default();
     let _ = ctx.run(Default::default(), |ctx| {
         crate::CentralPanel::default().show(ctx, |ui| {
             add_contents(ui);
diff --git a/egui/src/memory.rs b/egui/src/memory.rs
index f8d615ed..4809f2de 100644
--- a/egui/src/memory.rs
+++ b/egui/src/memory.rs
@@ -19,7 +19,15 @@ use crate::{area, window, Id, IdMap, InputState, LayerId, Pos2, Rect, Style};
 pub struct Memory {
     pub options: Options,
 
-    /// This map stores current states for all widgets with custom `Id`s.
+    /// This map stores some superficial state for all widgets with custom `Id`s.
+    ///
+    /// This includes storing if a [`crate::CollapsingHeader`] is open, how far scrolled a
+    /// [`crate::ScrollArea`] is, where the cursor in a [`crate::TextEdit`] is, etc.
+    ///
+    /// This is NOT meant to store any important data. Store that in your own structures!
+    ///
+    /// Each read clones the data, so keep your values cheap to clone.
+    /// If you want to store a lot of data you should wrap it in `Arc<Mutex<…>>` so it is cheap to clone.
     ///
     /// This will be saved between different program runs if you use the `persistence` feature.
     ///
@@ -45,7 +53,7 @@ pub struct Memory {
     /// }
     /// type CharCountCache<'a> = FrameCache<usize, CharCounter>;
     ///
-    /// # let mut ctx = egui::CtxRef::default();
+    /// # let mut ctx = egui::Context::default();
     /// let mut memory = ctx.memory();
     /// let cache = memory.caches.cache::<CharCountCache<'_>>();
     /// assert_eq!(cache.get("hello"), 5);
@@ -85,13 +93,13 @@ pub struct Memory {
 // ----------------------------------------------------------------------------
 
 /// Some global options that you can read and write.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct Options {
     /// The default style for new `Ui`:s.
     #[cfg_attr(feature = "serde", serde(skip))]
-    pub(crate) style: std::sync::Arc<Style>,
+    pub(crate) style: epaint::mutex::Arc<Style>,
 
     /// Controls the tessellator.
     pub tessellation_options: epaint::TessellationOptions,
@@ -100,6 +108,25 @@ pub struct Options {
     /// but is a signal to any backend that we want the [`crate::Output::events`] read out loud.
     /// Screen readers is an experimental feature of egui, and not supported on all platforms.
     pub screen_reader: bool,
+
+    /// If true, the most common glyphs (ASCII) are pre-rendered to the texture atlas.
+    ///
+    /// Only the fonts in [`Style::text_styles`] will be pre-cached.
+    ///
+    /// This can lead to fewer texture operations, but may use up the texture atlas quicker
+    /// if you are changing [`Style::text_styles`], of have a lot of text styles.
+    pub preload_font_glyphs: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            style: Default::default(),
+            tessellation_options: Default::default(),
+            screen_reader: false,
+            preload_font_glyphs: true,
+        }
+    }
 }
 
 // ----------------------------------------------------------------------------
@@ -396,7 +423,7 @@ impl Memory {
 /// Popups are things like combo-boxes, color pickers, menus etc.
 /// Only one can be be open at a time.
 impl Memory {
-    pub fn is_popup_open(&mut self, popup_id: Id) -> bool {
+    pub fn is_popup_open(&self, popup_id: Id) -> bool {
         self.popup == Some(popup_id) || self.everything_is_visible()
     }
 
@@ -541,7 +568,8 @@ impl Areas {
             ..
         } = self;
 
-        *visible_last_frame = std::mem::take(visible_current_frame);
+        std::mem::swap(visible_last_frame, visible_current_frame);
+        visible_current_frame.clear();
         order.sort_by_key(|layer| (layer.order, wants_to_be_on_top.contains(layer)));
         wants_to_be_on_top.clear();
     }
diff --git a/egui/src/menu.rs b/egui/src/menu.rs
index e8812d18..d2b87216 100644
--- a/egui/src/menu.rs
+++ b/egui/src/menu.rs
@@ -16,12 +16,11 @@
 //! ```
 
 use super::{
-    style::WidgetVisuals, Align, CtxRef, Id, InnerResponse, PointerState, Pos2, Rect, Response,
+    style::WidgetVisuals, Align, Context, Id, InnerResponse, PointerState, Pos2, Rect, Response,
     Sense, TextStyle, Ui, Vec2,
 };
 use crate::{widgets::*, *};
-use epaint::{mutex::RwLock, Stroke};
-use std::sync::Arc;
+use epaint::{mutex::Arc, mutex::RwLock, Stroke};
 
 /// What is saved between frames.
 #[derive(Clone, Default)]
@@ -31,14 +30,11 @@ pub(crate) struct BarState {
 
 impl BarState {
     fn load(ctx: &Context, bar_id: Id) -> Self {
-        ctx.memory()
-            .data
-            .get_temp::<Self>(bar_id)
-            .unwrap_or_default()
+        ctx.data().get_temp::<Self>(bar_id).unwrap_or_default()
     }
 
     fn store(self, ctx: &Context, bar_id: Id) {
-        ctx.memory().data.insert_temp(bar_id, self);
+        ctx.data().insert_temp(bar_id, self);
     }
 
     /// Show a menu at pointer if primary-clicked response.
@@ -116,7 +112,7 @@ pub(crate) fn submenu_button<R>(
 
 /// wrapper for the contents of every menu.
 pub(crate) fn menu_ui<'c, R>(
-    ctx: &CtxRef,
+    ctx: &Context,
     menu_id: impl std::hash::Hash,
     menu_state_arc: &Arc<RwLock<MenuState>>,
     add_contents: impl FnOnce(&mut Ui) -> R + 'c,
@@ -187,33 +183,19 @@ fn stationary_menu_impl<'c, R>(
     InnerResponse::new(inner.map(|r| r.inner), button_response)
 }
 
-/// Stores the state for the context menu.
-#[derive(Default)]
-pub(crate) struct ContextMenuSystem {
-    root: MenuRootManager,
-}
-impl ContextMenuSystem {
-    /// Show a menu at pointer if right-clicked response.
-    /// Should be called from [`Context`] on a [`Response`]
-    pub fn context_menu(
-        &mut self,
-        response: &Response,
-        add_contents: impl FnOnce(&mut Ui),
-    ) -> Option<InnerResponse<()>> {
-        MenuRoot::context_click_interaction(response, &mut self.root, response.id);
-        self.root.show(response, add_contents)
-    }
-}
-impl std::ops::Deref for ContextMenuSystem {
-    type Target = MenuRootManager;
-    fn deref(&self) -> &Self::Target {
-        &self.root
-    }
-}
-impl std::ops::DerefMut for ContextMenuSystem {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.root
-    }
+/// Response to secondary clicks (right-clicks) by showing the given menu.
+pub(crate) fn context_menu(
+    response: &Response,
+    add_contents: impl FnOnce(&mut Ui),
+) -> Option<InnerResponse<()>> {
+    let menu_id = Id::new("__egui::context_menu");
+    let mut bar_state = BarState::load(&response.ctx, menu_id);
+
+    MenuRoot::context_click_interaction(response, &mut bar_state, response.id);
+    let inner_response = bar_state.show(response, add_contents);
+
+    bar_state.store(&response.ctx, menu_id);
+    inner_response
 }
 
 /// Stores the state for the context menu.
@@ -429,7 +411,8 @@ impl SubMenuButton {
         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);
+        let text_galley =
+            text.into_galley(ui, Some(true), text_available_width, text_style.clone());
 
         let icon_available_width = text_available_width - text_galley.size().x;
         let icon_galley = icon.into_galley(ui, Some(true), icon_available_width, text_style);
@@ -455,7 +438,7 @@ impl SubMenuButton {
 
             ui.painter().rect_filled(
                 rect.expand(visuals.expansion),
-                visuals.corner_radius,
+                visuals.rounding,
                 visuals.bg_fill,
             );
 
@@ -520,7 +503,7 @@ impl MenuState {
         self.response = MenuResponse::Close;
     }
     pub fn show<R>(
-        ctx: &CtxRef,
+        ctx: &Context,
         menu_state: &Arc<RwLock<Self>>,
         id: Id,
         add_contents: impl FnOnce(&mut Ui) -> R,
@@ -529,7 +512,7 @@ impl MenuState {
     }
     fn show_submenu<R>(
         &mut self,
-        ctx: &CtxRef,
+        ctx: &Context,
         id: Id,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> Option<R> {
diff --git a/egui/src/painter.rs b/egui/src/painter.rs
index d7717dcc..e2adf8da 100644
--- a/egui/src/painter.rs
+++ b/egui/src/painter.rs
@@ -1,12 +1,12 @@
 use crate::{
     emath::{Align2, Pos2, Rect, Vec2},
     layers::{LayerId, PaintList, ShapeIdx},
-    Color32, CtxRef,
+    Color32, Context, FontId,
 };
 use epaint::{
-    mutex::Mutex,
-    text::{Fonts, Galley, TextStyle},
-    CircleShape, RectShape, Shape, Stroke, TextShape,
+    mutex::{Arc, RwLockReadGuard, RwLockWriteGuard},
+    text::{Fonts, Galley},
+    CircleShape, RectShape, Rounding, Shape, Stroke, TextShape,
 };
 
 /// Helper to paint shapes and text to a specific region on a specific layer.
@@ -15,13 +15,11 @@ use epaint::{
 #[derive(Clone)]
 pub struct Painter {
     /// Source of fonts and destination of shapes
-    ctx: CtxRef,
+    ctx: Context,
 
     /// Where we paint
     layer_id: LayerId,
 
-    paint_list: std::sync::Arc<Mutex<PaintList>>,
-
     /// Everything painted in this `Painter` will be clipped against this.
     /// This means nothing outside of this rectangle will be visible on screen.
     clip_rect: Rect,
@@ -32,33 +30,30 @@ pub struct Painter {
 }
 
 impl Painter {
-    pub fn new(ctx: CtxRef, layer_id: LayerId, clip_rect: Rect) -> Self {
-        let paint_list = ctx.graphics().list(layer_id).clone();
+    /// Create a painter to a specific layer within a certain clip rectangle.
+    pub fn new(ctx: Context, layer_id: LayerId, clip_rect: Rect) -> Self {
         Self {
             ctx,
             layer_id,
-            paint_list,
             clip_rect,
             fade_to_color: None,
         }
     }
 
+    /// Redirect where you are painting.
     #[must_use]
     pub fn with_layer_id(self, layer_id: LayerId) -> Self {
-        let paint_list = self.ctx.graphics().list(layer_id).clone();
         Self {
             ctx: self.ctx,
-            paint_list,
             layer_id,
             clip_rect: self.clip_rect,
             fade_to_color: None,
         }
     }
 
-    /// redirect
+    /// Redirect where you are painting.
     pub fn set_layer_id(&mut self, layer_id: LayerId) {
         self.layer_id = layer_id;
-        self.paint_list = self.ctx.graphics().list(self.layer_id).clone();
     }
 
     /// If set, colors will be modified to look like this
@@ -83,7 +78,6 @@ impl Painter {
         Self {
             ctx: self.ctx.clone(),
             layer_id: self.layer_id,
-            paint_list: self.paint_list.clone(),
             clip_rect: rect.intersect(self.clip_rect),
             fade_to_color: self.fade_to_color,
         }
@@ -92,15 +86,15 @@ impl Painter {
 
 /// ## Accessors etc
 impl Painter {
-    /// Get a reference to the parent [`CtxRef`].
+    /// Get a reference to the parent [`Context`].
     #[inline(always)]
-    pub fn ctx(&self) -> &CtxRef {
+    pub fn ctx(&self) -> &Context {
         &self.ctx
     }
 
     /// Available fonts.
     #[inline(always)]
-    pub fn fonts(&self) -> &Fonts {
+    pub fn fonts(&self) -> RwLockReadGuard<'_, Fonts> {
         self.ctx.fonts()
     }
 
@@ -145,6 +139,10 @@ impl Painter {
 
 /// ## Low level
 impl Painter {
+    fn paint_list(&self) -> RwLockWriteGuard<'_, PaintList> {
+        RwLockWriteGuard::map(self.ctx.graphics(), |g| g.list(self.layer_id))
+    }
+
     fn transform_shape(&self, shape: &mut Shape) {
         if let Some(fade_to_color) = self.fade_to_color {
             tint_shape_towards(shape, fade_to_color);
@@ -156,11 +154,11 @@ impl Painter {
     /// NOTE: all coordinates are screen coordinates!
     pub fn add(&self, shape: impl Into<Shape>) -> ShapeIdx {
         if self.fade_to_color == Some(Color32::TRANSPARENT) {
-            self.paint_list.lock().add(self.clip_rect, Shape::Noop)
+            self.paint_list().add(self.clip_rect, Shape::Noop)
         } else {
             let mut shape = shape.into();
             self.transform_shape(&mut shape);
-            self.paint_list.lock().add(self.clip_rect, shape)
+            self.paint_list().add(self.clip_rect, shape)
         }
     }
 
@@ -178,7 +176,7 @@ impl Painter {
                 }
             }
 
-            self.paint_list.lock().extend(self.clip_rect, shapes);
+            self.paint_list().extend(self.clip_rect, shapes);
         }
     }
 
@@ -189,7 +187,7 @@ impl Painter {
         }
         let mut shape = shape.into();
         self.transform_shape(&mut shape);
-        self.paint_list.lock().set(idx, self.clip_rect, shape);
+        self.paint_list().set(idx, self.clip_rect, shape);
     }
 }
 
@@ -198,12 +196,11 @@ impl Painter {
     #[allow(clippy::needless_pass_by_value)]
     pub fn debug_rect(&mut self, rect: Rect, color: Color32, text: impl ToString) {
         self.rect_stroke(rect, 0.0, (1.0, color));
-        let text_style = TextStyle::Monospace;
         self.text(
             rect.min,
             Align2::LEFT_TOP,
             text.to_string(),
-            text_style,
+            FontId::monospace(14.0),
             color,
         );
     }
@@ -221,7 +218,7 @@ impl Painter {
         color: Color32,
         text: impl ToString,
     ) -> Rect {
-        let galley = self.layout_no_wrap(text.to_string(), TextStyle::Monospace, color);
+        let galley = self.layout_no_wrap(text.to_string(), FontId::monospace(14.0), color);
         let rect = anchor.anchor_rect(Rect::from_min_size(pos, galley.size()));
         let frame_rect = rect.expand(2.0);
         self.add(Shape::rect_filled(
@@ -236,6 +233,8 @@ impl Painter {
 
 /// # Paint different primitives
 impl Painter {
+    /// Paints the line from the first point to the second using the `stroke`
+    /// for outlining shape.
     pub fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<Stroke>) {
         self.add(Shape::LineSegment {
             points,
@@ -279,31 +278,41 @@ impl Painter {
     pub fn rect(
         &self,
         rect: Rect,
-        corner_radius: f32,
+        rounding: impl Into<Rounding>,
         fill_color: impl Into<Color32>,
         stroke: impl Into<Stroke>,
     ) {
         self.add(RectShape {
             rect,
-            corner_radius,
+            rounding: rounding.into(),
             fill: fill_color.into(),
             stroke: stroke.into(),
         });
     }
 
-    pub fn rect_filled(&self, rect: Rect, corner_radius: f32, fill_color: impl Into<Color32>) {
+    pub fn rect_filled(
+        &self,
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+    ) {
         self.add(RectShape {
             rect,
-            corner_radius,
+            rounding: rounding.into(),
             fill: fill_color.into(),
             stroke: Default::default(),
         });
     }
 
-    pub fn rect_stroke(&self, rect: Rect, corner_radius: f32, stroke: impl Into<Stroke>) {
+    pub fn rect_stroke(
+        &self,
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        stroke: impl Into<Stroke>,
+    ) {
         self.add(RectShape {
             rect,
-            corner_radius,
+            rounding: rounding.into(),
             fill: Default::default(),
             stroke: stroke.into(),
         });
@@ -326,7 +335,7 @@ impl Painter {
 impl Painter {
     /// Lay out and paint some text.
     ///
-    /// To center the text at the given position, use `anchor: (Center, Center)`.
+    /// To center the text at the given position, use `Align2::CENTER_CENTER`.
     ///
     /// To find out the size of text before painting it, use
     /// [`Self::layout`] or [`Self::layout_no_wrap`].
@@ -338,10 +347,10 @@ impl Painter {
         pos: Pos2,
         anchor: Align2,
         text: impl ToString,
-        text_style: TextStyle,
+        font_id: FontId,
         text_color: Color32,
     ) -> Rect {
-        let galley = self.layout_no_wrap(text.to_string(), text_style, text_color);
+        let galley = self.layout_no_wrap(text.to_string(), font_id, text_color);
         let rect = anchor.anchor_rect(Rect::from_min_size(pos, galley.size()));
         self.galley(rect.min, galley);
         rect
@@ -354,11 +363,11 @@ impl Painter {
     pub fn layout(
         &self,
         text: String,
-        text_style: TextStyle,
+        font_id: FontId,
         color: crate::Color32,
         wrap_width: f32,
-    ) -> std::sync::Arc<Galley> {
-        self.fonts().layout(text, text_style, color, wrap_width)
+    ) -> Arc<Galley> {
+        self.fonts().layout(text, font_id, color, wrap_width)
     }
 
     /// Will line break at `\n`.
@@ -368,10 +377,10 @@ impl Painter {
     pub fn layout_no_wrap(
         &self,
         text: String,
-        text_style: TextStyle,
+        font_id: FontId,
         color: crate::Color32,
-    ) -> std::sync::Arc<Galley> {
-        self.fonts().layout(text, text_style, color, f32::INFINITY)
+    ) -> Arc<Galley> {
+        self.fonts().layout(text, font_id, color, f32::INFINITY)
     }
 
     /// Paint text that has already been layed out in a [`Galley`].
@@ -380,7 +389,7 @@ impl Painter {
     ///
     /// If you want to change the color of the text, use [`Self::galley_with_color`].
     #[inline(always)]
-    pub fn galley(&self, pos: Pos2, galley: std::sync::Arc<Galley>) {
+    pub fn galley(&self, pos: Pos2, galley: Arc<Galley>) {
         if !galley.is_empty() {
             self.add(Shape::galley(pos, galley));
         }
@@ -392,12 +401,7 @@ impl Painter {
     ///
     /// The text color in the [`Galley`] will be replaced with the given color.
     #[inline(always)]
-    pub fn galley_with_color(
-        &self,
-        pos: Pos2,
-        galley: std::sync::Arc<Galley>,
-        text_color: Color32,
-    ) {
+    pub fn galley_with_color(&self, pos: Pos2, galley: Arc<Galley>, text_color: Color32) {
         if !galley.is_empty() {
             self.add(TextShape {
                 override_text_color: Some(text_color),
diff --git a/egui/src/response.rs b/egui/src/response.rs
index 5c0c54a2..d685174f 100644
--- a/egui/src/response.rs
+++ b/egui/src/response.rs
@@ -1,6 +1,7 @@
 use crate::{
     emath::{lerp, Align, Pos2, Rect, Vec2},
-    CtxRef, CursorIcon, Id, LayerId, PointerButton, Sense, Ui, WidgetText, NUM_POINTER_BUTTONS,
+    menu, Context, CursorIcon, Id, LayerId, PointerButton, Sense, Ui, WidgetText,
+    NUM_POINTER_BUTTONS,
 };
 
 // ----------------------------------------------------------------------------
@@ -16,7 +17,7 @@ use crate::{
 pub struct Response {
     // CONTEXT:
     /// Used for optionally showing a tooltip and checking for more interactions.
-    pub ctx: CtxRef,
+    pub ctx: Context,
 
     // IN:
     /// Which layer the widget is part of.
@@ -382,6 +383,14 @@ impl Response {
         true
     }
 
+    /// Like `on_hover_text`, but show the text next to cursor.
+    #[doc(alias = "tooltip")]
+    pub fn on_hover_text_at_pointer(self, text: impl Into<WidgetText>) -> Self {
+        self.on_hover_ui_at_pointer(|ui| {
+            ui.add(crate::widgets::Label::new(text));
+        })
+    }
+
     /// Show this text if the widget was hovered (i.e. a tooltip).
     ///
     /// The text will not be visible if the widget is not enabled.
@@ -479,7 +488,7 @@ impl Response {
 
     /// Response to secondary clicks (right-clicks) by showing the given menu.
     ///
-    /// ``` rust
+    /// ```
     /// # egui::__run_test_ui(|ui| {
     /// let response = ui.label("Right-click me!");
     /// response.context_menu(|ui| {
@@ -492,9 +501,7 @@ impl Response {
     ///
     /// See also: [`Ui::menu_button`] and [`Ui::close_menu`].
     pub fn context_menu(self, add_contents: impl FnOnce(&mut Ui)) -> Self {
-        self.ctx
-            .context_menu_system()
-            .context_menu(&self, add_contents);
+        menu::context_menu(&self, add_contents);
         self
     }
 }
@@ -587,7 +594,9 @@ impl std::ops::BitOrAssign for Response {
 /// ```
 #[derive(Debug)]
 pub struct InnerResponse<R> {
+    /// What the user closure returned.
     pub inner: R,
+    /// The response of the area.
     pub response: Response,
 }
 
diff --git a/egui/src/style.rs b/egui/src/style.rs
index bb8159b4..a1430850 100644
--- a/egui/src/style.rs
+++ b/egui/src/style.rs
@@ -2,8 +2,123 @@
 
 #![allow(clippy::if_same_then_else)]
 
-use crate::{color::*, emath::*, Response, RichText, WidgetText};
-use epaint::{Shadow, Stroke, TextStyle};
+use crate::{color::*, emath::*, FontFamily, FontId, Response, RichText, WidgetText};
+use epaint::{mutex::Arc, Rounding, Shadow, Stroke};
+use std::collections::BTreeMap;
+
+// ----------------------------------------------------------------------------
+
+/// Alias for a [`FontId`] (font of a certain size).
+///
+/// The font is found via look-up in [`Style::text_styles`].
+/// You can use [`TextStyle::resolve`] to do this lookup.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum TextStyle {
+    /// Used when small text is needed.
+    Small,
+
+    /// Normal labels. Easily readable, doesn't take up too much space.
+    Body,
+
+    /// Same size as [`Self::Body]`, but used when monospace is important (for aligning number, code snippets, etc).
+    Monospace,
+
+    /// Buttons. Maybe slightly bigger than [`Self::Body]`.
+    /// Signifies that he item is interactive.
+    Button,
+
+    /// Heading. Probably larger than [`Self::Body]`.
+    Heading,
+
+    /// A user-chosen style, found in [`Style::text_styles`].
+    /// ```
+    /// egui::TextStyle::Name("footing".into());
+    /// ````
+    Name(Arc<str>),
+}
+
+impl std::fmt::Display for TextStyle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Small => "Small".fmt(f),
+            Self::Body => "Body".fmt(f),
+            Self::Monospace => "Monospace".fmt(f),
+            Self::Button => "Button".fmt(f),
+            Self::Heading => "Heading".fmt(f),
+            Self::Name(name) => (*name).fmt(f),
+        }
+    }
+}
+
+impl TextStyle {
+    /// Look up this [`TextStyle`] in [`Style::text_styles`].
+    pub fn resolve(&self, style: &Style) -> FontId {
+        style.text_styles.get(self).cloned().unwrap_or_else(|| {
+            panic!(
+                "Failed to find {:?} in Style::text_styles. Available styles:\n{:#?}",
+                self,
+                style.text_styles()
+            )
+        })
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A way to select [`FontId`], either by picking one directly or by using a [`TextStyle`].
+pub enum FontSelection {
+    /// Default text style - will use [`TextStyle::Body`], unless
+    /// [`Style::override_font_id`] or [`Style::override_text_style`] is set.
+    Default,
+
+    /// Directly select size and font family
+    FontId(FontId),
+
+    /// Use a [`TextStyle`] to look up the [`FontId`] in [`Style::text_styles`].
+    Style(TextStyle),
+}
+
+impl Default for FontSelection {
+    #[inline]
+    fn default() -> Self {
+        Self::Default
+    }
+}
+
+impl FontSelection {
+    pub fn resolve(self, style: &Style) -> FontId {
+        match self {
+            Self::Default => {
+                if let Some(override_font_id) = &style.override_font_id {
+                    override_font_id.clone()
+                } else if let Some(text_style) = &style.override_text_style {
+                    text_style.resolve(style)
+                } else {
+                    TextStyle::Body.resolve(style)
+                }
+            }
+            Self::FontId(font_id) => font_id,
+            Self::Style(text_style) => text_style.resolve(style),
+        }
+    }
+}
+
+impl From<FontId> for FontSelection {
+    #[inline(always)]
+    fn from(font_id: FontId) -> Self {
+        Self::FontId(font_id)
+    }
+}
+
+impl From<TextStyle> for FontSelection {
+    #[inline(always)]
+    fn from(text_style: TextStyle) -> Self {
+        Self::Style(text_style)
+    }
+}
+
+// ----------------------------------------------------------------------------
 
 /// Specifies the look and feel of egui.
 ///
@@ -15,15 +130,23 @@ use epaint::{Shadow, Stroke, TextStyle};
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct Style {
-    /// Default `TextStyle` for normal text (i.e. for `Label` and `TextEdit`).
-    pub body_text_style: TextStyle,
-
     /// If set this will change the default [`TextStyle`] for all widgets.
     ///
     /// On most widgets you can also set an explicit text style,
     /// which will take precedence over this.
     pub override_text_style: Option<TextStyle>,
 
+    /// If set this will change the font family and size for all widgets.
+    ///
+    /// On most widgets you can also set an explicit text style,
+    /// which will take precedence over this.
+    pub override_font_id: Option<FontId>,
+
+    /// The [`FontFamily`] and size you want to use for a specific [`TextStyle`].
+    ///
+    /// The most convenient way to look something up in this is to use [`TextStyle::resolve`].
+    pub text_styles: BTreeMap<TextStyle, FontId>,
+
     /// 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`.
@@ -77,6 +200,11 @@ impl Style {
     pub fn noninteractive(&self) -> &WidgetVisuals {
         &self.visuals.widgets.noninteractive
     }
+
+    /// All known text styles.
+    pub fn text_styles(&self) -> Vec<TextStyle> {
+        self.text_styles.keys().cloned().collect()
+    }
 }
 
 /// Controls the sizes and distances between widgets.
@@ -187,10 +315,10 @@ pub struct Visuals {
     ///
     /// If `text_color` is `None` (default), then the text color will be the same as the
     /// foreground stroke color (`WidgetVisuals::fg_stroke`)
-    /// and will depend on wether or not the widget is being interacted with.
+    /// and will depend on whether or not the widget is being interacted with.
     ///
     /// In the future we may instead modulate
-    /// the `text_color` based on wether or not it is interacted with
+    /// the `text_color` based on whether or not it is interacted with
     /// so that `visuals.text_color` is always used,
     /// but its alpha may be different based on whether or not
     /// it is disabled, non-interactive, hovered etc.
@@ -216,7 +344,7 @@ pub struct Visuals {
     /// Background color behind code-styled monospaced labels.
     pub code_bg_color: Color32,
 
-    pub window_corner_radius: f32,
+    pub window_rounding: Rounding,
     pub window_shadow: Shadow,
 
     pub popup_shadow: Shadow,
@@ -257,6 +385,7 @@ impl Visuals {
         self.widgets.active.text_color()
     }
 
+    /// Window background color.
     #[inline(always)]
     pub fn window_fill(&self) -> Color32 {
         self.widgets.noninteractive.bg_fill
@@ -324,7 +453,7 @@ pub struct WidgetVisuals {
     pub bg_stroke: Stroke,
 
     /// Button frames etc.
-    pub corner_radius: f32,
+    pub rounding: Rounding,
 
     /// Stroke and text color of the interactive part of a component (button text, slider grab, check-mark, …).
     pub fg_stroke: Stroke,
@@ -355,11 +484,35 @@ pub struct DebugOptions {
 
 // ----------------------------------------------------------------------------
 
+/// The default text styles of the default egui theme.
+pub fn default_text_styles() -> BTreeMap<TextStyle, FontId> {
+    let mut text_styles = BTreeMap::new();
+    text_styles.insert(
+        TextStyle::Small,
+        FontId::new(10.0, FontFamily::Proportional),
+    );
+    text_styles.insert(TextStyle::Body, FontId::new(14.0, FontFamily::Proportional));
+    text_styles.insert(
+        TextStyle::Button,
+        FontId::new(14.0, FontFamily::Proportional),
+    );
+    text_styles.insert(
+        TextStyle::Heading,
+        FontId::new(20.0, FontFamily::Proportional),
+    );
+    text_styles.insert(
+        TextStyle::Monospace,
+        FontId::new(14.0, FontFamily::Monospace),
+    );
+    text_styles
+}
+
 impl Default for Style {
     fn default() -> Self {
         Self {
-            body_text_style: TextStyle::Body,
+            override_font_id: None,
             override_text_style: None,
+            text_styles: default_text_styles(),
             wrap: None,
             spacing: Spacing::default(),
             interaction: Interaction::default(),
@@ -413,7 +566,7 @@ impl Visuals {
             faint_bg_color: Color32::from_gray(24),
             extreme_bg_color: Color32::from_gray(10),
             code_bg_color: Color32::from_gray(64),
-            window_corner_radius: 6.0,
+            window_rounding: Rounding::same(6.0),
             window_shadow: Shadow::big_dark(),
             popup_shadow: Shadow::small_dark(),
             resize_corner_size: 12.0,
@@ -476,35 +629,35 @@ impl Widgets {
                 bg_fill: Color32::from_gray(27), // window background
                 bg_stroke: Stroke::new(1.0, Color32::from_gray(60)), // separators, indentation lines, windows outlines
                 fg_stroke: Stroke::new(1.0, Color32::from_gray(140)), // normal text color
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 0.0,
             },
             inactive: WidgetVisuals {
                 bg_fill: Color32::from_gray(60), // button background
                 bg_stroke: Default::default(),
                 fg_stroke: Stroke::new(1.0, Color32::from_gray(180)), // button text
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 0.0,
             },
             hovered: WidgetVisuals {
                 bg_fill: Color32::from_gray(70),
                 bg_stroke: Stroke::new(1.0, Color32::from_gray(150)), // e.g. hover over window edge or button
                 fg_stroke: Stroke::new(1.5, Color32::from_gray(240)),
-                corner_radius: 3.0,
+                rounding: Rounding::same(3.0),
                 expansion: 1.0,
             },
             active: WidgetVisuals {
                 bg_fill: Color32::from_gray(55),
                 bg_stroke: Stroke::new(1.0, Color32::WHITE),
                 fg_stroke: Stroke::new(2.0, Color32::WHITE),
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 1.0,
             },
             open: WidgetVisuals {
                 bg_fill: Color32::from_gray(27),
                 bg_stroke: Stroke::new(1.0, Color32::from_gray(60)),
                 fg_stroke: Stroke::new(1.0, Color32::from_gray(210)),
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 0.0,
             },
         }
@@ -516,35 +669,35 @@ impl Widgets {
                 bg_fill: Color32::from_gray(235), // window background
                 bg_stroke: Stroke::new(1.0, Color32::from_gray(190)), // separators, indentation lines, windows outlines
                 fg_stroke: Stroke::new(1.0, Color32::from_gray(100)), // normal text color
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 0.0,
             },
             inactive: WidgetVisuals {
                 bg_fill: Color32::from_gray(215), // button background
                 bg_stroke: Default::default(),
                 fg_stroke: Stroke::new(1.0, Color32::from_gray(80)), // button text
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 0.0,
             },
             hovered: WidgetVisuals {
                 bg_fill: Color32::from_gray(210),
                 bg_stroke: Stroke::new(1.0, Color32::from_gray(105)), // e.g. hover over window edge or button
                 fg_stroke: Stroke::new(1.5, Color32::BLACK),
-                corner_radius: 3.0,
+                rounding: Rounding::same(3.0),
                 expansion: 1.0,
             },
             active: WidgetVisuals {
                 bg_fill: Color32::from_gray(165),
                 bg_stroke: Stroke::new(1.0, Color32::BLACK),
                 fg_stroke: Stroke::new(2.0, Color32::BLACK),
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 1.0,
             },
             open: WidgetVisuals {
                 bg_fill: Color32::from_gray(220),
                 bg_stroke: Stroke::new(1.0, Color32::from_gray(160)),
                 fg_stroke: Stroke::new(1.0, Color32::BLACK),
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 expansion: 0.0,
             },
         }
@@ -564,8 +717,9 @@ use crate::{widgets::*, Ui};
 impl Style {
     pub fn ui(&mut self, ui: &mut crate::Ui) {
         let Self {
-            body_text_style,
+            override_font_id,
             override_text_style,
+            text_styles,
             wrap: _,
             spacing,
             interaction,
@@ -578,11 +732,14 @@ impl Style {
         visuals.light_dark_radio_buttons(ui);
 
         crate::Grid::new("_options").show(ui, |ui| {
-            ui.label("Default body text style:");
+            ui.label("Override font id:");
             ui.horizontal(|ui| {
-                for &style in &[TextStyle::Body, TextStyle::Monospace] {
-                    let text = crate::RichText::new(format!("{:?}", style)).text_style(style);
-                    ui.radio_value(body_text_style, style, text);
+                ui.radio_value(override_font_id, None, "None");
+                if ui.radio(override_font_id.is_some(), "override").clicked() {
+                    *override_font_id = Some(FontId::default());
+                }
+                if let Some(override_font_id) = override_font_id {
+                    crate::introspection::font_id_ui(ui, override_font_id);
                 }
             });
             ui.end_row();
@@ -591,12 +748,14 @@ impl Style {
             crate::ComboBox::from_id_source("Override text style")
                 .selected_text(match override_text_style {
                     None => "None".to_owned(),
-                    Some(override_text_style) => format!("{:?}", override_text_style),
+                    Some(override_text_style) => override_text_style.to_string(),
                 })
                 .show_ui(ui, |ui| {
                     ui.selectable_value(override_text_style, None, "None");
-                    for style in TextStyle::all() {
-                        let text = crate::RichText::new(format!("{:?}", style)).text_style(style);
+                    let all_text_styles = ui.style().text_styles();
+                    for style in all_text_styles {
+                        let text =
+                            crate::RichText::new(style.to_string()).text_style(style.clone());
                         ui.selectable_value(override_text_style, Some(style), text);
                     }
                 });
@@ -611,6 +770,7 @@ impl Style {
             ui.end_row();
         });
 
+        ui.collapsing("🔠 Text Styles", |ui| text_styles_ui(ui, text_styles));
         ui.collapsing("📏 Spacing", |ui| spacing.ui(ui));
         ui.collapsing("☝ Interaction", |ui| interaction.ui(ui));
         ui.collapsing("🎨 Visuals", |ui| visuals.ui(ui));
@@ -625,6 +785,20 @@ impl Style {
     }
 }
 
+fn text_styles_ui(ui: &mut Ui, text_styles: &mut BTreeMap<TextStyle, FontId>) -> Response {
+    ui.vertical(|ui| {
+        crate::Grid::new("text_styles").show(ui, |ui| {
+            for (text_style, font_id) in text_styles.iter_mut() {
+                ui.label(RichText::new(text_style.to_string()).font(font_id.clone()));
+                crate::introspection::font_id_ui(ui, font_id);
+                ui.end_row();
+            }
+        });
+        crate::reset_button_with(ui, text_styles, default_text_styles());
+    })
+    .response
+}
+
 impl Spacing {
     pub fn ui(&mut self, ui: &mut crate::Ui) {
         let Self {
@@ -759,7 +933,7 @@ impl Selection {
     pub fn ui(&mut self, ui: &mut crate::Ui) {
         let Self { bg_fill, stroke } = self;
         ui.label("Selectable labels");
-        ui_color(ui, bg_fill, "bg_fill");
+        ui_color(ui, bg_fill, "background fill");
         stroke_ui(ui, stroke, "stroke");
     }
 }
@@ -769,14 +943,16 @@ impl WidgetVisuals {
         let Self {
             bg_fill,
             bg_stroke,
-            corner_radius,
+            rounding,
             fg_stroke,
             expansion,
         } = self;
-        ui_color(ui, bg_fill, "bg_fill");
-        stroke_ui(ui, bg_stroke, "bg_stroke");
-        ui.add(Slider::new(corner_radius, 0.0..=10.0).text("corner_radius"));
-        stroke_ui(ui, fg_stroke, "fg_stroke (text)");
+        ui_color(ui, bg_fill, "background fill");
+        stroke_ui(ui, bg_stroke, "background stroke");
+
+        rounding_ui(ui, rounding);
+
+        stroke_ui(ui, fg_stroke, "foreground stroke (text)");
         ui.add(Slider::new(expansion, -5.0..=5.0).text("expansion"))
             .on_hover_text("make shapes this much larger");
     }
@@ -825,7 +1001,7 @@ impl Visuals {
             faint_bg_color,
             extreme_bg_color,
             code_bg_color,
-            window_corner_radius,
+            window_rounding,
             window_shadow,
             popup_shadow,
             resize_corner_size,
@@ -850,7 +1026,9 @@ impl Visuals {
             // Common shortcuts
             ui_color(ui, &mut widgets.noninteractive.bg_fill, "Fill");
             stroke_ui(ui, &mut widgets.noninteractive.bg_stroke, "Outline");
-            ui.add(Slider::new(window_corner_radius, 0.0..=20.0).text("Rounding"));
+
+            rounding_ui(ui, window_rounding);
+
             shadow_ui(ui, window_shadow, "Shadow");
             shadow_ui(ui, popup_shadow, "Shadow (small menus and popups)");
         });
@@ -940,3 +1118,29 @@ fn ui_color(ui: &mut Ui, srgba: &mut Color32, label: impl Into<WidgetText>) -> R
     })
     .response
 }
+
+fn rounding_ui(ui: &mut Ui, rounding: &mut Rounding) {
+    const MAX: f32 = 20.0;
+    let mut same = rounding.is_same();
+    ui.group(|ui| {
+        ui.horizontal(|ui| {
+            ui.label("Rounding: ");
+            ui.radio_value(&mut same, true, "Same");
+            ui.radio_value(&mut same, false, "Separate");
+        });
+
+        if same {
+            let mut cr = rounding.nw;
+            ui.add(Slider::new(&mut cr, 0.0..=MAX));
+            *rounding = Rounding::same(cr);
+        } else {
+            ui.add(Slider::new(&mut rounding.nw, 0.0..=MAX).text("North-West"));
+            ui.add(Slider::new(&mut rounding.ne, 0.0..=MAX).text("North-East"));
+            ui.add(Slider::new(&mut rounding.sw, 0.0..=MAX).text("South-West"));
+            ui.add(Slider::new(&mut rounding.se, 0.0..=MAX).text("South-East"));
+            if rounding.is_same() {
+                rounding.se *= 1.00001;
+            }
+        }
+    });
+}
diff --git a/egui/src/ui.rs b/egui/src/ui.rs
index 956e12b8..b5a04c8f 100644
--- a/egui/src/ui.rs
+++ b/egui/src/ui.rs
@@ -1,12 +1,11 @@
 // #![warn(missing_docs)]
 
-use epaint::mutex::RwLock;
+use epaint::mutex::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard};
 use std::hash::Hash;
-use std::sync::Arc;
 
 use crate::{
-    color::*, containers::*, epaint::text::Fonts, layout::*, menu::MenuState, mutex::MutexGuard,
-    placer::Placer, widgets::*, *,
+    color::*, containers::*, epaint::text::Fonts, layout::*, menu::MenuState, placer::Placer,
+    widgets::*, *,
 };
 
 // ----------------------------------------------------------------------------
@@ -49,7 +48,7 @@ pub struct Ui {
     /// The `Style` (visuals, spacing, etc) of this ui.
     /// Commonly many `Ui`:s share the same `Style`.
     /// The `Ui` implements copy-on-write for this.
-    style: std::sync::Arc<Style>,
+    style: Arc<Style>,
 
     /// Handles the `Ui` size and the placement of new widgets.
     placer: Placer,
@@ -70,7 +69,7 @@ impl Ui {
     ///
     /// Normally you would not use this directly, but instead use
     /// [`SidePanel`], [`TopBottomPanel`], [`CentralPanel`], [`Window`] or [`Area`].
-    pub fn new(ctx: CtxRef, layer_id: LayerId, id: Id, max_rect: Rect, clip_rect: Rect) -> Self {
+    pub fn new(ctx: Context, layer_id: LayerId, id: Id, max_rect: Rect, clip_rect: Rect) -> Self {
         let style = ctx.style();
         Ui {
             id,
@@ -122,7 +121,7 @@ impl Ui {
     ///
     /// Note that this may be a different [`Style`] than that of [`Context::style`].
     #[inline]
-    pub fn style(&self) -> &std::sync::Arc<Style> {
+    pub fn style(&self) -> &Arc<Style> {
         &self.style
     }
 
@@ -134,17 +133,17 @@ impl Ui {
     /// Example:
     /// ```
     /// # egui::__run_test_ui(|ui| {
-    /// ui.style_mut().body_text_style = egui::TextStyle::Heading;
+    /// ui.style_mut().override_text_style = Some(egui::TextStyle::Heading);
     /// # });
     /// ```
     pub fn style_mut(&mut self) -> &mut Style {
-        std::sync::Arc::make_mut(&mut self.style) // clone-on-write
+        Arc::make_mut(&mut self.style) // clone-on-write
     }
 
     /// Changes apply to this `Ui` and its subsequent children.
     ///
     /// To set the visuals of all `Ui`:s, use [`Context::set_visuals`].
-    pub fn set_style(&mut self, style: impl Into<std::sync::Arc<Style>>) {
+    pub fn set_style(&mut self, style: impl Into<Arc<Style>>) {
         self.style = style.into();
     }
 
@@ -195,9 +194,9 @@ impl Ui {
         &mut self.style_mut().visuals
     }
 
-    /// Get a reference to the parent [`CtxRef`].
+    /// Get a reference to the parent [`Context`].
     #[inline]
-    pub fn ctx(&self) -> &CtxRef {
+    pub fn ctx(&self) -> &Context {
         self.painter.ctx()
     }
 
@@ -313,34 +312,64 @@ impl Ui {
         self.painter().layer_id()
     }
 
-    /// The `Input` of the `Context` associated with the `Ui`.
+    /// The [`InputState`] of the [`Context`] associated with this [`Ui`].
     /// Equivalent to `.ctx().input()`.
+    ///
+    /// Note that this locks the [`Context`], so be careful with if-let bindings:
+    ///
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// if let Some(pos) = { ui.input().pointer.hover_pos() } {
+    ///     // This is fine!
+    /// }
+    ///
+    /// let pos = ui.input().pointer.hover_pos();
+    /// if let Some(pos) = pos {
+    ///     // This is also fine!
+    /// }
+    ///
+    /// if let Some(pos) = ui.input().pointer.hover_pos() {
+    ///     // ⚠️ Using `ui` again here will lead to a dead-lock!
+    /// }
+    /// # });
+    /// ```
     #[inline]
-    pub fn input(&self) -> &InputState {
+    pub fn input(&self) -> RwLockReadGuard<'_, InputState> {
         self.ctx().input()
     }
 
-    /// The `Memory` of the `Context` associated with the `Ui`.
+    /// The [`Memory`] of the [`Context`] associated with this ui.
     /// Equivalent to `.ctx().memory()`.
     #[inline]
-    pub fn memory(&self) -> MutexGuard<'_, Memory> {
+    pub fn memory(&self) -> RwLockWriteGuard<'_, Memory> {
         self.ctx().memory()
     }
 
-    /// The `Output` of the `Context` associated with the `Ui`.
+    /// Stores superficial widget state.
+    #[inline]
+    pub fn data(&self) -> RwLockWriteGuard<'_, crate::util::IdTypeMap> {
+        self.ctx().data()
+    }
+
+    /// The [`Output`] of the [`Context`] associated with this ui.
     /// Equivalent to `.ctx().output()`.
     #[inline]
-    pub fn output(&self) -> MutexGuard<'_, Output> {
+    pub fn output(&self) -> RwLockWriteGuard<'_, Output> {
         self.ctx().output()
     }
 
-    /// The `Fonts` of the `Context` associated with the `Ui`.
+    /// The [`Fonts`] of the [`Context`] associated with this ui.
     /// Equivalent to `.ctx().fonts()`.
     #[inline]
-    pub fn fonts(&self) -> &Fonts {
+    pub fn fonts(&self) -> RwLockReadGuard<'_, Fonts> {
         self.ctx().fonts()
     }
 
+    /// The height of text of this text style
+    pub fn text_style_height(&self, style: &TextStyle) -> f32 {
+        self.fonts().row_height(&style.resolve(self.style()))
+    }
+
     /// Screen-space rectangle for clipping what we paint in this ui.
     /// This is used, for instance, to avoid painting outside a window that is smaller than its contents.
     #[inline]
@@ -1055,7 +1084,7 @@ impl Ui {
     /// Add extra space before the next widget.
     ///
     /// The direction is dependent on the layout.
-    /// This will be in addition to the [`Spacing::item_spacing`}.
+    /// This will be in addition to the [`crate::style::Spacing::item_spacing`].
     ///
     /// [`Self::min_rect`] will expand to contain the space.
     #[inline]
@@ -1068,6 +1097,16 @@ impl Ui {
     /// Shortcut for `add(Label::new(text))`
     ///
     /// See also [`Label`].
+    ///
+    /// ### Example
+    /// ```
+    /// # egui::__run_test_ui(|ui| {
+    /// use egui::{RichText, FontId, Color32};
+    /// ui.label("Normal text");
+    /// ui.label(RichText::new("Large text").font(FontId::proportional(40.0)));
+    /// ui.label(RichText::new("Red text").color(Color32::RED));
+    /// # });
+    /// ```
     #[inline]
     pub fn label(&mut self, text: impl Into<WidgetText>) -> Response {
         Label::new(text).ui(self)
@@ -1238,12 +1277,12 @@ impl Ui {
     pub fn radio_value<Value: PartialEq>(
         &mut self,
         current_value: &mut Value,
-        selected_value: Value,
+        alternative: Value,
         text: impl Into<WidgetText>,
     ) -> Response {
-        let mut response = self.radio(*current_value == selected_value, text);
+        let mut response = self.radio(*current_value == alternative, text);
         if response.clicked() {
-            *current_value = selected_value;
+            *current_value = alternative;
             response.mark_changed();
         }
         response
@@ -1323,9 +1362,30 @@ impl Ui {
 
     /// Show an image here with the given size.
     ///
-    /// See also [`Image`].
+    /// In order to display an image you must first acquire a [`TextureHandle`]
+    /// using [`Context::load_texture`].
+    ///
+    /// ```
+    /// struct MyImage {
+    ///     texture: Option<egui::TextureHandle>,
+    /// }
+    ///
+    /// impl MyImage {
+    ///     fn ui(&mut self, ui: &mut egui::Ui) {
+    ///         let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+    ///             // Load the texture only once.
+    ///             ui.ctx().load_texture("my-image", egui::ColorImage::example())
+    ///         });
+    ///
+    ///         // Show the image:
+    ///         ui.image(texture, texture.size_vec2());
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Se also [`crate::Image`] and [`crate::ImageButton`].
     #[inline]
-    pub fn image(&mut self, texture_id: TextureId, size: impl Into<Vec2>) -> Response {
+    pub fn image(&mut self, texture_id: impl Into<TextureId>, size: impl Into<Vec2>) -> Response {
         Image::new(texture_id, size).ui(self)
     }
 }
diff --git a/egui/src/util/history.rs b/egui/src/util/history.rs
index 7c02ed8c..bea3f97f 100644
--- a/egui/src/util/history.rs
+++ b/egui/src/util/history.rs
@@ -109,11 +109,11 @@ where
     /// `(time, value)` pairs
     /// Time difference between values can be zero, but never negative.
     // TODO: impl IntoIter
-    pub fn iter(&'_ self) -> impl Iterator<Item = (f64, T)> + '_ {
+    pub fn iter(&'_ self) -> impl ExactSizeIterator<Item = (f64, T)> + '_ {
         self.values.iter().map(|(time, value)| (*time, *value))
     }
 
-    pub fn values(&'_ self) -> impl Iterator<Item = T> + '_ {
+    pub fn values(&'_ self) -> impl ExactSizeIterator<Item = T> + '_ {
         self.values.iter().map(|(_time, value)| *value)
     }
 
diff --git a/egui/src/util/id_type_map.rs b/egui/src/util/id_type_map.rs
index 9363a39f..82ddf931 100644
--- a/egui/src/util/id_type_map.rs
+++ b/egui/src/util/id_type_map.rs
@@ -3,8 +3,8 @@
 // For non-serializable types, these simply return `None`.
 // This will also allow users to pick their own serialization format per type.
 
+use epaint::mutex::Arc;
 use std::any::Any;
-use std::sync::Arc;
 
 // -----------------------------------------------------------------------------------------------
 
@@ -275,11 +275,12 @@ impl Element {
 fn from_ron_str<T: serde::de::DeserializeOwned>(ron: &str) -> Option<T> {
     match ron::from_str::<T>(ron) {
         Ok(value) => Some(value),
-        Err(err) => {
-            eprintln!(
+        Err(_err) => {
+            #[cfg(feature = "tracing")]
+            tracing::warn!(
                 "egui: Failed to deserialize {} from memory: {}, ron error: {:?}",
                 std::any::type_name::<T>(),
-                err,
+                _err,
                 ron
             );
             None
@@ -294,7 +295,10 @@ use crate::Id;
 // TODO: make IdTypeMap generic over the key (`Id`), and make a library of IdTypeMap.
 /// Stores values identified by an [`Id`] AND a the [`std::any::TypeId`] of the value.
 ///
-/// so it maps `(Id, TypeId)` to any value you want.
+/// In other words, it maps `(Id, TypeId)` to any value you want.
+///
+/// Values are cloned when read, so keep them small and light.
+/// If you want to store something bigger, wrap them in `Arc<Mutex<…>>`.
 ///
 /// Values can either be "persisted" (serializable) or "temporary" (cleared when egui is shut down).
 ///
@@ -311,19 +315,19 @@ use crate::Id;
 /// map.insert_temp(a, 42);
 ///
 /// // `b` associated with an f64 and a `&'static str`
-/// map.insert_persisted(b, 6.28);
+/// map.insert_persisted(b, 13.37);
 /// map.insert_temp(b, "Hello World".to_string());
 ///
 /// // we can retrieve all four values:
 /// assert_eq!(map.get_temp::<f64>(a), Some(3.14));
 /// assert_eq!(map.get_temp::<i32>(a), Some(42));
-/// assert_eq!(map.get_temp::<f64>(b), Some(6.28));
+/// assert_eq!(map.get_temp::<f64>(b), Some(13.37));
 /// assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_string()));
 ///
 /// // we can retrieve them like so also:
 /// assert_eq!(map.get_persisted::<f64>(a), Some(3.14));
 /// assert_eq!(map.get_persisted::<i32>(a), Some(42));
-/// assert_eq!(map.get_persisted::<f64>(b), Some(6.28));
+/// assert_eq!(map.get_persisted::<f64>(b), Some(13.37));
 /// assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_string()));
 /// ```
 #[derive(Clone, Debug, Default)]
@@ -346,6 +350,8 @@ impl IdTypeMap {
     }
 
     /// Read a value without trying to deserialize a persisted value.
+    ///
+    /// The call clones the value (if found), so make sure it is cheap to clone!
     #[inline]
     pub fn get_temp<T: 'static + Clone>(&mut self, id: Id) -> Option<T> {
         let hash = hash(TypeId::of::<T>(), id);
@@ -356,6 +362,8 @@ impl IdTypeMap {
     }
 
     /// Read a value, optionally deserializing it if available.
+    ///
+    /// The call clones the value (if found), so make sure it is cheap to clone!
     #[inline]
     pub fn get_persisted<T: SerializableAny>(&mut self, id: Id) -> Option<T> {
         let hash = hash(TypeId::of::<T>(), id);
@@ -544,11 +552,11 @@ fn test_two_id_two_type() {
     let b = Id::new("b");
 
     let mut map: IdTypeMap = Default::default();
-    map.insert_persisted(a, 6.28);
+    map.insert_persisted(a, 13.37);
     map.insert_temp(b, 42);
-    assert_eq!(map.get_persisted::<f64>(a), Some(6.28));
+    assert_eq!(map.get_persisted::<f64>(a), Some(13.37));
     assert_eq!(map.get_persisted::<i32>(b), Some(42));
-    assert_eq!(map.get_temp::<f64>(a), Some(6.28));
+    assert_eq!(map.get_temp::<f64>(a), Some(13.37));
     assert_eq!(map.get_temp::<i32>(b), Some(42));
 }
 
@@ -565,19 +573,19 @@ fn test_two_id_x_two_types() {
     map.insert_temp(a, 42);
 
     // `b` associated with an f64 and a `&'static str`
-    map.insert_persisted(b, 6.28);
+    map.insert_persisted(b, 13.37);
     map.insert_temp(b, "Hello World".to_string());
 
     // we can retrieve all four values:
     assert_eq!(map.get_temp::<f64>(a), Some(3.14));
     assert_eq!(map.get_temp::<i32>(a), Some(42));
-    assert_eq!(map.get_temp::<f64>(b), Some(6.28));
+    assert_eq!(map.get_temp::<f64>(b), Some(13.37));
     assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_string()));
 
     // we can retrieve them like so also:
     assert_eq!(map.get_persisted::<f64>(a), Some(3.14));
     assert_eq!(map.get_persisted::<i32>(a), Some(42));
-    assert_eq!(map.get_persisted::<f64>(b), Some(6.28));
+    assert_eq!(map.get_persisted::<f64>(b), Some(13.37));
     assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_string()));
 }
 
@@ -586,11 +594,11 @@ fn test_one_id_two_types() {
     let id = Id::new("a");
 
     let mut map: IdTypeMap = Default::default();
-    map.insert_persisted(id, 6.28);
+    map.insert_persisted(id, 13.37);
     map.insert_temp(id, 42);
 
-    assert_eq!(map.get_temp::<f64>(id), Some(6.28));
-    assert_eq!(map.get_persisted::<f64>(id), Some(6.28));
+    assert_eq!(map.get_temp::<f64>(id), Some(13.37));
+    assert_eq!(map.get_persisted::<f64>(id), Some(13.37));
     assert_eq!(map.get_temp::<i32>(id), Some(42));
 
     // ------------
@@ -601,8 +609,8 @@ fn test_one_id_two_types() {
     assert_eq!(map.get_temp::<i32>(id), None);
 
     // Other type is still there, even though it is the same if:
-    assert_eq!(map.get_temp::<f64>(id), Some(6.28));
-    assert_eq!(map.get_persisted::<f64>(id), Some(6.28));
+    assert_eq!(map.get_temp::<f64>(id), Some(13.37));
+    assert_eq!(map.get_persisted::<f64>(id), Some(13.37));
 
     // But we can still remove the last:
     map.remove::<f64>(id);
diff --git a/egui/src/widget_text.rs b/egui/src/widget_text.rs
index acd77878..4e5659cd 100644
--- a/egui/src/widget_text.rs
+++ b/egui/src/widget_text.rs
@@ -1,17 +1,30 @@
-use std::sync::Arc;
+use epaint::mutex::Arc;
 
 use crate::{
-    style::WidgetVisuals, text::LayoutJob, Align, Color32, Galley, Pos2, Style, TextStyle, Ui,
-    Visuals,
+    style::WidgetVisuals, text::LayoutJob, Align, Color32, FontFamily, FontSelection, Galley, Pos2,
+    Style, TextStyle, Ui, Visuals,
 };
 
 /// Text and optional style choices for it.
 ///
 /// The style choices (font, color) are applied to the entire text.
 /// For more detailed control, use [`crate::text::LayoutJob`] instead.
+///
+/// A `RichText` can be used in most widgets and helper functions, e.g. [`Ui::label`] and [`Ui::button`].
+///
+/// ### Example
+/// ```
+/// use egui::{RichText, Color32};
+///
+/// RichText::new("Plain");
+/// RichText::new("colored").color(Color32::RED);
+/// RichText::new("Large and underlined").size(20.0).underline();
+/// ```
 #[derive(Clone, Default, PartialEq)]
 pub struct RichText {
     text: String,
+    size: Option<f32>,
+    family: Option<FontFamily>,
     text_style: Option<TextStyle>,
     background_color: Color32,
     text_color: Option<Color32>,
@@ -64,6 +77,35 @@ impl RichText {
         &self.text
     }
 
+    /// Select the font size (in points).
+    /// This overrides the value from [`Self::text_style`].
+    #[inline]
+    pub fn size(mut self, size: f32) -> Self {
+        self.size = Some(size);
+        self
+    }
+
+    /// Select the font family.
+    ///
+    /// This overrides the value from [`Self::text_style`].
+    ///
+    /// Only the families available in [`crate::FontDefinitions::families`] may be used.
+    #[inline]
+    pub fn family(mut self, family: FontFamily) -> Self {
+        self.family = Some(family);
+        self
+    }
+
+    /// Select the font and size.
+    /// This overrides the value from [`Self::text_style`].
+    #[inline]
+    pub fn font(mut self, font_id: crate::FontId) -> Self {
+        let crate::FontId { size, family } = font_id;
+        self.size = Some(size);
+        self.family = Some(family);
+        self
+    }
+
     /// Override the [`TextStyle`].
     #[inline]
     pub fn text_style(mut self, text_style: TextStyle) -> Self {
@@ -170,24 +212,33 @@ impl RichText {
     }
 
     /// Read the font height of the selected text style.
-    pub fn font_height(&self, fonts: &epaint::text::Fonts, style: &crate::Style) -> f32 {
-        let text_style = self
-            .text_style
-            .or(style.override_text_style)
-            .unwrap_or(style.body_text_style);
-        fonts.row_height(text_style)
+    pub fn font_height(&self, fonts: &epaint::Fonts, style: &Style) -> f32 {
+        let mut font_id = self.text_style.as_ref().map_or_else(
+            || FontSelection::Default.resolve(style),
+            |text_style| text_style.resolve(style),
+        );
+
+        if let Some(size) = self.size {
+            font_id.size = size;
+        }
+        if let Some(family) = &self.family {
+            font_id.family = family.clone();
+        }
+        fonts.row_height(&font_id)
     }
 
     fn into_text_job(
         self,
         style: &Style,
-        default_text_style: TextStyle,
+        fallback_font: FontSelection,
         default_valign: Align,
     ) -> WidgetTextJob {
         let text_color = self.get_text_color(&style.visuals);
 
         let Self {
             text,
+            size,
+            family,
             text_style,
             background_color,
             text_color: _, // already used by `get_text_color`
@@ -204,9 +255,21 @@ impl RichText {
         let line_color = text_color.unwrap_or_else(|| style.visuals.text_color());
         let text_color = text_color.unwrap_or(crate::Color32::TEMPORARY_COLOR);
 
-        let text_style = text_style
-            .or(style.override_text_style)
-            .unwrap_or(default_text_style);
+        let font_id = {
+            let mut font_id = text_style
+                .or_else(|| style.override_text_style.clone())
+                .map_or_else(
+                    || fallback_font.resolve(style),
+                    |text_style| text_style.resolve(style),
+                );
+            if let Some(size) = size {
+                font_id.size = size;
+            }
+            if let Some(family) = family {
+                font_id.family = family;
+            }
+            font_id
+        };
 
         let mut background_color = background_color;
         if code {
@@ -230,7 +293,7 @@ impl RichText {
         };
 
         let text_format = crate::text::TextFormat {
-            style: text_style,
+            font_id,
             color: text_color,
             background: background_color,
             italics,
@@ -267,8 +330,10 @@ impl RichText {
 /// but it can be a [`RichText`] (text with color, style, etc),
 /// a [`LayoutJob`] (for when you want full control of how the text looks)
 /// or text that has already been layed out in a [`Galley`].
+#[derive(Clone)]
 pub enum WidgetText {
     RichText(RichText),
+
     /// Use this [`LayoutJob`] when laying out the text.
     ///
     /// Only [`LayoutJob::text`] and [`LayoutJob::sections`] are guaranteed to be respected.
@@ -279,6 +344,7 @@ pub enum WidgetText {
     /// If you want all parts of the `LayoutJob` respected, then convert it to a
     /// [`Galley`] and use [`Self::Galley`] instead.
     LayoutJob(LayoutJob),
+
     /// Use exactly this galley when painting the text.
     Galley(Arc<Galley>),
 }
@@ -437,7 +503,7 @@ impl WidgetText {
         }
     }
 
-    pub(crate) fn font_height(&self, fonts: &epaint::text::Fonts, style: &crate::Style) -> f32 {
+    pub(crate) fn font_height(&self, fonts: &epaint::Fonts, style: &Style) -> f32 {
         match self {
             Self::RichText(text) => text.font_height(fonts, style),
             Self::LayoutJob(job) => job.font_height(fonts),
@@ -454,11 +520,11 @@ impl WidgetText {
     pub fn into_text_job(
         self,
         style: &Style,
-        default_text_style: TextStyle,
+        fallback_font: FontSelection,
         default_valign: Align,
     ) -> WidgetTextJob {
         match self {
-            Self::RichText(text) => text.into_text_job(style, default_text_style, default_valign),
+            Self::RichText(text) => text.into_text_job(style, fallback_font, default_valign),
             Self::LayoutJob(job) => WidgetTextJob {
                 job,
                 job_has_color: true,
@@ -481,7 +547,7 @@ impl WidgetText {
         ui: &Ui,
         wrap: Option<bool>,
         available_width: f32,
-        default_text_style: TextStyle,
+        fallback_font: impl Into<FontSelection>,
     ) -> WidgetTextGalley {
         let wrap = wrap.unwrap_or_else(|| ui.wrap_text());
         let wrap_width = if wrap { available_width } else { f32::INFINITY };
@@ -489,7 +555,7 @@ impl WidgetText {
         match self {
             Self::RichText(text) => {
                 let valign = ui.layout().vertical_align();
-                let mut text_job = text.into_text_job(ui.style(), default_text_style, valign);
+                let mut text_job = text.into_text_job(ui.style(), fallback_font.into(), valign);
                 text_job.job.wrap_width = wrap_width;
                 WidgetTextGalley {
                     galley: ui.fonts().layout_job(text_job.job),
diff --git a/egui/src/widgets/button.rs b/egui/src/widgets/button.rs
index 599d77c1..f8fbe359 100644
--- a/egui/src/widgets/button.rs
+++ b/egui/src/widgets/button.rs
@@ -180,7 +180,7 @@ impl Widget for Button {
                 let stroke = stroke.unwrap_or(visuals.bg_stroke);
                 ui.painter().rect(
                     rect.expand(visuals.expansion),
-                    visuals.corner_radius,
+                    visuals.rounding,
                     fill,
                     stroke,
                 );
@@ -265,7 +265,7 @@ impl<'a> Widget for Checkbox<'a> {
             let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
             ui.painter().add(epaint::RectShape {
                 rect: big_icon_rect.expand(visuals.expansion),
-                corner_radius: visuals.corner_radius,
+                rounding: visuals.rounding,
                 fill: visuals.bg_fill,
                 stroke: visuals.bg_stroke,
             });
@@ -394,7 +394,7 @@ pub struct ImageButton {
 }
 
 impl ImageButton {
-    pub fn new(texture_id: TextureId, size: impl Into<Vec2>) -> Self {
+    pub fn new(texture_id: impl Into<TextureId>, size: impl Into<Vec2>) -> Self {
         Self {
             image: widgets::Image::new(texture_id, size),
             sense: Sense::click(),
@@ -455,9 +455,14 @@ impl Widget for ImageButton {
         response.widget_info(|| WidgetInfo::new(WidgetType::ImageButton));
 
         if ui.is_rect_visible(rect) {
-            let (expansion, corner_radius, fill, stroke) = if selected {
+            let (expansion, rounding, fill, stroke) = if selected {
                 let selection = ui.visuals().selection;
-                (-padding, 0.0, selection.bg_fill, selection.stroke)
+                (
+                    -padding,
+                    Rounding::none(),
+                    selection.bg_fill,
+                    selection.stroke,
+                )
             } else if frame {
                 let visuals = ui.style().interact(&response);
                 let expansion = if response.hovered {
@@ -467,7 +472,7 @@ impl Widget for ImageButton {
                 };
                 (
                     expansion,
-                    visuals.corner_radius,
+                    visuals.rounding,
                     visuals.bg_fill,
                     visuals.bg_stroke,
                 )
@@ -477,7 +482,7 @@ impl Widget for ImageButton {
 
             // Draw frame background (for transparent images):
             ui.painter()
-                .rect_filled(rect.expand2(expansion), corner_radius, fill);
+                .rect_filled(rect.expand2(expansion), rounding, fill);
 
             let image_rect = ui
                 .layout()
@@ -487,7 +492,7 @@ impl Widget for ImageButton {
 
             // Draw frame outline:
             ui.painter()
-                .rect_stroke(rect.expand2(expansion), corner_radius, stroke);
+                .rect_stroke(rect.expand2(expansion), rounding, stroke);
         }
 
         response
diff --git a/egui/src/widgets/color_picker.rs b/egui/src/widgets/color_picker.rs
index 63e24119..6ed70d60 100644
--- a/egui/src/widgets/color_picker.rs
+++ b/egui/src/widgets/color_picker.rs
@@ -61,7 +61,7 @@ fn show_hsva(ui: &mut Ui, color: Hsva, desired_size: Vec2) -> Response {
         } else {
             ui.painter().add(RectShape {
                 rect,
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 fill: color.into(),
                 stroke: Stroke::new(3.0, color.to_opaque()),
             });
@@ -90,9 +90,15 @@ fn color_button(ui: &mut Ui, color: Color32, open: bool) -> Response {
         ui.painter().rect_filled(left_half, 0.0, color);
         ui.painter().rect_filled(right_half, 0.0, color.to_opaque());
 
-        let corner_radius = visuals.corner_radius.at_most(2.0);
+        let rounding = Rounding {
+            nw: visuals.rounding.nw.at_most(2.0),
+            ne: visuals.rounding.ne.at_most(2.0),
+            sw: visuals.rounding.sw.at_most(2.0),
+            se: visuals.rounding.se.at_most(2.0),
+        };
+
         ui.painter()
-            .rect_stroke(rect, corner_radius, (2.0, visuals.bg_fill)); // fill is intentional, because default style has no border
+            .rect_stroke(rect, rounding, (2.0, visuals.bg_fill)); // fill is intentional, because default style has no border
     }
 
     response
@@ -308,8 +314,10 @@ fn color_picker_hsvag_2d(ui: &mut Ui, hsva: &mut HsvaGamma, alpha: Alpha) {
     color_slider_2d(ui, v, s, |v, s| HsvaGamma { s, v, ..opaque }.into());
 }
 
+//// Shows a color picker where the user can change the given [`Hsva`] color.
+///
 /// Returns `true` on change.
-fn color_picker_hsva_2d(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> bool {
+pub fn color_picker_hsva_2d(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> bool {
     let mut hsvag = HsvaGamma::from(*hsva);
     ui.vertical(|ui| {
         color_picker_hsvag_2d(ui, &mut hsvag, alpha);
@@ -323,7 +331,7 @@ fn color_picker_hsva_2d(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> bool {
     }
 }
 
-/// Shows a color picker where the user can change the given color.
+/// Shows a color picker where the user can change the given [`Color32`] color.
 ///
 /// Returns `true` on change.
 pub fn color_picker_color32(ui: &mut Ui, srgba: &mut Color32, alpha: Alpha) -> bool {
@@ -335,19 +343,19 @@ pub fn color_picker_color32(ui: &mut Ui, srgba: &mut Color32, alpha: Alpha) -> b
 }
 
 pub fn color_edit_button_hsva(ui: &mut Ui, hsva: &mut Hsva, alpha: Alpha) -> Response {
-    let pupup_id = ui.auto_id_with("popup");
-    let open = ui.memory().is_popup_open(pupup_id);
+    let popup_id = ui.auto_id_with("popup");
+    let open = ui.memory().is_popup_open(popup_id);
     let mut button_response = color_button(ui, (*hsva).into(), open);
     if ui.style().explanation_tooltips {
         button_response = button_response.on_hover_text("Click to edit color");
     }
 
     if button_response.clicked() {
-        ui.memory().toggle_popup(pupup_id);
+        ui.memory().toggle_popup(popup_id);
     }
     // TODO: make it easier to show a temporary popup that closes when you click outside it
-    if ui.memory().is_popup_open(pupup_id) {
-        let area_response = Area::new(pupup_id)
+    if ui.memory().is_popup_open(popup_id) {
+        let area_response = Area::new(popup_id)
             .order(Order::Foreground)
             .default_pos(button_response.rect.max)
             .show(ui.ctx(), |ui| {
@@ -427,5 +435,5 @@ fn color_cache_set(ctx: &Context, rgba: impl Into<Rgba>, hsva: Hsva) {
 
 // To ensure we keep hue slider when `srgba` is gray we store the full `Hsva` in a cache:
 fn use_color_cache<R>(ctx: &Context, f: impl FnOnce(&mut FixedCache<Rgba, Hsva>) -> R) -> R {
-    f(ctx.memory().data.get_temp_mut_or_default(Id::null()))
+    f(ctx.data().get_temp_mut_or_default(Id::null()))
 }
diff --git a/egui/src/widgets/drag_value.rs b/egui/src/widgets/drag_value.rs
index a9afa873..0c788184 100644
--- a/egui/src/widgets/drag_value.rs
+++ b/egui/src/widgets/drag_value.rs
@@ -159,8 +159,8 @@ impl<'a> Widget for DragValue<'a> {
             max_decimals,
         } = self;
 
-        let is_slow_speed =
-            ui.input().modifiers.shift_only() && ui.memory().is_being_dragged(ui.next_auto_id());
+        let shift = ui.input().modifiers.shift_only();
+        let is_slow_speed = shift && ui.memory().is_being_dragged(ui.next_auto_id());
 
         let old_value = get(&mut get_set_value);
         let value = clamp_to_range(old_value, clamp_range.clone());
@@ -195,7 +195,7 @@ impl<'a> Widget for DragValue<'a> {
                 TextEdit::singleline(&mut value_text)
                     .id(kb_edit_id)
                     .desired_width(button_width)
-                    .text_style(TextStyle::Monospace),
+                    .font(TextStyle::Monospace),
             );
             if let Ok(parsed_value) = value_text.parse() {
                 let parsed_value = clamp_to_range(parsed_value, clamp_range);
diff --git a/egui/src/widgets/image.rs b/egui/src/widgets/image.rs
index ef1b88b6..61ea0d9a 100644
--- a/egui/src/widgets/image.rs
+++ b/egui/src/widgets/image.rs
@@ -2,17 +2,31 @@ use crate::*;
 
 /// An widget to show an image of a given size.
 ///
-/// ```
-/// # egui::__run_test_ui(|ui| {
-/// # let my_texture_id = egui::TextureId::User(0);
-/// ui.add(egui::Image::new(my_texture_id, [640.0, 480.0]));
+/// In order to display an image you must first acquire a [`TextureHandle`]
+/// using [`Context::load_texture`].
 ///
-/// // Shorter version:
-/// ui.image(my_texture_id, [640.0, 480.0]);
-/// # });
+/// ```
+/// struct MyImage {
+///     texture: Option<egui::TextureHandle>,
+/// }
+///
+/// impl MyImage {
+///     fn ui(&mut self, ui: &mut egui::Ui) {
+///         let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+///             // Load the texture only once.
+///             ui.ctx().load_texture("my-image", egui::ColorImage::example())
+///         });
+///
+///         // Show the image:
+///         ui.add(egui::Image::new(texture, texture.size_vec2()));
+///
+///         // Shorter version:
+///         ui.image(texture, texture.size_vec2());
+///     }
+/// }
 /// ```
 ///
-/// Se also [`crate::ImageButton`].
+/// Se also [`crate::Ui::image`] and [`crate::ImageButton`].
 #[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
 #[derive(Clone, Copy, Debug)]
 pub struct Image {
@@ -25,9 +39,9 @@ pub struct Image {
 }
 
 impl Image {
-    pub fn new(texture_id: TextureId, size: impl Into<Vec2>) -> Self {
+    pub fn new(texture_id: impl Into<TextureId>, size: impl Into<Vec2>) -> Self {
         Self {
-            texture_id,
+            texture_id: texture_id.into(),
             uv: Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
             size: size.into(),
             bg_fill: Default::default(),
diff --git a/egui/src/widgets/label.rs b/egui/src/widgets/label.rs
index 77dd15cc..5513fb20 100644
--- a/egui/src/widgets/label.rs
+++ b/egui/src/widgets/label.rs
@@ -2,6 +2,8 @@ use crate::{widget_text::WidgetTextGalley, *};
 
 /// Static text.
 ///
+/// Usually it is more convenient to use [`Ui::label`].
+///
 /// ```
 /// # egui::__run_test_ui(|ui| {
 /// ui.label("Equivalent");
@@ -49,7 +51,7 @@ impl Label {
     /// By calling this you can turn the label into a button of sorts.
     /// This will also give the label the hover-effect of a button, but without the frame.
     ///
-    /// ``` rust
+    /// ```
     /// # use egui::{Label, Sense};
     /// # egui::__run_test_ui(|ui| {
     /// if ui.add(Label::new("click me").sense(Sense::click())).clicked() {
@@ -82,7 +84,9 @@ impl Label {
         }
 
         let valign = ui.layout().vertical_align();
-        let mut text_job = self.text.into_text_job(ui.style(), TextStyle::Body, valign);
+        let mut text_job = self
+            .text
+            .into_text_job(ui.style(), FontSelection::Default, valign);
 
         let should_wrap = self.wrap.unwrap_or_else(|| ui.wrap_text());
         let available_width = ui.available_width();
@@ -106,7 +110,7 @@ impl Label {
             if let Some(first_section) = text_job.job.sections.first_mut() {
                 first_section.leading_space = first_row_indentation;
             }
-            let text_galley = text_job.into_galley(ui.fonts());
+            let text_galley = text_job.into_galley(&*ui.fonts());
 
             let pos = pos2(ui.max_rect().left(), ui.cursor().top());
             assert!(
@@ -139,7 +143,7 @@ impl Label {
                 text_job.job.justify = ui.layout().horizontal_justify();
             };
 
-            let text_galley = text_job.into_galley(ui.fonts());
+            let text_galley = text_job.into_galley(&*ui.fonts());
             let (rect, response) = ui.allocate_exact_size(text_galley.size(), self.sense);
             let pos = match text_galley.galley.job.halign {
                 Align::LEFT => rect.left_top(),
diff --git a/egui/src/widgets/plot/items/bar.rs b/egui/src/widgets/plot/items/bar.rs
index 4453e9ae..39f3a91f 100644
--- a/egui/src/widgets/plot/items/bar.rs
+++ b/egui/src/widgets/plot/items/bar.rs
@@ -1,5 +1,5 @@
 use crate::emath::NumExt;
-use crate::epaint::{Color32, RectShape, Shape, Stroke};
+use crate::epaint::{Color32, RectShape, Rounding, Shape, Stroke};
 
 use super::{add_rulers_and_text, highlighted_color, Orientation, PlotConfig, RectElement};
 use crate::plot::{BarChart, ScreenTransform, Value};
@@ -129,7 +129,7 @@ impl Bar {
         let rect = transform.rect_from_values(&self.bounds_min(), &self.bounds_max());
         let rect = Shape::Rect(RectShape {
             rect,
-            corner_radius: 0.0,
+            rounding: Rounding::none(),
             fill,
             stroke,
         });
diff --git a/egui/src/widgets/plot/items/box_elem.rs b/egui/src/widgets/plot/items/box_elem.rs
index 451cba48..7cda17c8 100644
--- a/egui/src/widgets/plot/items/box_elem.rs
+++ b/egui/src/widgets/plot/items/box_elem.rs
@@ -1,5 +1,5 @@
 use crate::emath::NumExt;
-use crate::epaint::{Color32, RectShape, Shape, Stroke};
+use crate::epaint::{Color32, RectShape, Rounding, Shape, Stroke};
 
 use super::{add_rulers_and_text, highlighted_color, Orientation, PlotConfig, RectElement};
 use crate::plot::{BoxPlot, ScreenTransform, Value};
@@ -152,7 +152,7 @@ impl BoxElem {
         );
         let rect = Shape::Rect(RectShape {
             rect,
-            corner_radius: 0.0,
+            rounding: Rounding::none(),
             fill,
             stroke,
         });
diff --git a/egui/src/widgets/plot/items/mod.rs b/egui/src/widgets/plot/items/mod.rs
index 87d27f38..983d29df 100644
--- a/egui/src/widgets/plot/items/mod.rs
+++ b/egui/src/widgets/plot/items/mod.rs
@@ -9,11 +9,11 @@ use crate::*;
 
 use super::{CustomLabelFuncRef, PlotBounds, ScreenTransform};
 use rect_elem::*;
-use values::*;
+use values::{ClosestElem, PlotGeometry};
 
 pub use bar::Bar;
 pub use box_elem::{BoxElem, BoxSpread};
-pub use values::{LineStyle, MarkerShape, Value, Values};
+pub use values::{LineStyle, MarkerShape, Orientation, Value, Values};
 
 mod bar;
 mod box_elem;
@@ -117,8 +117,8 @@ impl HLine {
     }
 
     /// Highlight this line in the plot by scaling up the line.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -227,8 +227,8 @@ impl VLine {
     }
 
     /// Highlight this line in the plot by scaling up the line.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -338,8 +338,8 @@ impl Line {
     }
 
     /// Highlight this line in the plot by scaling up the line.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -506,8 +506,8 @@ impl Polygon {
 
     /// Highlight this polygon in the plot by scaling up the stroke and reducing the fill
     /// transparency.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -614,8 +614,7 @@ impl PlotItem for Polygon {
 
 /// Text inside the plot.
 pub struct Text {
-    pub(super) text: String,
-    pub(super) style: TextStyle,
+    pub(super) text: WidgetText,
     pub(super) position: Value,
     pub(super) name: String,
     pub(super) highlight: bool,
@@ -624,11 +623,9 @@ pub struct Text {
 }
 
 impl Text {
-    #[allow(clippy::needless_pass_by_value)]
-    pub fn new(position: Value, text: impl ToString) -> Self {
+    pub fn new(position: Value, text: impl Into<WidgetText>) -> Self {
         Self {
-            text: text.to_string(),
-            style: TextStyle::Small,
+            text: text.into(),
             position,
             name: Default::default(),
             highlight: false,
@@ -638,18 +635,12 @@ impl Text {
     }
 
     /// Highlight this text in the plot by drawing a rectangle around it.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
-    /// Text style. Default is `TextStyle::Small`.
-    pub fn style(mut self, style: TextStyle) -> Self {
-        self.style = style;
-        self
-    }
-
-    /// Text color. Default is `Color32::TRANSPARENT` which means a color will be auto-assigned.
+    /// Text color.
     pub fn color(mut self, color: impl Into<Color32>) -> Self {
         self.color = color.into();
         self
@@ -681,14 +672,23 @@ impl PlotItem for Text {
         } else {
             self.color
         };
+
+        let galley =
+            self.text
+                .clone()
+                .into_galley(ui, Some(false), f32::INFINITY, TextStyle::Small);
+
         let pos = transform.position_from_value(&self.position);
-        let galley = ui
-            .fonts()
-            .layout_no_wrap(self.text.clone(), self.style, color);
         let rect = self
             .anchor
             .anchor_rect(Rect::from_min_size(pos, galley.size()));
-        shapes.push(Shape::galley(rect.min, galley));
+
+        let mut text_shape = epaint::TextShape::new(rect.min, galley.galley);
+        if !galley.galley_has_color {
+            text_shape.override_text_color = Some(color);
+        }
+        shapes.push(text_shape.into());
+
         if self.highlight {
             shapes.push(Shape::rect_stroke(
                 rect.expand(2.0),
@@ -763,8 +763,8 @@ impl Points {
     }
 
     /// Highlight these points in the plot by scaling up their markers.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -979,8 +979,8 @@ impl Arrows {
     }
 
     /// Highlight these arrows in the plot.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -1087,12 +1087,16 @@ pub struct PlotImage {
 
 impl PlotImage {
     /// Create a new image with position and size in plot coordinates.
-    pub fn new(texture_id: TextureId, position: Value, size: impl Into<Vec2>) -> Self {
+    pub fn new(
+        texture_id: impl Into<TextureId>,
+        center_position: Value,
+        size: impl Into<Vec2>,
+    ) -> Self {
         Self {
-            position,
+            position: center_position,
             name: Default::default(),
             highlight: false,
-            texture_id,
+            texture_id: texture_id.into(),
             uv: Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
             size: size.into(),
             bg_fill: Default::default(),
@@ -1101,8 +1105,8 @@ impl PlotImage {
     }
 
     /// Highlight this image in the plot.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -1291,8 +1295,8 @@ impl BarChart {
     }
 
     /// Highlight all plot elements.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -1454,8 +1458,8 @@ impl BoxPlot {
     }
 
     /// Highlight all plot elements.
-    pub fn highlight(mut self) -> Self {
-        self.highlight = true;
+    pub fn highlight(mut self, highlight: bool) -> Self {
+        self.highlight = highlight;
         self
     }
 
@@ -1617,13 +1621,15 @@ fn add_rulers_and_text(
         text
     });
 
+    let font_id = TextStyle::Body.resolve(plot.ui.style());
+
     let corner_value = elem.corner_value();
     shapes.push(Shape::text(
-        plot.ui.fonts(),
+        &*plot.ui.fonts(),
         plot.transform.position_from_value(&corner_value) + vec2(3.0, -2.0),
         Align2::LEFT_BOTTOM,
         text,
-        TextStyle::Body,
+        font_id,
         plot.ui.visuals().text_color(),
     ));
 }
@@ -1673,12 +1679,14 @@ pub(super) fn rulers_at_value(
         }
     };
 
+    let font_id = TextStyle::Body.resolve(plot.ui.style());
+
     shapes.push(Shape::text(
-        plot.ui.fonts(),
+        &*plot.ui.fonts(),
         pointer + vec2(3.0, -2.0),
         Align2::LEFT_BOTTOM,
         text,
-        TextStyle::Body,
+        font_id,
         plot.ui.visuals().text_color(),
     ));
 }
diff --git a/egui/src/widgets/plot/items/values.rs b/egui/src/widgets/plot/items/values.rs
index 735f3e03..946d203a 100644
--- a/egui/src/widgets/plot/items/values.rs
+++ b/egui/src/widgets/plot/items/values.rs
@@ -125,6 +125,7 @@ impl ToString for LineStyle {
 
 // ----------------------------------------------------------------------------
 
+/// Determines whether a plot element is vertically or horizontally oriented.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum Orientation {
     Horizontal,
@@ -139,20 +140,12 @@ impl Default for Orientation {
 
 // ----------------------------------------------------------------------------
 
+#[derive(Default)]
 pub struct Values {
     pub(super) values: Vec<Value>,
     generator: Option<ExplicitGenerator>,
 }
 
-impl Default for Values {
-    fn default() -> Self {
-        Self {
-            values: Vec::new(),
-            generator: None,
-        }
-    }
-}
-
 impl Values {
     pub fn from_values(values: Vec<Value>) -> Self {
         Self {
@@ -297,7 +290,7 @@ pub enum MarkerShape {
 
 impl MarkerShape {
     /// Get a vector containing all marker shapes.
-    pub fn all() -> impl Iterator<Item = MarkerShape> {
+    pub fn all() -> impl ExactSizeIterator<Item = MarkerShape> {
         [
             Self::Circle,
             Self::Diamond,
@@ -342,7 +335,7 @@ struct ExplicitGenerator {
 
 // ----------------------------------------------------------------------------
 
-/// Result of [`PlotItem::find_closest()`] search, identifies an element inside the item for immediate use
+/// Result of [`super::PlotItem::find_closest()`] search, identifies an element inside the item for immediate use
 pub(crate) struct ClosestElem {
     /// Position of hovered-over value (or bar/box-plot/...) in PlotItem
     pub index: usize,
diff --git a/egui/src/widgets/plot/legend.rs b/egui/src/widgets/plot/legend.rs
index 3f41c400..71f3dfdc 100644
--- a/egui/src/widgets/plot/legend.rs
+++ b/egui/src/widgets/plot/legend.rs
@@ -29,7 +29,7 @@ impl Corner {
 }
 
 /// The configuration for a plot legend.
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub struct Legend {
     pub text_style: TextStyle,
     pub background_alpha: f32,
@@ -82,16 +82,18 @@ impl LegendEntry {
         }
     }
 
-    fn ui(&mut self, ui: &mut Ui, text: String) -> Response {
+    fn ui(&mut self, ui: &mut Ui, text: String, text_style: &TextStyle) -> Response {
         let Self {
             color,
             checked,
             hovered,
         } = self;
 
-        let galley =
-            ui.fonts()
-                .layout_delayed_color(text, ui.style().body_text_style, f32::INFINITY);
+        let font_id = text_style.resolve(ui.style());
+
+        let galley = ui
+            .fonts()
+            .layout_delayed_color(text, font_id, f32::INFINITY);
 
         let icon_size = galley.size().y;
         let icon_spacing = icon_size / 5.0;
@@ -236,10 +238,9 @@ impl Widget for &mut LegendWidget {
         let mut legend_ui = ui.child_ui(legend_rect, layout);
         legend_ui
             .scope(|ui| {
-                ui.style_mut().body_text_style = config.text_style;
                 let background_frame = Frame {
                     margin: vec2(8.0, 4.0),
-                    corner_radius: ui.style().visuals.window_corner_radius,
+                    rounding: ui.style().visuals.window_rounding,
                     shadow: epaint::Shadow::default(),
                     fill: ui.style().visuals.extreme_bg_color,
                     stroke: ui.style().visuals.window_stroke(),
@@ -249,7 +250,7 @@ impl Widget for &mut LegendWidget {
                     .show(ui, |ui| {
                         entries
                             .iter_mut()
-                            .map(|(name, entry)| entry.ui(ui, name.clone()))
+                            .map(|(name, entry)| entry.ui(ui, name.clone(), &config.text_style))
                             .reduce(|r1, r2| r1.union(r2))
                             .unwrap()
                     })
diff --git a/egui/src/widgets/plot/mod.rs b/egui/src/widgets/plot/mod.rs
index 3dbf71fd..647c1b41 100644
--- a/egui/src/widgets/plot/mod.rs
+++ b/egui/src/widgets/plot/mod.rs
@@ -1,5 +1,7 @@
 //! Simple plotting library.
 
+use std::{cell::RefCell, rc::Rc};
+
 use crate::*;
 use epaint::ahash::AHashSet;
 use epaint::color::Hsva;
@@ -10,7 +12,7 @@ use transform::{PlotBounds, ScreenTransform};
 
 pub use items::{
     Arrows, Bar, BarChart, BoxElem, BoxPlot, BoxSpread, HLine, Line, LineStyle, MarkerShape,
-    PlotImage, Points, Polygon, Text, VLine, Value, Values,
+    Orientation, PlotImage, Points, Polygon, Text, VLine, Value, Values,
 };
 pub use legend::{Corner, Legend};
 
@@ -21,6 +23,9 @@ mod transform;
 type CustomLabelFunc = dyn Fn(&str, &Value) -> String;
 type CustomLabelFuncRef = Option<Box<CustomLabelFunc>>;
 
+type AxisFormatterFn = dyn Fn(f64) -> String;
+type AxisFormatter = Option<Box<AxisFormatterFn>>;
+
 // ----------------------------------------------------------------------------
 
 /// Information about the plot that has to persist between frames.
@@ -32,15 +37,74 @@ struct PlotMemory {
     hidden_items: AHashSet<String>,
     min_auto_bounds: PlotBounds,
     last_screen_transform: ScreenTransform,
+    /// Allows to remember the first click position when performing a boxed zoom
+    last_click_pos_for_zoom: Option<Pos2>,
 }
 
 impl PlotMemory {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(id)
+        ctx.data().get_persisted(id)
     }
 
     pub fn store(self, ctx: &Context, id: Id) {
-        ctx.memory().data.insert_persisted(id, self);
+        ctx.data().insert_persisted(id, self);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Defines how multiple plots share the same range for one or both of their axes. Can be added while building
+/// a plot with [`Plot::link_axis`]. Contains an internal state, meaning that this object should be stored by
+/// the user between frames.
+#[derive(Clone, PartialEq)]
+pub struct LinkedAxisGroup {
+    pub(crate) link_x: bool,
+    pub(crate) link_y: bool,
+    pub(crate) bounds: Rc<RefCell<Option<PlotBounds>>>,
+}
+
+impl LinkedAxisGroup {
+    pub fn new(link_x: bool, link_y: bool) -> Self {
+        Self {
+            link_x,
+            link_y,
+            bounds: Rc::new(RefCell::new(None)),
+        }
+    }
+
+    /// Only link the x-axis.
+    pub fn x() -> Self {
+        Self::new(true, false)
+    }
+
+    /// Only link the y-axis.
+    pub fn y() -> Self {
+        Self::new(false, true)
+    }
+
+    /// Link both axes. Note that this still respects the aspect ratio of the individual plots.
+    pub fn both() -> Self {
+        Self::new(true, true)
+    }
+
+    /// Change whether the x-axis is linked for this group. Using this after plots in this group have been
+    /// drawn in this frame already may lead to unexpected results.
+    pub fn set_link_x(&mut self, link: bool) {
+        self.link_x = link;
+    }
+
+    /// Change whether the y-axis is linked for this group. Using this after plots in this group have been
+    /// drawn in this frame already may lead to unexpected results.
+    pub fn set_link_y(&mut self, link: bool) {
+        self.link_y = link;
+    }
+
+    fn get(&self) -> Option<PlotBounds> {
+        *self.bounds.borrow()
+    }
+
+    fn set(&self, bounds: PlotBounds) {
+        *self.bounds.borrow_mut() = Some(bounds);
     }
 }
 
@@ -70,6 +134,9 @@ pub struct Plot {
     allow_drag: bool,
     min_auto_bounds: PlotBounds,
     margin_fraction: Vec2,
+    allow_boxed_zoom: bool,
+    boxed_zoom_pointer_button: PointerButton,
+    linked_axes: Option<LinkedAxisGroup>,
 
     min_size: Vec2,
     width: Option<f32>,
@@ -80,6 +147,7 @@ pub struct Plot {
     show_x: bool,
     show_y: bool,
     custom_label_func: CustomLabelFuncRef,
+    axis_formatters: [AxisFormatter; 2],
     legend_config: Option<Legend>,
     show_background: bool,
     show_axes: [bool; 2],
@@ -97,6 +165,9 @@ impl Plot {
             allow_drag: true,
             min_auto_bounds: PlotBounds::NOTHING,
             margin_fraction: Vec2::splat(0.05),
+            allow_boxed_zoom: true,
+            boxed_zoom_pointer_button: PointerButton::Secondary,
+            linked_axes: None,
 
             min_size: Vec2::splat(64.0),
             width: None,
@@ -107,6 +178,7 @@ impl Plot {
             show_x: true,
             show_y: true,
             custom_label_func: None,
+            axis_formatters: [None, None], // [None; 2] requires Copy
             legend_config: None,
             show_background: true,
             show_axes: [true; 2],
@@ -181,6 +253,20 @@ impl Plot {
         self
     }
 
+    /// Whether to allow zooming in the plot by dragging out a box with the secondary mouse button.
+    ///
+    /// Default: `true`.
+    pub fn allow_boxed_zoom(mut self, on: bool) -> Self {
+        self.allow_boxed_zoom = on;
+        self
+    }
+
+    /// Config the button pointer to use for boxed zooming. Default: `Secondary`
+    pub fn boxed_zoom_pointer_button(mut self, boxed_zoom_pointer_button: PointerButton) -> Self {
+        self.boxed_zoom_pointer_button = boxed_zoom_pointer_button;
+        self
+    }
+
     /// Whether to allow dragging in the plot to move the bounds. Default: `true`.
     pub fn allow_drag(mut self, on: bool) -> Self {
         self.allow_drag = on;
@@ -208,11 +294,35 @@ impl Plot {
     /// .show(ui, |plot_ui| plot_ui.line(line));
     /// # });
     /// ```
-    pub fn custom_label_func<F: 'static + Fn(&str, &Value) -> String>(
+    pub fn custom_label_func(
         mut self,
-        custom_lebel_func: F,
+        custom_label_func: impl Fn(&str, &Value) -> String + 'static,
     ) -> Self {
-        self.custom_label_func = Some(Box::new(custom_lebel_func));
+        self.custom_label_func = Some(Box::new(custom_label_func));
+        self
+    }
+
+    /// Provide a function to customize the labels for the X axis.
+    ///
+    /// This is useful for custom input domains, e.g. date/time.
+    ///
+    /// If axis labels should not appear for certain values or beyond a certain zoom/resolution,
+    /// the formatter function can return empty strings. This is also useful if your domain is
+    /// discrete (e.g. only full days in a calendar).
+    pub fn x_axis_formatter(mut self, func: impl Fn(f64) -> String + 'static) -> Self {
+        self.axis_formatters[0] = Some(Box::new(func));
+        self
+    }
+
+    /// Provide a function to customize the labels for the Y axis.
+    ///
+    /// This is useful for custom value representation, e.g. percentage or units.
+    ///
+    /// If axis labels should not appear for certain values or beyond a certain zoom/resolution,
+    /// the formatter function can return empty strings. This is also useful if your Y values are
+    /// discrete (e.g. only integers).
+    pub fn y_axis_formatter(mut self, func: impl Fn(f64) -> String + 'static) -> Self {
+        self.axis_formatters[1] = Some(Box::new(func));
         self
     }
 
@@ -252,6 +362,13 @@ impl Plot {
         self
     }
 
+    /// Add a [`LinkedAxisGroup`] so that this plot will share the bounds with other plots that have this
+    /// group assigned. A plot cannot belong to more than one group.
+    pub fn link_axis(mut self, group: LinkedAxisGroup) -> Self {
+        self.linked_axes = Some(group);
+        self
+    }
+
     /// Interact with and add items to the plot and finally draw it.
     pub fn show<R>(self, ui: &mut Ui, build_fn: impl FnOnce(&mut PlotUi) -> R) -> InnerResponse<R> {
         let Self {
@@ -260,6 +377,8 @@ impl Plot {
             center_y_axis,
             allow_zoom,
             allow_drag,
+            allow_boxed_zoom,
+            boxed_zoom_pointer_button: boxed_zoom_pointer,
             min_auto_bounds,
             margin_fraction,
             width,
@@ -270,9 +389,11 @@ impl Plot {
             mut show_x,
             mut show_y,
             custom_label_func,
+            axis_formatters,
             legend_config,
             show_background,
             show_axes,
+            linked_axes,
         } = self;
 
         // Determine the size of the plot in the UI
@@ -315,6 +436,7 @@ impl Plot {
                 center_x_axis,
                 center_y_axis,
             ),
+            last_click_pos_for_zoom: None,
         });
 
         // If the min bounds changed, recalculate everything.
@@ -333,6 +455,7 @@ impl Plot {
             mut hovered_entry,
             mut hidden_items,
             last_screen_transform,
+            mut last_click_pos_for_zoom,
             ..
         } = memory;
 
@@ -356,7 +479,7 @@ impl Plot {
         if show_background {
             ui.painter().sub_region(rect).add(epaint::RectShape {
                 rect,
-                corner_radius: 2.0,
+                rounding: Rounding::same(2.0),
                 fill: ui.visuals().extreme_bg_color,
                 stroke: ui.visuals().widgets.noninteractive.bg_stroke,
             });
@@ -385,6 +508,22 @@ impl Plot {
         // --- Bound computation ---
         let mut bounds = *last_screen_transform.bounds();
 
+        // Transfer the bounds from a link group.
+        if let Some(axes) = linked_axes.as_ref() {
+            if let Some(linked_bounds) = axes.get() {
+                if axes.link_x {
+                    bounds.min[0] = linked_bounds.min[0];
+                    bounds.max[0] = linked_bounds.max[0];
+                }
+                if axes.link_y {
+                    bounds.min[1] = linked_bounds.min[1];
+                    bounds.max[1] = linked_bounds.max[1];
+                }
+                // Turn off auto bounds to keep it from overriding what we just set.
+                auto_bounds = false;
+            }
+        }
+
         // Allow double clicking to reset to automatic bounds.
         auto_bounds |= response.double_clicked_by(PointerButton::Primary);
 
@@ -401,7 +540,10 @@ impl Plot {
 
         // Enforce equal aspect ratio.
         if let Some(data_aspect) = data_aspect {
-            transform.set_aspect(data_aspect as f64);
+            let preserve_y = linked_axes
+                .as_ref()
+                .map_or(false, |group| group.link_y && !group.link_x);
+            transform.set_aspect(data_aspect as f64, preserve_y);
         }
 
         // Dragging
@@ -412,6 +554,53 @@ impl Plot {
         }
 
         // Zooming
+        let mut boxed_zoom_rect = None;
+        if allow_boxed_zoom {
+            // Save last click to allow boxed zooming
+            if response.drag_started() && response.dragged_by(boxed_zoom_pointer) {
+                // it would be best for egui that input has a memory of the last click pos because it's a common pattern
+                last_click_pos_for_zoom = response.hover_pos();
+            }
+            let box_start_pos = last_click_pos_for_zoom;
+            let box_end_pos = response.hover_pos();
+            if let (Some(box_start_pos), Some(box_end_pos)) = (box_start_pos, box_end_pos) {
+                // while dragging prepare a Shape and draw it later on top of the plot
+                if response.dragged_by(boxed_zoom_pointer) {
+                    response = response.on_hover_cursor(CursorIcon::ZoomIn);
+                    let rect = epaint::Rect::from_two_pos(box_start_pos, box_end_pos);
+                    boxed_zoom_rect = Some((
+                        epaint::RectShape::stroke(
+                            rect,
+                            0.0,
+                            epaint::Stroke::new(4., Color32::DARK_BLUE),
+                        ), // Outer stroke
+                        epaint::RectShape::stroke(
+                            rect,
+                            0.0,
+                            epaint::Stroke::new(2., Color32::WHITE),
+                        ), // Inner stroke
+                    ));
+                }
+                // when the click is release perform the zoom
+                if response.drag_released() {
+                    let box_start_pos = transform.value_from_position(box_start_pos);
+                    let box_end_pos = transform.value_from_position(box_end_pos);
+                    let new_bounds = PlotBounds {
+                        min: [box_start_pos.x, box_end_pos.y],
+                        max: [box_end_pos.x, box_start_pos.y],
+                    };
+                    if new_bounds.is_valid() {
+                        *transform.bounds_mut() = new_bounds;
+                        auto_bounds = false;
+                    } else {
+                        auto_bounds = true;
+                    }
+                    // reset the boxed zoom state
+                    last_click_pos_for_zoom = None;
+                }
+            }
+        }
+
         if allow_zoom {
             if let Some(hover_pos) = response.hover_pos() {
                 let zoom_factor = if data_aspect.is_some() {
@@ -442,23 +631,34 @@ impl Plot {
             show_x,
             show_y,
             custom_label_func,
+            axis_formatters,
             show_axes,
             transform: transform.clone(),
         };
         prepared.ui(ui, &response);
 
+        if let Some(boxed_zoom_rect) = boxed_zoom_rect {
+            ui.painter().sub_region(rect).add(boxed_zoom_rect.0);
+            ui.painter().sub_region(rect).add(boxed_zoom_rect.1);
+        }
+
         if let Some(mut legend) = legend {
             ui.add(&mut legend);
             hidden_items = legend.get_hidden_items();
             hovered_entry = legend.get_hovered_entry_name();
         }
 
+        if let Some(group) = linked_axes.as_ref() {
+            group.set(*transform.bounds());
+        }
+
         let memory = PlotMemory {
             auto_bounds,
             hovered_entry,
             hidden_items,
             min_auto_bounds,
             last_screen_transform: transform,
+            last_click_pos_for_zoom,
         };
         memory.store(ui.ctx(), plot_id);
 
@@ -473,13 +673,13 @@ impl Plot {
 }
 
 /// Provides methods to interact with a plot while building it. It is the single argument of the closure
-/// provided to `Plot::show`. See [`Plot`] for an example of how to use it.
+/// provided to [`Plot::show`]. See [`Plot`] for an example of how to use it.
 pub struct PlotUi {
     items: Vec<Box<dyn PlotItem>>,
     next_auto_color_idx: usize,
     last_screen_transform: ScreenTransform,
     response: Response,
-    ctx: CtxRef,
+    ctx: Context,
 }
 
 impl PlotUi {
@@ -491,7 +691,7 @@ impl PlotUi {
         Hsva::new(h, 0.85, 0.5, 1.0).into() // TODO: OkLab or some other perspective color space
     }
 
-    pub fn ctx(&self) -> &CtxRef {
+    pub fn ctx(&self) -> &Context {
         &self.ctx
     }
 
@@ -650,6 +850,7 @@ struct PreparedPlot {
     show_x: bool,
     show_y: bool,
     custom_label_func: CustomLabelFuncRef,
+    axis_formatters: [AxisFormatter; 2],
     show_axes: [bool; 2],
     transform: ScreenTransform,
 }
@@ -680,10 +881,15 @@ impl PreparedPlot {
     }
 
     fn paint_axis(&self, ui: &Ui, axis: usize, shapes: &mut Vec<Shape>) {
-        let Self { transform, .. } = self;
+        let Self {
+            transform,
+            axis_formatters,
+            ..
+        } = self;
 
         let bounds = transform.bounds();
-        let text_style = TextStyle::Body;
+
+        let font_id = TextStyle::Body.resolve(ui.style());
 
         let base: i64 = 10;
         let basef = base as f64;
@@ -739,18 +945,26 @@ impl PreparedPlot {
 
             if text_alpha > 0.0 {
                 let color = color_from_alpha(ui, text_alpha);
-                let text = emath::round_to_decimals(value_main, 5).to_string(); // hack
 
-                let galley = ui.painter().layout_no_wrap(text, text_style, color);
+                let text: String = if let Some(formatter) = axis_formatters[axis].as_deref() {
+                    formatter(value_main)
+                } else {
+                    emath::round_to_decimals(value_main, 5).to_string() // hack
+                };
 
-                let mut text_pos = pos_in_gui + vec2(1.0, -galley.size().y);
+                // Custom formatters can return empty string to signal "no label at this resolution"
+                if !text.is_empty() {
+                    let galley = ui.painter().layout_no_wrap(text, font_id.clone(), color);
 
-                // Make sure we see the labels, even if the axis is off-screen:
-                text_pos[1 - axis] = text_pos[1 - axis]
-                    .at_most(transform.frame().max[1 - axis] - galley.size()[1 - axis] - 2.0)
-                    .at_least(transform.frame().min[1 - axis] + 1.0);
+                    let mut text_pos = pos_in_gui + vec2(1.0, -galley.size().y);
 
-                shapes.push(Shape::galley(text_pos, galley));
+                    // Make sure we see the labels, even if the axis is off-screen:
+                    text_pos[1 - axis] = text_pos[1 - axis]
+                        .at_most(transform.frame().max[1 - axis] - galley.size()[1 - axis] - 2.0)
+                        .at_least(transform.frame().min[1 - axis] + 1.0);
+
+                    shapes.push(Shape::galley(text_pos, galley));
+                }
             }
         }
 
diff --git a/egui/src/widgets/plot/transform.rs b/egui/src/widgets/plot/transform.rs
index 53007950..c208bc6e 100644
--- a/egui/src/widgets/plot/transform.rs
+++ b/egui/src/widgets/plot/transform.rs
@@ -178,6 +178,10 @@ impl ScreenTransform {
         &self.bounds
     }
 
+    pub fn bounds_mut(&mut self) -> &mut PlotBounds {
+        &mut self.bounds
+    }
+
     pub fn translate_bounds(&mut self, mut delta_pos: Vec2) {
         if self.x_centered {
             delta_pos.x = 0.;
@@ -273,13 +277,20 @@ impl ScreenTransform {
         (self.bounds.width() / rw) / (self.bounds.height() / rh)
     }
 
-    pub fn set_aspect(&mut self, aspect: f64) {
-        let epsilon = 1e-5;
+    /// Sets the aspect ratio by either expanding the x-axis or contracting the y-axis.
+    pub fn set_aspect(&mut self, aspect: f64, preserve_y: bool) {
         let current_aspect = self.get_aspect();
-        if current_aspect < aspect - epsilon {
+
+        let epsilon = 1e-5;
+        if (current_aspect - aspect).abs() < epsilon {
+            // Don't make any changes when the aspect is already almost correct.
+            return;
+        }
+
+        if preserve_y {
             self.bounds
                 .expand_x((aspect / current_aspect - 1.0) * self.bounds.width() * 0.5);
-        } else if current_aspect > aspect + epsilon {
+        } else {
             self.bounds
                 .expand_y((current_aspect / aspect - 1.0) * self.bounds.height() * 0.5);
         }
diff --git a/egui/src/widgets/progress_bar.rs b/egui/src/widgets/progress_bar.rs
index 9c74f473..c89f1002 100644
--- a/egui/src/widgets/progress_bar.rs
+++ b/egui/src/widgets/progress_bar.rs
@@ -77,10 +77,10 @@ impl Widget for ProgressBar {
             }
 
             let visuals = ui.style().visuals.clone();
-            let corner_radius = outer_rect.height() / 2.0;
+            let rounding = outer_rect.height() / 2.0;
             ui.painter().rect(
                 outer_rect,
-                corner_radius,
+                rounding,
                 visuals.extreme_bg_color,
                 Stroke::none(),
             );
@@ -101,7 +101,7 @@ impl Widget for ProgressBar {
 
             ui.painter().rect(
                 inner_rect,
-                corner_radius,
+                rounding,
                 Color32::from(Rgba::from(visuals.selection.bg_fill) * color_factor as f32),
                 Stroke::none(),
             );
@@ -110,14 +110,14 @@ impl Widget for ProgressBar {
                 let n_points = 20;
                 let start_angle = ui.input().time as f64 * 360f64.to_radians();
                 let end_angle = start_angle + 240f64.to_radians() * ui.input().time.sin();
-                let circle_radius = corner_radius - 2.0;
+                let circle_radius = rounding - 2.0;
                 let points: Vec<Pos2> = (0..n_points)
                     .map(|i| {
                         let angle = lerp(start_angle..=end_angle, i as f64 / n_points as f64);
                         let (sin, cos) = angle.sin_cos();
                         inner_rect.right_center()
                             + circle_radius * vec2(cos as f32, sin as f32)
-                            + vec2(-corner_radius, 0.0)
+                            + vec2(-rounding, 0.0)
                     })
                     .collect();
                 ui.painter().add(Shape::line(
diff --git a/egui/src/widgets/selected_label.rs b/egui/src/widgets/selected_label.rs
index bf08b41c..2f2d49d2 100644
--- a/egui/src/widgets/selected_label.rs
+++ b/egui/src/widgets/selected_label.rs
@@ -64,9 +64,8 @@ impl Widget for SelectableLabel {
             if selected || response.hovered() || response.has_focus() {
                 let rect = rect.expand(visuals.expansion);
 
-                let corner_radius = 2.0;
                 ui.painter()
-                    .rect(rect, corner_radius, visuals.bg_fill, visuals.bg_stroke);
+                    .rect(rect, visuals.rounding, visuals.bg_fill, visuals.bg_stroke);
             }
 
             text.paint_with_visuals(ui.painter(), text_pos, &visuals);
diff --git a/egui/src/widgets/slider.rs b/egui/src/widgets/slider.rs
index 5f38a68c..dd32fccc 100644
--- a/egui/src/widgets/slider.rs
+++ b/egui/src/widgets/slider.rs
@@ -355,7 +355,7 @@ impl<'a> Slider<'a> {
             let visuals = ui.style().interact(response);
             ui.painter().add(epaint::RectShape {
                 rect: rail_rect,
-                corner_radius: ui.visuals().widgets.inactive.corner_radius,
+                rounding: ui.visuals().widgets.inactive.rounding,
                 fill: ui.visuals().widgets.inactive.bg_fill,
                 // fill: visuals.bg_fill,
                 // fill: ui.visuals().extreme_bg_color,
@@ -466,10 +466,8 @@ impl<'a> Slider<'a> {
     }
 
     fn add_contents(&mut self, ui: &mut Ui) -> Response {
-        let text_style = TextStyle::Button;
         let perpendicular = ui
-            .fonts()
-            .row_height(text_style)
+            .text_style_height(&TextStyle::Body)
             .at_least(ui.spacing().interact_size.y);
         let slider_response = self.allocate_slider_space(ui, perpendicular);
         self.slider_ui(ui, &slider_response);
diff --git a/egui/src/widgets/text_edit/builder.rs b/egui/src/widgets/text_edit/builder.rs
index 95d911ab..1c956633 100644
--- a/egui/src/widgets/text_edit/builder.rs
+++ b/egui/src/widgets/text_edit/builder.rs
@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use epaint::mutex::Arc;
 
 use epaint::text::{cursor::*, Galley, LayoutJob};
 
@@ -8,7 +8,7 @@ use super::{CCursorRange, CursorRange, TextEditOutput, TextEditState};
 
 /// A text region that the user can edit the contents of.
 ///
-/// See also [`Ui::text_edit_singleline`] and  [`Ui::text_edit_multiline`].
+/// See also [`Ui::text_edit_singleline`] and [`Ui::text_edit_multiline`].
 ///
 /// Example:
 ///
@@ -52,11 +52,12 @@ pub struct TextEdit<'t> {
     hint_text: WidgetText,
     id: Option<Id>,
     id_source: Option<Id>,
-    text_style: Option<TextStyle>,
+    font_selection: FontSelection,
     text_color: Option<Color32>,
     layouter: Option<&'t mut dyn FnMut(&Ui, &str, f32) -> Arc<Galley>>,
     password: bool,
     frame: bool,
+    margin: Vec2,
     multiline: bool,
     interactive: bool,
     desired_width: Option<f32>,
@@ -96,11 +97,12 @@ impl<'t> TextEdit<'t> {
             hint_text: Default::default(),
             id: None,
             id_source: None,
-            text_style: None,
+            font_selection: Default::default(),
             text_color: None,
             layouter: None,
             password: false,
             frame: true,
+            margin: vec2(4.0, 2.0),
             multiline: true,
             interactive: true,
             desired_width: None,
@@ -115,7 +117,7 @@ impl<'t> TextEdit<'t> {
     /// - monospaced font
     /// - focus lock
     pub fn code_editor(self) -> Self {
-        self.text_style(TextStyle::Monospace).lock_focus(true)
+        self.font(TextStyle::Monospace).lock_focus(true)
     }
 
     /// Use if you want to set an explicit `Id` for this widget.
@@ -142,11 +144,17 @@ impl<'t> TextEdit<'t> {
         self
     }
 
-    pub fn text_style(mut self, text_style: TextStyle) -> Self {
-        self.text_style = Some(text_style);
+    /// Pick a [`FontId`] or [`TextStyle`].
+    pub fn font(mut self, font_selection: impl Into<FontSelection>) -> Self {
+        self.font_selection = font_selection.into();
         self
     }
 
+    #[deprecated = "Use .font(…) instead"]
+    pub fn text_style(self, text_style: TextStyle) -> Self {
+        self.font(text_style)
+    }
+
     pub fn text_color(mut self, text_color: Color32) -> Self {
         self.text_color = Some(text_color);
         self
@@ -200,6 +208,12 @@ impl<'t> TextEdit<'t> {
         self
     }
 
+    /// Set margin of text. Default is [4.0,2.0]
+    pub fn margin(mut self, margin: Vec2) -> Self {
+        self.margin = margin;
+        self
+    }
+
     /// Set to 0.0 to keep as small as possible.
     /// Set to [`f32::INFINITY`] to take up all available space (i.e. disable automatic word wrap).
     pub fn desired_width(mut self, desired_width: f32) -> Self {
@@ -264,7 +278,7 @@ impl<'t> TextEdit<'t> {
         let interactive = self.interactive;
         let where_to_put_background = ui.painter().add(Shape::Noop);
 
-        let margin = Vec2::new(4.0, 2.0);
+        let margin = self.margin;
         let max_rect = ui.available_rect_before_wrap().shrink2(margin);
         let mut content_ui = ui.child_ui(max_rect, *ui.layout());
         let mut output = self.show_content(&mut content_ui);
@@ -285,7 +299,7 @@ impl<'t> TextEdit<'t> {
                 if output.response.has_focus() {
                     epaint::RectShape {
                         rect: frame_rect,
-                        corner_radius: visuals.corner_radius,
+                        rounding: visuals.rounding,
                         // fill: ui.visuals().selection.bg_fill,
                         fill: ui.visuals().extreme_bg_color,
                         stroke: ui.visuals().selection.stroke,
@@ -293,7 +307,7 @@ impl<'t> TextEdit<'t> {
                 } else {
                     epaint::RectShape {
                         rect: frame_rect,
-                        corner_radius: visuals.corner_radius,
+                        rounding: visuals.rounding,
                         fill: ui.visuals().extreme_bg_color,
                         stroke: visuals.bg_stroke, // TODO: we want to show something here, or a text-edit field doesn't "pop".
                     }
@@ -302,7 +316,7 @@ impl<'t> TextEdit<'t> {
                 let visuals = &ui.style().visuals.widgets.inactive;
                 epaint::RectShape {
                     rect: frame_rect,
-                    corner_radius: visuals.corner_radius,
+                    rounding: visuals.rounding,
                     // fill: ui.visuals().extreme_bg_color,
                     // fill: visuals.bg_fill,
                     fill: Color32::TRANSPARENT,
@@ -322,11 +336,12 @@ impl<'t> TextEdit<'t> {
             hint_text,
             id,
             id_source,
-            text_style,
+            font_selection,
             text_color,
             layouter,
             password,
             frame: _,
+            margin: _,
             multiline,
             interactive,
             desired_width,
@@ -341,10 +356,9 @@ impl<'t> TextEdit<'t> {
             .unwrap_or_else(|| ui.visuals().widgets.inactive.text_color());
 
         let prev_text = text.as_ref().to_owned();
-        let text_style = text_style
-            .or(ui.style().override_text_style)
-            .unwrap_or_else(|| ui.style().body_text_style);
-        let row_height = ui.fonts().row_height(text_style);
+
+        let font_id = font_selection.resolve(ui.style());
+        let row_height = ui.fonts().row_height(&font_id);
         const MIN_WIDTH: f32 = 24.0; // Never make a `TextEdit` more narrow than this.
         let available_width = ui.available_width().at_least(MIN_WIDTH);
         let desired_width = desired_width.unwrap_or_else(|| ui.spacing().text_edit_width);
@@ -354,12 +368,13 @@ impl<'t> TextEdit<'t> {
             desired_width.min(available_width)
         };
 
+        let font_id_clone = font_id.clone();
         let mut default_layouter = move |ui: &Ui, text: &str, wrap_width: f32| {
             let text = mask_if_password(password, text);
             ui.fonts().layout_job(if multiline {
-                LayoutJob::simple(text, text_style, text_color, wrap_width)
+                LayoutJob::simple(text, font_id_clone.clone(), text_color, wrap_width)
             } else {
-                LayoutJob::simple_singleline(text, text_style, text_color)
+                LayoutJob::simple_singleline(text, font_id_clone.clone(), text_color)
             })
         };
 
@@ -390,7 +405,8 @@ impl<'t> TextEdit<'t> {
         // dragging select text, or scroll the enclosing `ScrollArea` (if any)?
         // Since currently copying selected text in not supported on `egui_web`,
         // we prioritize touch-scrolling:
-        let allow_drag_to_select = !ui.input().any_touches() || ui.memory().has_focus(id);
+        let any_touches = ui.input().any_touches(); // separate line to avoid double-locking the same mutex
+        let allow_drag_to_select = !any_touches || ui.memory().has_focus(id);
 
         let sense = if interactive {
             if allow_drag_to_select {
@@ -406,7 +422,7 @@ impl<'t> TextEdit<'t> {
         let painter = ui.painter_at(text_clip_rect);
 
         if interactive {
-            if let Some(pointer_pos) = ui.input().pointer.interact_pos() {
+            if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
                 if response.hovered() && text.is_mutable() {
                     ui.output().mutable_text_under_cursor = true;
                 }
@@ -533,9 +549,9 @@ impl<'t> TextEdit<'t> {
             if text.as_ref().is_empty() && !hint_text.is_empty() {
                 let hint_text_color = ui.visuals().weak_text_color();
                 let galley = if multiline {
-                    hint_text.into_galley(ui, Some(true), desired_size.x, text_style)
+                    hint_text.into_galley(ui, Some(true), desired_size.x, font_id)
                 } else {
-                    hint_text.into_galley(ui, Some(false), f32::INFINITY, text_style)
+                    hint_text.into_galley(ui, Some(false), f32::INFINITY, font_id)
                 };
                 galley.paint_with_fallback_color(&painter, response.rect.min, hint_text_color);
             }
@@ -665,7 +681,8 @@ fn events(
 
     let mut any_change = false;
 
-    for event in &ui.input().events {
+    let events = ui.input().events.clone(); // avoid dead-lock by cloning. TODO: optimize
+    for event in &events {
         let did_mutate_text = match event {
             Event::Copy => {
                 if cursor_range.is_empty() {
@@ -684,6 +701,15 @@ fn events(
                     Some(CCursorRange::one(delete_selected(text, &cursor_range)))
                 }
             }
+            Event::Paste(text_to_insert) => {
+                if !text_to_insert.is_empty() {
+                    let mut ccursor = delete_selected(text, &cursor_range);
+                    insert_text(&mut ccursor, text, text_to_insert);
+                    Some(CCursorRange::one(ccursor))
+                } else {
+                    None
+                }
+            }
             Event::Text(text_to_insert) => {
                 // Newlines are handled by `Key::Enter`.
                 if !text_to_insert.is_empty() && text_to_insert != "\n" && text_to_insert != "\r" {
diff --git a/egui/src/widgets/text_edit/state.rs b/egui/src/widgets/text_edit/state.rs
index 3319c7ad..d196d4b9 100644
--- a/egui/src/widgets/text_edit/state.rs
+++ b/egui/src/widgets/text_edit/state.rs
@@ -34,11 +34,11 @@ pub struct TextEditState {
 
 impl TextEditState {
     pub fn load(ctx: &Context, id: Id) -> Option<Self> {
-        ctx.memory().data.get_persisted(id)
+        ctx.data().get_persisted(id)
     }
 
     pub fn store(self, ctx: &Context, id: Id) {
-        ctx.memory().data.insert_persisted(id, self);
+        ctx.data().insert_persisted(id, self);
     }
 
     /// The the currently selected range of characters.
diff --git a/egui_demo_app/Cargo.toml b/egui_demo_app/Cargo.toml
index 982faa5b..2f23c079 100644
--- a/egui_demo_app/Cargo.toml
+++ b/egui_demo_app/Cargo.toml
@@ -7,9 +7,21 @@ edition = "2021"
 rust-version = "1.56"
 publish = false
 
+[package.metadata.docs.rs]
+all-features = true
+
 [lib]
 crate-type = ["cdylib", "rlib"]
 
+
+[features]
+default = ["persistence"]
+http = ["egui_demo_lib/http"]
+persistence = ["eframe/persistence", "egui_demo_lib/persistence"]
+screen_reader = ["eframe/screen_reader"] # experimental
+syntax_highlighting = ["egui_demo_lib/syntax_highlighting"]
+
+
 [dependencies]
 eframe = { version = "0.16.0", path = "../eframe" }
 
@@ -17,10 +29,4 @@ eframe = { version = "0.16.0", path = "../eframe" }
 # eframe = { version = "0.16.0", path = "../eframe", default-features = false, features = ["default_fonts", "egui_glium"] }
 
 egui_demo_lib = { version = "0.16.0", path = "../egui_demo_lib", features = ["extra_debug_asserts"] }
-
-[features]
-default = ["persistence"]
-http = ["egui_demo_lib/http"]
-persistence = ["eframe/persistence", "egui_demo_lib/persistence"]
-screen_reader = ["eframe/screen_reader"] # experimental
-syntax_highlighting = ["egui_demo_lib/syntax_highlighting"]
+tracing-subscriber = "0.3"
diff --git a/egui_demo_app/src/main.rs b/egui_demo_app/src/main.rs
index 75e36cdf..1ad429b9 100644
--- a/egui_demo_app/src/main.rs
+++ b/egui_demo_app/src/main.rs
@@ -7,10 +7,13 @@
 
 // When compiling natively:
 fn main() {
+    // Log to stdout (if you run with `RUST_LOG=debug`).
+    tracing_subscriber::fmt::init();
+
     let app = egui_demo_lib::WrapApp::default();
     let options = eframe::NativeOptions {
         // Let's show off that we support transparent windows
-        // transparent: true,
+        transparent: true,
         drag_and_drop_support: true,
         ..Default::default()
     };
diff --git a/egui_demo_lib/Cargo.toml b/egui_demo_lib/Cargo.toml
index 86a209be..0fa34100 100644
--- a/egui_demo_lib/Cargo.toml
+++ b/egui_demo_lib/Cargo.toml
@@ -18,22 +18,43 @@ all-features = true
 
 [lib]
 
+
+[features]
+default = ["datetime"]
+
+# Enable additional checks if debug assertions are enabled (debug builds).
+extra_debug_asserts = ["egui/extra_debug_asserts"]
+# Always enable additional checks.
+extra_asserts = ["egui/extra_asserts"]
+
+datetime = ["egui_extras/chrono", "chrono"]
+http = ["ehttp", "image", "poll-promise"]
+persistence = [
+  "egui/persistence",
+  "epi/persistence",
+  "egui_extras/persistence",
+  "serde",
+]
+serialize = ["egui/serialize", "serde"]
+syntax_highlighting = ["syntect"]
+
+
 [dependencies]
 egui = { version = "0.16.0", path = "../egui", default-features = false }
 epi = { version = "0.16.0", path = "../epi" }
 egui_extras = { version = "0.16.0", path = "../egui_extras" }
 
 chrono = { version = "0.4", features = ["js-sys", "wasmbind"], optional = true }
-enum-map = { version = "1", features = ["serde"] }
+enum-map = { version = "2", features = ["serde"] }
 unicode_names2 = { version = "0.4.0", default-features = false }
 
 # feature "http":
-ehttp = { version = "0.1.0", optional = true }
-image = { version = "0.23", default-features = false, features = [
+ehttp = { version = "0.2.0", optional = true }
+image = { version = "0.24", default-features = false, features = [
   "jpeg",
   "png",
 ], optional = true }
-
+poll-promise = { version = "0.1", default-features = false, optional = true }
 # feature "syntax_highlighting":
 syntect = { version = "4", default-features = false, features = [
   "default-fancy",
@@ -45,25 +66,6 @@ serde = { version = "1", features = ["derive"], optional = true }
 [dev-dependencies]
 criterion = { version = "0.3", default-features = false }
 
-[features]
-default = ["datetime"]
-datetime = ["egui_extras/datetime", "chrono"]
-
-# Enable additional checks if debug assertions are enabled (debug builds).
-extra_debug_asserts = ["egui/extra_debug_asserts"]
-# Always enable additional checks.
-extra_asserts = ["egui/extra_asserts"]
-
-http = ["ehttp", "image"]
-persistence = [
-  "egui/persistence",
-  "epi/persistence",
-  "egui_extras/persistence",
-  "serde",
-]
-serialize = ["egui/serialize", "serde"]
-syntax_highlighting = ["syntect"]
-
 [[bench]]
 name = "benchmark"
 harness = false
diff --git a/egui_demo_lib/benches/benchmark.rs b/egui_demo_lib/benches/benchmark.rs
index 97eb7f4b..584afb75 100644
--- a/egui_demo_lib/benches/benchmark.rs
+++ b/egui_demo_lib/benches/benchmark.rs
@@ -4,16 +4,16 @@ use egui::epaint::TextShape;
 use egui_demo_lib::LOREM_IPSUM_LONG;
 
 pub fn criterion_benchmark(c: &mut Criterion) {
-    let raw_input = egui::RawInput::default();
+    use egui::RawInput;
 
     {
-        let mut ctx = egui::CtxRef::default();
+        let ctx = egui::Context::default();
         let mut demo_windows = egui_demo_lib::DemoWindows::default();
 
         // The most end-to-end benchmark.
         c.bench_function("demo_with_tessellate__realistic", |b| {
             b.iter(|| {
-                let (_output, shapes) = ctx.run(raw_input.clone(), |ctx| {
+                let (_output, shapes) = ctx.run(RawInput::default(), |ctx| {
                     demo_windows.ui(ctx);
                 });
                 ctx.tessellate(shapes)
@@ -22,13 +22,13 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
         c.bench_function("demo_no_tessellate", |b| {
             b.iter(|| {
-                ctx.run(raw_input.clone(), |ctx| {
+                ctx.run(RawInput::default(), |ctx| {
                     demo_windows.ui(ctx);
                 })
             })
         });
 
-        let (_output, shapes) = ctx.run(raw_input.clone(), |ctx| {
+        let (_output, shapes) = ctx.run(RawInput::default(), |ctx| {
             demo_windows.ui(ctx);
         });
         c.bench_function("demo_only_tessellate", |b| {
@@ -37,12 +37,12 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     }
 
     if false {
-        let mut ctx = egui::CtxRef::default();
+        let ctx = egui::Context::default();
         ctx.memory().set_everything_is_visible(true); // give us everything
         let mut demo_windows = egui_demo_lib::DemoWindows::default();
         c.bench_function("demo_full_no_tessellate", |b| {
             b.iter(|| {
-                ctx.run(raw_input.clone(), |ctx| {
+                ctx.run(RawInput::default(), |ctx| {
                     demo_windows.ui(ctx);
                 })
             })
@@ -50,8 +50,8 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     }
 
     {
-        let mut ctx = egui::CtxRef::default();
-        let _ = ctx.run(raw_input, |ctx| {
+        let ctx = egui::Context::default();
+        let _ = ctx.run(RawInput::default(), |ctx| {
             egui::CentralPanel::default().show(ctx, |ui| {
                 c.bench_function("label &str", |b| {
                     b.iter(|| {
@@ -68,40 +68,68 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     }
 
     {
-        let pixels_per_point = 1.0;
-        let wrap_width = 512.0;
-        let text_style = egui::TextStyle::Body;
-        let color = egui::Color32::WHITE;
-        let fonts =
-            egui::epaint::text::Fonts::new(pixels_per_point, egui::FontDefinitions::default());
-        c.bench_function("text_layout_uncached", |b| {
-            b.iter(|| {
-                use egui::epaint::text::{layout, LayoutJob};
+        let ctx = egui::Context::default();
+        ctx.begin_frame(RawInput::default());
 
-                let job = LayoutJob::simple(
+        egui::CentralPanel::default().show(&ctx, |ui| {
+            c.bench_function("Painter::rect", |b| {
+                let painter = ui.painter();
+                let rect = ui.max_rect();
+                b.iter(|| {
+                    painter.rect(rect, 2.0, egui::Color32::RED, (1.0, egui::Color32::WHITE));
+                })
+            });
+        });
+
+        // Don't call `end_frame` to not have to drain the huge paint list
+    }
+
+    {
+        let pixels_per_point = 1.0;
+        let max_texture_side = 8 * 1024;
+        let wrap_width = 512.0;
+        let font_id = egui::FontId::default();
+        let color = egui::Color32::WHITE;
+        let fonts = egui::epaint::text::Fonts::new(
+            pixels_per_point,
+            max_texture_side,
+            egui::FontDefinitions::default(),
+        );
+        {
+            let mut locked_fonts = fonts.lock();
+            c.bench_function("text_layout_uncached", |b| {
+                b.iter(|| {
+                    use egui::epaint::text::{layout, LayoutJob};
+
+                    let job = LayoutJob::simple(
+                        LOREM_IPSUM_LONG.to_owned(),
+                        font_id.clone(),
+                        color,
+                        wrap_width,
+                    );
+                    layout(&mut locked_fonts.fonts, job.into())
+                })
+            });
+        }
+        c.bench_function("text_layout_cached", |b| {
+            b.iter(|| {
+                fonts.layout(
                     LOREM_IPSUM_LONG.to_owned(),
-                    egui::TextStyle::Body,
+                    font_id.clone(),
                     color,
                     wrap_width,
-                );
-                layout(&fonts, job.into())
+                )
             })
         });
-        c.bench_function("text_layout_cached", |b| {
-            b.iter(|| fonts.layout(LOREM_IPSUM_LONG.to_owned(), text_style, color, wrap_width))
-        });
 
-        let galley = fonts.layout(LOREM_IPSUM_LONG.to_owned(), text_style, color, wrap_width);
+        let galley = fonts.layout(LOREM_IPSUM_LONG.to_owned(), font_id, color, wrap_width);
         let mut tessellator = egui::epaint::Tessellator::from_options(Default::default());
         let mut mesh = egui::epaint::Mesh::default();
         let text_shape = TextShape::new(egui::Pos2::ZERO, galley);
+        let font_image_size = fonts.font_image_size();
         c.bench_function("tessellate_text", |b| {
             b.iter(|| {
-                tessellator.tessellate_text(
-                    fonts.font_image().size(),
-                    text_shape.clone(),
-                    &mut mesh,
-                );
+                tessellator.tessellate_text(font_image_size, text_shape.clone(), &mut mesh);
                 mesh.clear();
             })
         });
diff --git a/egui_demo_lib/src/apps/color_test.rs b/egui_demo_lib/src/apps/color_test.rs
index 231e68ca..f306e11a 100644
--- a/egui_demo_lib/src/apps/color_test.rs
+++ b/egui_demo_lib/src/apps/color_test.rs
@@ -34,7 +34,7 @@ impl epi::App for ColorTest {
         "🎨 Color test"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
         egui::CentralPanel::default().show(ctx, |ui| {
             if frame.is_web() {
                 ui.label(
@@ -43,14 +43,14 @@ impl epi::App for ColorTest {
                 ui.separator();
             }
             ScrollArea::both().auto_shrink([false; 2]).show(ui, |ui| {
-                self.ui(ui, Some(frame));
+                self.ui(ui);
             });
         });
     }
 }
 
 impl ColorTest {
-    pub fn ui(&mut self, ui: &mut Ui, tex_allocator: Option<&dyn epi::TextureAllocator>) {
+    pub fn ui(&mut self, ui: &mut Ui) {
         ui.set_max_width(680.0);
 
         ui.vertical_centered(|ui| {
@@ -70,13 +70,7 @@ impl ColorTest {
             ui.spacing_mut().item_spacing.y = 0.0; // No spacing between gradients
             let g = Gradient::one_color(Color32::from_rgb(255, 165, 0));
             self.vertex_gradient(ui, "orange rgb(255, 165, 0) - vertex", WHITE, &g);
-            self.tex_gradient(
-                ui,
-                tex_allocator,
-                "orange rgb(255, 165, 0) - texture",
-                WHITE,
-                &g,
-            );
+            self.tex_gradient(ui, "orange rgb(255, 165, 0) - texture", WHITE, &g);
         });
 
         ui.separator();
@@ -99,20 +93,18 @@ impl ColorTest {
             {
                 let g = Gradient::one_color(Color32::from(tex_color * vertex_color));
                 self.vertex_gradient(ui, "Ground truth (vertices)", WHITE, &g);
-                self.tex_gradient(ui, tex_allocator, "Ground truth (texture)", WHITE, &g);
-            }
-            if let Some(tex_allocator) = tex_allocator {
-                ui.horizontal(|ui| {
-                    let g = Gradient::one_color(Color32::from(tex_color));
-                    let tex = self.tex_mngr.get(tex_allocator, &g);
-                    let texel_offset = 0.5 / (g.0.len() as f32);
-                    let uv =
-                        Rect::from_min_max(pos2(texel_offset, 0.0), pos2(1.0 - texel_offset, 1.0));
-                    ui.add(Image::new(tex, GRADIENT_SIZE).tint(vertex_color).uv(uv))
-                        .on_hover_text(format!("A texture that is {} texels wide", g.0.len()));
-                    ui.label("GPU result");
-                });
+                self.tex_gradient(ui, "Ground truth (texture)", WHITE, &g);
             }
+
+            ui.horizontal(|ui| {
+                let g = Gradient::one_color(Color32::from(tex_color));
+                let tex = self.tex_mngr.get(ui.ctx(), &g);
+                let texel_offset = 0.5 / (g.0.len() as f32);
+                let uv = Rect::from_min_max(pos2(texel_offset, 0.0), pos2(1.0 - texel_offset, 1.0));
+                ui.add(Image::new(tex, GRADIENT_SIZE).tint(vertex_color).uv(uv))
+                    .on_hover_text(format!("A texture that is {} texels wide", g.0.len()));
+                ui.label("GPU result");
+            });
         });
 
         ui.separator();
@@ -120,18 +112,18 @@ impl ColorTest {
         // TODO: test color multiplication (image tint),
         // to make sure vertex and texture color multiplication is done in linear space.
 
-        self.show_gradients(ui, tex_allocator, WHITE, (RED, GREEN));
+        self.show_gradients(ui, WHITE, (RED, GREEN));
         if self.srgb {
             ui.label("Notice the darkening in the center of the naive sRGB interpolation.");
         }
 
         ui.separator();
 
-        self.show_gradients(ui, tex_allocator, RED, (TRANSPARENT, GREEN));
+        self.show_gradients(ui, RED, (TRANSPARENT, GREEN));
 
         ui.separator();
 
-        self.show_gradients(ui, tex_allocator, WHITE, (TRANSPARENT, GREEN));
+        self.show_gradients(ui, WHITE, (TRANSPARENT, GREEN));
         if self.srgb {
             ui.label(
             "Notice how the linear blend stays green while the naive sRGBA interpolation looks gray in the middle.",
@@ -142,15 +134,14 @@ impl ColorTest {
 
         // TODO: another ground truth where we do the alpha-blending against the background also.
         // TODO: exactly the same thing, but with vertex colors (no textures)
-        self.show_gradients(ui, tex_allocator, WHITE, (TRANSPARENT, BLACK));
+        self.show_gradients(ui, WHITE, (TRANSPARENT, BLACK));
         ui.separator();
-        self.show_gradients(ui, tex_allocator, BLACK, (TRANSPARENT, WHITE));
+        self.show_gradients(ui, BLACK, (TRANSPARENT, WHITE));
         ui.separator();
 
         ui.label("Additive blending: add more and more blue to the red background:");
         self.show_gradients(
             ui,
-            tex_allocator,
             RED,
             (TRANSPARENT, Color32::from_rgb_additive(0, 0, 255)),
         );
@@ -160,13 +151,7 @@ impl ColorTest {
         pixel_test(ui);
     }
 
-    fn show_gradients(
-        &mut self,
-        ui: &mut Ui,
-        tex_allocator: Option<&dyn epi::TextureAllocator>,
-        bg_fill: Color32,
-        (left, right): (Color32, Color32),
-    ) {
+    fn show_gradients(&mut self, ui: &mut Ui, bg_fill: Color32, (left, right): (Color32, Color32)) {
         let is_opaque = left.is_opaque() && right.is_opaque();
 
         ui.horizontal(|ui| {
@@ -186,13 +171,7 @@ impl ColorTest {
             if is_opaque {
                 let g = Gradient::ground_truth_linear_gradient(left, right);
                 self.vertex_gradient(ui, "Ground Truth (CPU gradient) - vertices", bg_fill, &g);
-                self.tex_gradient(
-                    ui,
-                    tex_allocator,
-                    "Ground Truth (CPU gradient) - texture",
-                    bg_fill,
-                    &g,
-                );
+                self.tex_gradient(ui, "Ground Truth (CPU gradient) - texture", bg_fill, &g);
             } else {
                 let g = Gradient::ground_truth_linear_gradient(left, right).with_bg_fill(bg_fill);
                 self.vertex_gradient(
@@ -203,20 +182,13 @@ impl ColorTest {
                 );
                 self.tex_gradient(
                     ui,
-                    tex_allocator,
                     "Ground Truth (CPU gradient, CPU blending) - texture",
                     bg_fill,
                     &g,
                 );
                 let g = Gradient::ground_truth_linear_gradient(left, right);
                 self.vertex_gradient(ui, "CPU gradient, GPU blending - vertices", bg_fill, &g);
-                self.tex_gradient(
-                    ui,
-                    tex_allocator,
-                    "CPU gradient, GPU blending - texture",
-                    bg_fill,
-                    &g,
-                );
+                self.tex_gradient(ui, "CPU gradient, GPU blending - texture", bg_fill, &g);
             }
 
             let g = Gradient::texture_gradient(left, right);
@@ -226,13 +198,7 @@ impl ColorTest {
                 bg_fill,
                 &g,
             );
-            self.tex_gradient(
-                ui,
-                tex_allocator,
-                "Texture of width 2 (test texture sampler)",
-                bg_fill,
-                &g,
-            );
+            self.tex_gradient(ui, "Texture of width 2 (test texture sampler)", bg_fill, &g);
 
             if self.srgb {
                 let g =
@@ -243,41 +209,26 @@ impl ColorTest {
                     bg_fill,
                     &g,
                 );
-                self.tex_gradient(
-                    ui,
-                    tex_allocator,
-                    "Naive sRGBA interpolation (WRONG)",
-                    bg_fill,
-                    &g,
-                );
+                self.tex_gradient(ui, "Naive sRGBA interpolation (WRONG)", bg_fill, &g);
             }
         });
     }
 
-    fn tex_gradient(
-        &mut self,
-        ui: &mut Ui,
-        tex_allocator: Option<&dyn epi::TextureAllocator>,
-        label: &str,
-        bg_fill: Color32,
-        gradient: &Gradient,
-    ) {
+    fn tex_gradient(&mut self, ui: &mut Ui, label: &str, bg_fill: Color32, gradient: &Gradient) {
         if !self.texture_gradients {
             return;
         }
-        if let Some(tex_allocator) = tex_allocator {
-            ui.horizontal(|ui| {
-                let tex = self.tex_mngr.get(tex_allocator, gradient);
-                let texel_offset = 0.5 / (gradient.0.len() as f32);
-                let uv = Rect::from_min_max(pos2(texel_offset, 0.0), pos2(1.0 - texel_offset, 1.0));
-                ui.add(Image::new(tex, GRADIENT_SIZE).bg_fill(bg_fill).uv(uv))
-                    .on_hover_text(format!(
-                        "A texture that is {} texels wide",
-                        gradient.0.len()
-                    ));
-                ui.label(label);
-            });
-        }
+        ui.horizontal(|ui| {
+            let tex = self.tex_mngr.get(ui.ctx(), gradient);
+            let texel_offset = 0.5 / (gradient.0.len() as f32);
+            let uv = Rect::from_min_max(pos2(texel_offset, 0.0), pos2(1.0 - texel_offset, 1.0));
+            ui.add(Image::new(tex, GRADIENT_SIZE).bg_fill(bg_fill).uv(uv))
+                .on_hover_text(format!(
+                    "A texture that is {} texels wide",
+                    gradient.0.len()
+                ));
+            ui.label(label);
+        });
     }
 
     fn vertex_gradient(&mut self, ui: &mut Ui, label: &str, bg_fill: Color32, gradient: &Gradient) {
@@ -384,18 +335,21 @@ impl Gradient {
 }
 
 #[derive(Default)]
-struct TextureManager(HashMap<Gradient, TextureId>);
+struct TextureManager(HashMap<Gradient, TextureHandle>);
 
 impl TextureManager {
-    fn get(&mut self, tex_allocator: &dyn epi::TextureAllocator, gradient: &Gradient) -> TextureId {
-        *self.0.entry(gradient.clone()).or_insert_with(|| {
+    fn get(&mut self, ctx: &egui::Context, gradient: &Gradient) -> &TextureHandle {
+        self.0.entry(gradient.clone()).or_insert_with(|| {
             let pixels = gradient.to_pixel_row();
             let width = pixels.len();
             let height = 1;
-            tex_allocator.alloc(epi::Image {
-                size: [width, height],
-                pixels,
-            })
+            ctx.load_texture(
+                "color_test_gradient",
+                epaint::ColorImage {
+                    size: [width, height],
+                    pixels,
+                },
+            )
         })
     }
 }
diff --git a/egui_demo_lib/src/apps/demo/app.rs b/egui_demo_lib/src/apps/demo/app.rs
index 2ba8e34b..063f29e7 100644
--- a/egui_demo_lib/src/apps/demo/app.rs
+++ b/egui_demo_lib/src/apps/demo/app.rs
@@ -16,7 +16,7 @@ impl epi::App for DemoApp {
 
     fn setup(
         &mut self,
-        _ctx: &egui::CtxRef,
+        _ctx: &egui::Context,
         _frame: &epi::Frame,
         _storage: Option<&dyn epi::Storage>,
     ) {
@@ -31,7 +31,7 @@ impl epi::App for DemoApp {
         epi::set_value(storage, epi::APP_KEY, self);
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, _frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, _frame: &epi::Frame) {
         self.demo_windows.ui(ctx);
     }
 }
diff --git a/egui_demo_lib/src/apps/demo/code_editor.rs b/egui_demo_lib/src/apps/demo/code_editor.rs
index ebc8e57b..107d66b8 100644
--- a/egui_demo_lib/src/apps/demo/code_editor.rs
+++ b/egui_demo_lib/src/apps/demo/code_editor.rs
@@ -26,7 +26,7 @@ impl super::Demo for CodeEditor {
         "🖮 Code Editor"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         use super::View as _;
         egui::Window::new(self.name())
             .open(open)
@@ -71,7 +71,7 @@ impl super::View for CodeEditor {
         ui.collapsing("Theme", |ui| {
             ui.group(|ui| {
                 theme.ui(ui);
-                theme.store_in_memory(ui.ctx());
+                theme.clone().store_in_memory(ui.ctx());
             });
         });
 
@@ -85,7 +85,7 @@ impl super::View for CodeEditor {
         egui::ScrollArea::vertical().show(ui, |ui| {
             ui.add(
                 egui::TextEdit::multiline(code)
-                    .text_style(egui::TextStyle::Monospace) // for cursor height
+                    .font(egui::TextStyle::Monospace) // for cursor height
                     .code_editor()
                     .desired_rows(10)
                     .lock_focus(true)
diff --git a/egui_demo_lib/src/apps/demo/code_example.rs b/egui_demo_lib/src/apps/demo/code_example.rs
index 8ba88c29..5c62e606 100644
--- a/egui_demo_lib/src/apps/demo/code_example.rs
+++ b/egui_demo_lib/src/apps/demo/code_example.rs
@@ -68,7 +68,7 @@ impl super::Demo for CodeExample {
         "🖮 Code Example"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         use super::View;
         egui::Window::new(self.name())
             .open(open)
@@ -98,7 +98,8 @@ impl CodeExample {
         );
 
         ui.horizontal(|ui| {
-            let indentation = 8.0 * ui.fonts()[egui::TextStyle::Monospace].glyph_width(' ');
+            let font_id = egui::TextStyle::Monospace.resolve(ui.style());
+            let indentation = 8.0 * ui.fonts().glyph_width(&font_id, ' ');
             let item_spacing = ui.spacing_mut().item_spacing;
             ui.add_space(indentation - item_spacing.x);
 
diff --git a/egui_demo_lib/src/apps/demo/context_menu.rs b/egui_demo_lib/src/apps/demo/context_menu.rs
index 732dbfcd..bd812365 100644
--- a/egui_demo_lib/src/apps/demo/context_menu.rs
+++ b/egui_demo_lib/src/apps/demo/context_menu.rs
@@ -47,7 +47,7 @@ impl super::Demo for ContextMenus {
         "☰ Context Menus"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         use super::View;
         egui::Window::new(self.name())
             .vscroll(false)
diff --git a/egui_demo_lib/src/apps/demo/dancing_strings.rs b/egui_demo_lib/src/apps/demo/dancing_strings.rs
index cebdd6ad..afd04dc3 100644
--- a/egui_demo_lib/src/apps/demo/dancing_strings.rs
+++ b/egui_demo_lib/src/apps/demo/dancing_strings.rs
@@ -10,7 +10,7 @@ impl super::Demo for DancingStrings {
         "♫ Dancing Strings"
     }
 
-    fn show(&mut self, ctx: &CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
         use super::View as _;
         Window::new(self.name())
             .open(open)
diff --git a/egui_demo_lib/src/apps/demo/demo_app_windows.rs b/egui_demo_lib/src/apps/demo/demo_app_windows.rs
index c59ca9c2..cd4fdfcc 100644
--- a/egui_demo_lib/src/apps/demo/demo_app_windows.rs
+++ b/egui_demo_lib/src/apps/demo/demo_app_windows.rs
@@ -1,5 +1,5 @@
 use super::Demo;
-use egui::{CtxRef, ScrollArea, Ui};
+use egui::{Context, ScrollArea, Ui};
 use std::collections::BTreeSet;
 
 // ----------------------------------------------------------------------------
@@ -26,6 +26,7 @@ impl Default for Demos {
             Box::new(super::MiscDemoWindow::default()),
             Box::new(super::multi_touch::MultiTouch::default()),
             Box::new(super::painting::Painting::default()),
+            Box::new(super::paint_bezier::PaintBezier::default()),
             Box::new(super::plot_demo::PlotDemo::default()),
             Box::new(super::scrolling::Scrolling::default()),
             Box::new(super::sliders::Sliders::default()),
@@ -60,7 +61,7 @@ impl Demos {
         }
     }
 
-    pub fn windows(&mut self, ctx: &CtxRef) {
+    pub fn windows(&mut self, ctx: &Context) {
         let Self { demos, open } = self;
         for demo in demos {
             let mut is_open = open.contains(demo.name());
@@ -115,7 +116,7 @@ impl Tests {
         }
     }
 
-    pub fn windows(&mut self, ctx: &CtxRef) {
+    pub fn windows(&mut self, ctx: &Context) {
         let Self { demos, open } = self;
         for demo in demos {
             let mut is_open = open.contains(demo.name());
@@ -151,7 +152,7 @@ pub struct DemoWindows {
 impl DemoWindows {
     /// Show the app ui (menu bar and windows).
     /// `sidebar_ui` can be used to optionally show some things in the sidebar
-    pub fn ui(&mut self, ctx: &CtxRef) {
+    pub fn ui(&mut self, ctx: &Context) {
         let Self { demos, tests } = self;
 
         egui::SidePanel::right("egui_demo_panel")
@@ -216,7 +217,7 @@ impl DemoWindows {
     }
 
     /// Show the open windows.
-    fn windows(&mut self, ctx: &CtxRef) {
+    fn windows(&mut self, ctx: &Context) {
         let Self { demos, tests } = self;
 
         demos.windows(ctx);
diff --git a/egui_demo_lib/src/apps/demo/drag_and_drop.rs b/egui_demo_lib/src/apps/demo/drag_and_drop.rs
index 99dc2d30..a44c48be 100644
--- a/egui_demo_lib/src/apps/demo/drag_and_drop.rs
+++ b/egui_demo_lib/src/apps/demo/drag_and_drop.rs
@@ -25,7 +25,7 @@ pub fn drag_source(ui: &mut Ui, id: Id, body: impl FnOnce(&mut Ui)) {
         // (anything with `Order::Tooltip` always gets an empty `Response`)
         // So this is fine!
 
-        if let Some(pointer_pos) = ui.input().pointer.interact_pos() {
+        if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
             let delta = pointer_pos - response.rect.center();
             ui.ctx().translate_layer(layer_id, delta);
         }
@@ -66,7 +66,7 @@ pub fn drop_target<R>(
     ui.painter().set(
         where_to_put_background,
         epaint::RectShape {
-            corner_radius: style.corner_radius,
+            rounding: style.rounding,
             fill,
             stroke,
             rect,
@@ -101,7 +101,7 @@ impl super::Demo for DragAndDropDemo {
         "✋ Drag and Drop"
     }
 
-    fn show(&mut self, ctx: &CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
         use super::View as _;
         Window::new(self.name())
             .open(open)
diff --git a/egui_demo_lib/src/apps/demo/font_book.rs b/egui_demo_lib/src/apps/demo/font_book.rs
index 638e1aa7..3a5a2ef6 100644
--- a/egui_demo_lib/src/apps/demo/font_book.rs
+++ b/egui_demo_lib/src/apps/demo/font_book.rs
@@ -2,15 +2,15 @@ use std::collections::BTreeMap;
 
 pub struct FontBook {
     filter: String,
-    text_style: egui::TextStyle,
-    named_chars: BTreeMap<egui::TextStyle, BTreeMap<char, String>>,
+    font_id: egui::FontId,
+    named_chars: BTreeMap<egui::FontFamily, BTreeMap<char, String>>,
 }
 
 impl Default for FontBook {
     fn default() -> Self {
         Self {
             filter: Default::default(),
-            text_style: egui::TextStyle::Button,
+            font_id: egui::FontId::proportional(20.0),
             named_chars: Default::default(),
         }
     }
@@ -21,7 +21,7 @@ impl super::Demo for FontBook {
         "🔤 Font Book"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name()).open(open).show(ctx, |ui| {
             use super::View as _;
             self.ui(ui);
@@ -34,7 +34,7 @@ impl super::View for FontBook {
         ui.label(format!(
             "The selected font supports {} characters.",
             self.named_chars
-                .get(&self.text_style)
+                .get(&self.font_id.family)
                 .map(|map| map.len())
                 .unwrap_or_default()
         ));
@@ -51,13 +51,7 @@ impl super::View for FontBook {
 
         ui.separator();
 
-        egui::ComboBox::from_label("Text style")
-            .selected_text(format!("{:?}", self.text_style))
-            .show_ui(ui, |ui| {
-                for style in egui::TextStyle::all() {
-                    ui.selectable_value(&mut self.text_style, style, format!("{:?}", style));
-                }
-            });
+        egui::introspection::font_id_ui(ui, &mut self.font_id);
 
         ui.horizontal(|ui| {
             ui.label("Filter:");
@@ -68,16 +62,11 @@ impl super::View for FontBook {
             }
         });
 
-        let text_style = self.text_style;
         let filter = &self.filter;
-        let named_chars = self.named_chars.entry(text_style).or_insert_with(|| {
-            ui.fonts()[text_style]
-                .characters()
-                .iter()
-                .filter(|chr| !chr.is_whitespace() && !chr.is_ascii_control())
-                .map(|&chr| (chr, char_name(chr)))
-                .collect()
-        });
+        let named_chars = self
+            .named_chars
+            .entry(self.font_id.family.clone())
+            .or_insert_with(|| available_characters(ui, self.font_id.family.clone()));
 
         ui.separator();
 
@@ -88,12 +77,14 @@ impl super::View for FontBook {
                 for (&chr, name) in named_chars {
                     if filter.is_empty() || name.contains(filter) || *filter == chr.to_string() {
                         let button = egui::Button::new(
-                            egui::RichText::new(chr.to_string()).text_style(text_style),
+                            egui::RichText::new(chr.to_string()).font(self.font_id.clone()),
                         )
                         .frame(false);
 
                         let tooltip_ui = |ui: &mut egui::Ui| {
-                            ui.label(egui::RichText::new(chr.to_string()).text_style(text_style));
+                            ui.label(
+                                egui::RichText::new(chr.to_string()).font(self.font_id.clone()),
+                            );
                             ui.label(format!("{}\nU+{:X}\n\nClick to copy", name, chr as u32));
                         };
 
@@ -107,6 +98,18 @@ impl super::View for FontBook {
     }
 }
 
+fn available_characters(ui: &egui::Ui, family: egui::FontFamily) -> BTreeMap<char, String> {
+    ui.fonts()
+        .lock()
+        .fonts
+        .font(&egui::FontId::new(10.0, family)) // size is arbitrary for getting the characters
+        .characters()
+        .iter()
+        .filter(|chr| !chr.is_whitespace() && !chr.is_ascii_control())
+        .map(|&chr| (chr, char_name(chr)))
+        .collect()
+}
+
 fn char_name(chr: char) -> String {
     special_char_name(chr)
         .map(|s| s.to_owned())
diff --git a/egui_demo_lib/src/apps/demo/grid_demo.rs b/egui_demo_lib/src/apps/demo/grid_demo.rs
index 8487c315..7ffcb104 100644
--- a/egui_demo_lib/src/apps/demo/grid_demo.rs
+++ b/egui_demo_lib/src/apps/demo/grid_demo.rs
@@ -11,7 +11,7 @@ impl super::Demo for GridDemo {
         "▣ Grid Demo"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(true)
diff --git a/egui_demo_lib/src/apps/demo/layout_test.rs b/egui_demo_lib/src/apps/demo/layout_test.rs
index 35b37502..39fab0ea 100644
--- a/egui_demo_lib/src/apps/demo/layout_test.rs
+++ b/egui_demo_lib/src/apps/demo/layout_test.rs
@@ -76,7 +76,7 @@ impl super::Demo for LayoutTest {
         "Layout Test"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(false)
diff --git a/egui_demo_lib/src/apps/demo/misc_demo_window.rs b/egui_demo_lib/src/apps/demo/misc_demo_window.rs
index b430594e..f4e672ed 100644
--- a/egui_demo_lib/src/apps/demo/misc_demo_window.rs
+++ b/egui_demo_lib/src/apps/demo/misc_demo_window.rs
@@ -31,7 +31,7 @@ impl Demo for MiscDemoWindow {
         "✨ Misc Demos"
     }
 
-    fn show(&mut self, ctx: &CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
         Window::new(self.name())
             .open(open)
             .vscroll(true)
@@ -140,7 +140,8 @@ impl Widgets {
 
         ui.horizontal_wrapped(|ui| {
             // Trick so we don't have to add spaces in the text below:
-            ui.spacing_mut().item_spacing.x = ui.fonts()[TextStyle::Body].glyph_width(' ');
+            let width = ui.fonts().glyph_width(&TextStyle::Body.resolve(ui.style()), ' ');
+            ui.spacing_mut().item_spacing.x = width;
 
             ui.label(RichText::new("Text can have").color(Color32::from_rgb(110, 255, 110)));
             ui.colored_label(Color32::from_rgb(128, 140, 255), "color"); // Shortcut version
@@ -268,7 +269,7 @@ impl ColorWidgets {
 #[cfg_attr(feature = "serde", serde(default))]
 struct BoxPainting {
     size: Vec2,
-    corner_radius: f32,
+    rounding: f32,
     stroke_width: f32,
     num_boxes: usize,
 }
@@ -277,7 +278,7 @@ impl Default for BoxPainting {
     fn default() -> Self {
         Self {
             size: vec2(64.0, 32.0),
-            corner_radius: 5.0,
+            rounding: 5.0,
             stroke_width: 2.0,
             num_boxes: 1,
         }
@@ -288,7 +289,7 @@ impl BoxPainting {
     pub fn ui(&mut self, ui: &mut Ui) {
         ui.add(Slider::new(&mut self.size.x, 0.0..=500.0).text("width"));
         ui.add(Slider::new(&mut self.size.y, 0.0..=500.0).text("height"));
-        ui.add(Slider::new(&mut self.corner_radius, 0.0..=50.0).text("corner_radius"));
+        ui.add(Slider::new(&mut self.rounding, 0.0..=50.0).text("rounding"));
         ui.add(Slider::new(&mut self.stroke_width, 0.0..=10.0).text("stroke_width"));
         ui.add(Slider::new(&mut self.num_boxes, 0..=8).text("num_boxes"));
 
@@ -297,7 +298,7 @@ impl BoxPainting {
                 let (rect, _response) = ui.allocate_at_least(self.size, Sense::hover());
                 ui.painter().rect(
                     rect,
-                    self.corner_radius,
+                    self.rounding,
                     Color32::from_gray(64),
                     Stroke::new(self.stroke_width, Color32::WHITE),
                 );
@@ -417,7 +418,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "This is a demonstration of ",
         first_row_indentation,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             ..Default::default()
         },
@@ -426,7 +426,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "the egui text layout engine. ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: strong_color,
             ..Default::default()
         },
@@ -435,7 +434,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "It supports ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             ..Default::default()
         },
@@ -444,7 +442,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "different ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: Color32::from_rgb(110, 255, 110),
             ..Default::default()
         },
@@ -453,7 +450,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "colors, ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: Color32::from_rgb(128, 140, 255),
             ..Default::default()
         },
@@ -462,7 +458,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "backgrounds, ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             background: Color32::from_rgb(128, 32, 32),
             ..Default::default()
@@ -472,7 +467,7 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "mixing ",
         0.0,
         TextFormat {
-            style: TextStyle::Heading,
+            font_id: FontId::proportional(20.0),
             color: default_color,
             ..Default::default()
         },
@@ -481,7 +476,7 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "fonts, ",
         0.0,
         TextFormat {
-            style: TextStyle::Monospace,
+            font_id: FontId::monospace(14.0),
             color: default_color,
             ..Default::default()
         },
@@ -490,7 +485,7 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "raised text, ",
         0.0,
         TextFormat {
-            style: TextStyle::Small,
+            font_id: FontId::proportional(8.0),
             color: default_color,
             valign: Align::TOP,
             ..Default::default()
@@ -500,7 +495,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "with ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             ..Default::default()
         },
@@ -509,7 +503,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "underlining",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             underline: Stroke::new(1.0, Color32::LIGHT_BLUE),
             ..Default::default()
@@ -519,7 +512,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         " and ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             ..Default::default()
         },
@@ -528,7 +520,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "strikethrough",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             strikethrough: Stroke::new(2.0, Color32::RED.linear_multiply(0.5)),
             ..Default::default()
@@ -538,7 +529,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         ". Of course, ",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             ..Default::default()
         },
@@ -547,7 +537,6 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         "you can",
         0.0,
         TextFormat {
-            style: TextStyle::Body,
             color: default_color,
             strikethrough: Stroke::new(1.0, strong_color),
             ..Default::default()
@@ -557,7 +546,7 @@ fn text_layout_ui(ui: &mut egui::Ui) {
         " mix these!",
         0.0,
         TextFormat {
-            style: TextStyle::Small,
+            font_id: FontId::proportional(8.0),
             color: Color32::LIGHT_BLUE,
             background: Color32::from_rgb(128, 0, 0),
             underline: Stroke::new(1.0, strong_color),
diff --git a/egui_demo_lib/src/apps/demo/mod.rs b/egui_demo_lib/src/apps/demo/mod.rs
index ee9c6f5e..61ac4814 100644
--- a/egui_demo_lib/src/apps/demo/mod.rs
+++ b/egui_demo_lib/src/apps/demo/mod.rs
@@ -16,6 +16,7 @@ pub mod grid_demo;
 pub mod layout_test;
 pub mod misc_demo_window;
 pub mod multi_touch;
+pub mod paint_bezier;
 pub mod painting;
 pub mod password;
 pub mod plot_demo;
@@ -47,5 +48,5 @@ pub trait Demo {
     fn name(&self) -> &'static str;
 
     /// Show windows, etc
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool);
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool);
 }
diff --git a/egui_demo_lib/src/apps/demo/multi_touch.rs b/egui_demo_lib/src/apps/demo/multi_touch.rs
index 8c6a7292..0f154301 100644
--- a/egui_demo_lib/src/apps/demo/multi_touch.rs
+++ b/egui_demo_lib/src/apps/demo/multi_touch.rs
@@ -26,7 +26,7 @@ impl super::Demo for MultiTouch {
         "👌 Multi Touch"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .default_size(vec2(512.0, 512.0))
@@ -77,7 +77,7 @@ impl super::View for MultiTouch {
             // color and width:
             let mut stroke_width = 1.;
             let color = Color32::GRAY;
-            if let Some(multi_touch) = ui.input().multi_touch() {
+            if let Some(multi_touch) = ui.ctx().multi_touch() {
                 // This adjusts the current zoom factor and rotation angle according to the dynamic
                 // change (for the current frame) of the touch gesture:
                 self.zoom *= multi_touch.zoom_delta;
diff --git a/egui_demo_lib/src/apps/demo/paint_bezier.rs b/egui_demo_lib/src/apps/demo/paint_bezier.rs
new file mode 100644
index 00000000..3d1cc547
--- /dev/null
+++ b/egui_demo_lib/src/apps/demo/paint_bezier.rs
@@ -0,0 +1,254 @@
+use egui::emath::RectTransform;
+use egui::epaint::{CircleShape, CubicBezierShape, QuadraticBezierShape};
+use egui::*;
+
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct PaintBezier {
+    /// Current bezier curve degree, it can be 3, 4.
+    bezier: usize,
+    /// Track the bezier degree before change in order to clean the remaining points.
+    degree_backup: usize,
+    /// Points already clicked. once it reaches the 'bezier' degree, it will be pushed into the 'shapes'
+    points: Vec<Pos2>,
+    /// Track last points set in order to draw auxiliary lines.
+    backup_points: Vec<Pos2>,
+    /// Quadratic shapes already drawn.
+    q_shapes: Vec<QuadraticBezierShape>,
+    /// Cubic shapes already drawn.
+    /// Since `Shape` can't be 'serialized', we can't use Shape as variable type.
+    c_shapes: Vec<CubicBezierShape>,
+    /// Stroke for auxiliary lines.
+    aux_stroke: Stroke,
+    /// Stroke for bezier curve.
+    stroke: Stroke,
+    /// Fill for bezier curve.
+    fill: Color32,
+    /// The curve should be closed or not.
+    closed: bool,
+    /// Display the bounding box or not.
+    show_bounding_box: bool,
+    /// Storke for the bounding box.
+    bounding_box_stroke: Stroke,
+}
+
+impl Default for PaintBezier {
+    fn default() -> Self {
+        Self {
+            bezier: 4, // default bezier degree, a cubic bezier curve
+            degree_backup: 4,
+            points: Default::default(),
+            backup_points: Default::default(),
+            q_shapes: Default::default(),
+            c_shapes: Default::default(),
+            aux_stroke: Stroke::new(1.0, Color32::RED),
+            stroke: Stroke::new(1.0, Color32::LIGHT_BLUE),
+            fill: Default::default(),
+            closed: false,
+            show_bounding_box: false,
+            bounding_box_stroke: Stroke::new(1.0, Color32::LIGHT_GREEN),
+        }
+    }
+}
+
+impl PaintBezier {
+    pub fn ui_control(&mut self, ui: &mut egui::Ui) -> egui::Response {
+        ui.horizontal(|ui| {
+            ui.vertical(|ui| {
+                egui::stroke_ui(ui, &mut self.stroke, "Curve Stroke");
+                egui::stroke_ui(ui, &mut self.aux_stroke, "Auxiliary Stroke");
+                ui.horizontal(|ui| {
+                    ui.label("Fill Color:");
+                    if ui.color_edit_button_srgba(&mut self.fill).changed()
+                        && self.fill != Color32::TRANSPARENT
+                    {
+                        self.closed = true;
+                    }
+                    if ui.checkbox(&mut self.closed, "Closed").clicked() && !self.closed {
+                        self.fill = Color32::TRANSPARENT;
+                    }
+                });
+                egui::stroke_ui(ui, &mut self.bounding_box_stroke, "Bounding Box Stroke");
+            });
+
+            ui.separator();
+            ui.vertical(|ui| {
+                {
+                    let mut tessellation_options = *(ui.ctx().tessellation_options());
+                    let tessellation_options = &mut tessellation_options;
+                    tessellation_options.ui(ui);
+                    let mut new_tessellation_options = ui.ctx().tessellation_options();
+                    *new_tessellation_options = *tessellation_options;
+                }
+
+                ui.checkbox(&mut self.show_bounding_box, "Bounding Box");
+            });
+            ui.separator();
+            ui.vertical(|ui| {
+                if ui.radio_value(&mut self.bezier, 3, "Quadratic").clicked()
+                    && self.degree_backup != self.bezier
+                {
+                    self.points.clear();
+                    self.degree_backup = self.bezier;
+                };
+                if ui.radio_value(&mut self.bezier, 4, "Cubic").clicked()
+                    && self.degree_backup != self.bezier
+                {
+                    self.points.clear();
+                    self.degree_backup = self.bezier;
+                };
+                // ui.radio_value(self.bezier, 5, "Quintic");
+                ui.label("Click 3 or 4 points to build a bezier curve!");
+                if ui.button("Clear Painting").clicked() {
+                    self.points.clear();
+                    self.backup_points.clear();
+                    self.q_shapes.clear();
+                    self.c_shapes.clear();
+                }
+            })
+        })
+        .response
+    }
+
+    pub fn ui_content(&mut self, ui: &mut Ui) -> egui::Response {
+        let (mut response, painter) =
+            ui.allocate_painter(ui.available_size_before_wrap(), Sense::click());
+
+        let to_screen = emath::RectTransform::from_to(
+            Rect::from_min_size(Pos2::ZERO, response.rect.square_proportions()),
+            response.rect,
+        );
+        let from_screen = to_screen.inverse();
+
+        if response.clicked() {
+            if let Some(pointer_pos) = response.interact_pointer_pos() {
+                let canvas_pos = from_screen * pointer_pos;
+                self.points.push(canvas_pos);
+                if self.points.len() >= self.bezier {
+                    self.backup_points = self.points.clone();
+                    let points = self.points.drain(..).collect::<Vec<_>>();
+                    match points.len() {
+                        3 => {
+                            let quadratic = QuadraticBezierShape::from_points_stroke(
+                                points,
+                                self.closed,
+                                self.fill,
+                                self.stroke,
+                            );
+                            self.q_shapes.push(quadratic);
+                        }
+                        4 => {
+                            let cubic = CubicBezierShape::from_points_stroke(
+                                points,
+                                self.closed,
+                                self.fill,
+                                self.stroke,
+                            );
+                            self.c_shapes.push(cubic);
+                        }
+                        _ => {
+                            unreachable!();
+                        }
+                    }
+                }
+
+                response.mark_changed();
+            }
+        }
+        let mut shapes = Vec::new();
+        for shape in self.q_shapes.iter() {
+            shapes.push(shape.to_screen(&to_screen).into());
+            if self.show_bounding_box {
+                shapes.push(self.build_bounding_box(shape.bounding_rect(), &to_screen));
+            }
+        }
+        for shape in self.c_shapes.iter() {
+            shapes.push(shape.to_screen(&to_screen).into());
+            if self.show_bounding_box {
+                shapes.push(self.build_bounding_box(shape.bounding_rect(), &to_screen));
+            }
+        }
+        painter.extend(shapes);
+
+        if !self.points.is_empty() {
+            painter.extend(build_auxiliary_line(
+                &self.points,
+                &to_screen,
+                &self.aux_stroke,
+            ));
+        } else if !self.backup_points.is_empty() {
+            painter.extend(build_auxiliary_line(
+                &self.backup_points,
+                &to_screen,
+                &self.aux_stroke,
+            ));
+        }
+
+        response
+    }
+
+    pub fn build_bounding_box(&self, bbox: Rect, to_screen: &RectTransform) -> Shape {
+        let bbox = Rect {
+            min: to_screen * bbox.min,
+            max: to_screen * bbox.max,
+        };
+        let bbox_shape = epaint::RectShape::stroke(bbox, 0.0, self.bounding_box_stroke);
+        bbox_shape.into()
+    }
+}
+
+/// An internal function to create auxiliary lines around the current bezier curve
+/// or to auxiliary lines (points) before the points meet the bezier curve requirements.
+fn build_auxiliary_line(
+    points: &[Pos2],
+    to_screen: &RectTransform,
+    aux_stroke: &Stroke,
+) -> Vec<Shape> {
+    let mut shapes = Vec::new();
+    if points.len() >= 2 {
+        let points: Vec<Pos2> = points.iter().map(|p| to_screen * *p).collect();
+        shapes.push(egui::Shape::line(points, *aux_stroke));
+    }
+    for point in points.iter() {
+        let center = to_screen * *point;
+        let radius = aux_stroke.width * 3.0;
+        let circle = CircleShape {
+            center,
+            radius,
+            fill: aux_stroke.color,
+            stroke: *aux_stroke,
+        };
+
+        shapes.push(circle.into());
+    }
+
+    shapes
+}
+
+impl super::Demo for PaintBezier {
+    fn name(&self) -> &'static str {
+        "✔ Bezier Curve"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .default_size(vec2(512.0, 512.0))
+            .vscroll(false)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for PaintBezier {
+    fn ui(&mut self, ui: &mut Ui) {
+        // ui.vertical_centered(|ui| {
+        //     ui.add(crate::__egui_github_link_file!());
+        // });
+        self.ui_control(ui);
+
+        Frame::dark_canvas(ui.style()).show(ui, |ui| {
+            self.ui_content(ui);
+        });
+    }
+}
diff --git a/egui_demo_lib/src/apps/demo/painting.rs b/egui_demo_lib/src/apps/demo/painting.rs
index f445605b..2b76851e 100644
--- a/egui_demo_lib/src/apps/demo/painting.rs
+++ b/egui_demo_lib/src/apps/demo/painting.rs
@@ -74,7 +74,7 @@ impl super::Demo for Painting {
         "🖊 Painting"
     }
 
-    fn show(&mut self, ctx: &CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
         use super::View as _;
         Window::new(self.name())
             .open(open)
diff --git a/egui_demo_lib/src/apps/demo/password.rs b/egui_demo_lib/src/apps/demo/password.rs
index 7d2d573d..4a82cc84 100644
--- a/egui_demo_lib/src/apps/demo/password.rs
+++ b/egui_demo_lib/src/apps/demo/password.rs
@@ -19,7 +19,7 @@ pub fn password_ui(ui: &mut egui::Ui, password: &mut String) -> egui::Response {
 
     // Get state for this widget.
     // You should get state by value, not by reference to avoid borrowing of `Memory`.
-    let mut show_plaintext = ui.memory().data.get_temp::<bool>(state_id).unwrap_or(false);
+    let mut show_plaintext = ui.data().get_temp::<bool>(state_id).unwrap_or(false);
 
     // Process ui, change a local copy of the state
     // We want TextEdit to fill entire space, and have button after that, so in that case we can
@@ -42,7 +42,7 @@ pub fn password_ui(ui: &mut egui::Ui, password: &mut String) -> egui::Response {
     });
 
     // Store the (possibly changed) state:
-    ui.memory().data.insert_temp(state_id, show_plaintext);
+    ui.data().insert_temp(state_id, show_plaintext);
 
     // All done! Return the interaction response so the user can check what happened
     // (hovered, clicked, …) and maybe show a tooltip:
diff --git a/egui_demo_lib/src/apps/demo/plot_demo.rs b/egui_demo_lib/src/apps/demo/plot_demo.rs
index 6e060fe6..fb0ab761 100644
--- a/egui_demo_lib/src/apps/demo/plot_demo.rs
+++ b/egui_demo_lib/src/apps/demo/plot_demo.rs
@@ -71,8 +71,8 @@ impl LineDemo {
 
             ui.vertical(|ui| {
                 ui.style_mut().wrap = Some(false);
-                ui.checkbox(animate, "animate");
-                ui.checkbox(square, "square view")
+                ui.checkbox(animate, "Animate");
+                ui.checkbox(square, "Square view")
                     .on_hover_text("Always keep the viewport square.");
                 ui.checkbox(proportional, "Proportional data axes")
                     .on_hover_text("Tick are the same size on both axes.");
@@ -237,19 +237,11 @@ impl Widget for &mut MarkerDemo {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(Default, PartialEq)]
 struct LegendDemo {
     config: Legend,
 }
 
-impl Default for LegendDemo {
-    fn default() -> Self {
-        Self {
-            config: Legend::default(),
-        }
-    }
-}
-
 impl LegendDemo {
     fn line_with_slope(slope: f64) -> Line {
         Line::new(Values::from_explicit_callback(move |x| slope * x, .., 100))
@@ -269,9 +261,10 @@ impl Widget for &mut LegendDemo {
         egui::Grid::new("settings").show(ui, |ui| {
             ui.label("Text style:");
             ui.horizontal(|ui| {
-                TextStyle::all().for_each(|style| {
-                    ui.selectable_value(&mut config.text_style, style, format!("{:?}", style));
-                });
+                let all_text_styles = ui.style().text_styles();
+                for style in all_text_styles {
+                    ui.selectable_value(&mut config.text_style, style.clone(), style.to_string());
+                }
             });
             ui.end_row();
 
@@ -292,7 +285,9 @@ impl Widget for &mut LegendDemo {
             ui.end_row();
         });
 
-        let legend_plot = Plot::new("legend_demo").legend(*config).data_aspect(1.0);
+        let legend_plot = Plot::new("legend_demo")
+            .legend(config.clone())
+            .data_aspect(1.0);
         legend_plot
             .show(ui, |plot_ui| {
                 plot_ui.line(LegendDemo::line_with_slope(0.5).name("lines"));
@@ -305,10 +300,82 @@ impl Widget for &mut LegendDemo {
     }
 }
 
-#[derive(PartialEq, Default)]
-struct ItemsDemo {}
+#[derive(PartialEq)]
+struct LinkedAxisDemo {
+    link_x: bool,
+    link_y: bool,
+    group: plot::LinkedAxisGroup,
+}
 
-impl ItemsDemo {}
+impl Default for LinkedAxisDemo {
+    fn default() -> Self {
+        let link_x = true;
+        let link_y = false;
+        Self {
+            link_x,
+            link_y,
+            group: plot::LinkedAxisGroup::new(link_x, link_y),
+        }
+    }
+}
+
+impl LinkedAxisDemo {
+    fn line_with_slope(slope: f64) -> Line {
+        Line::new(Values::from_explicit_callback(move |x| slope * x, .., 100))
+    }
+    fn sin() -> Line {
+        Line::new(Values::from_explicit_callback(move |x| x.sin(), .., 100))
+    }
+    fn cos() -> Line {
+        Line::new(Values::from_explicit_callback(move |x| x.cos(), .., 100))
+    }
+
+    fn configure_plot(plot_ui: &mut plot::PlotUi) {
+        plot_ui.line(LinkedAxisDemo::line_with_slope(0.5));
+        plot_ui.line(LinkedAxisDemo::line_with_slope(1.0));
+        plot_ui.line(LinkedAxisDemo::line_with_slope(2.0));
+        plot_ui.line(LinkedAxisDemo::sin());
+        plot_ui.line(LinkedAxisDemo::cos());
+    }
+}
+
+impl Widget for &mut LinkedAxisDemo {
+    fn ui(self, ui: &mut Ui) -> Response {
+        ui.horizontal(|ui| {
+            ui.label("Linked axes:");
+            ui.checkbox(&mut self.link_x, "X");
+            ui.checkbox(&mut self.link_y, "Y");
+        });
+        self.group.set_link_x(self.link_x);
+        self.group.set_link_y(self.link_y);
+        ui.horizontal(|ui| {
+            Plot::new("linked_axis_1")
+                .data_aspect(1.0)
+                .width(250.0)
+                .height(250.0)
+                .link_axis(self.group.clone())
+                .show(ui, LinkedAxisDemo::configure_plot);
+            Plot::new("linked_axis_2")
+                .data_aspect(2.0)
+                .width(150.0)
+                .height(250.0)
+                .link_axis(self.group.clone())
+                .show(ui, LinkedAxisDemo::configure_plot);
+        });
+        Plot::new("linked_axis_3")
+            .data_aspect(0.5)
+            .width(250.0)
+            .height(150.0)
+            .link_axis(self.group.clone())
+            .show(ui, LinkedAxisDemo::configure_plot)
+            .response
+    }
+}
+
+#[derive(PartialEq, Default)]
+struct ItemsDemo {
+    texture: Option<egui::TextureHandle>,
+}
 
 impl Widget for &mut ItemsDemo {
     fn ui(self, ui: &mut Ui) -> Response {
@@ -343,13 +410,15 @@ impl Widget for &mut ItemsDemo {
             );
             Arrows::new(arrow_origins, arrow_tips)
         };
+
+        let texture: &egui::TextureHandle = self.texture.get_or_insert_with(|| {
+            ui.ctx()
+                .load_texture("plot_demo", egui::ColorImage::example())
+        });
         let image = PlotImage::new(
-            TextureId::Egui,
+            texture,
             Value::new(0.0, 10.0),
-            [
-                ui.fonts().font_image().width as f32 / 100.0,
-                ui.fonts().font_image().height as f32 / 100.0,
-            ],
+            5.0 * vec2(texture.aspect_ratio(), 1.0),
         );
 
         let plot = Plot::new("items_demo")
@@ -376,15 +445,9 @@ impl Widget for &mut ItemsDemo {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(Default, PartialEq)]
 struct InteractionDemo {}
 
-impl Default for InteractionDemo {
-    fn default() -> Self {
-        Self {}
-    }
-}
-
 impl Widget for &mut InteractionDemo {
     fn ui(self, ui: &mut Ui) -> Response {
         let plot = Plot::new("interaction_demo").height(300.0);
@@ -532,15 +595,40 @@ impl ChartsDemo {
         .name("Set 4")
         .stack_on(&[&chart1, &chart2, &chart3]);
 
+        let mut x_fmt: fn(f64) -> String = |val| {
+            if val >= 0.0 && val <= 4.0 && is_approx_integer(val) {
+                // Only label full days from 0 to 4
+                format!("Day {}", val)
+            } else {
+                // Otherwise return empty string (i.e. no label)
+                String::new()
+            }
+        };
+
+        let mut y_fmt: fn(f64) -> String = |val| {
+            let percent = 100.0 * val;
+
+            if is_approx_integer(percent) && !is_approx_zero(percent) {
+                // Only show integer percentages,
+                // and don't show at Y=0 (label overlaps with X axis label)
+                format!("{}%", percent)
+            } else {
+                String::new()
+            }
+        };
+
         if !self.vertical {
             chart1 = chart1.horizontal();
             chart2 = chart2.horizontal();
             chart3 = chart3.horizontal();
             chart4 = chart4.horizontal();
+            std::mem::swap(&mut x_fmt, &mut y_fmt);
         }
 
         Plot::new("Stacked Bar Chart Demo")
             .legend(Legend::default())
+            .x_axis_formatter(x_fmt)
+            .y_axis_formatter(y_fmt)
             .data_aspect(1.0)
             .show(ui, |plot_ui| {
                 plot_ui.bar_chart(chart1);
@@ -623,11 +711,12 @@ enum Panel {
     Charts,
     Items,
     Interaction,
+    LinkedAxes,
 }
 
 impl Default for Panel {
     fn default() -> Self {
-        Self::Charts
+        Self::Lines
     }
 }
 
@@ -639,6 +728,7 @@ pub struct PlotDemo {
     charts_demo: ChartsDemo,
     items_demo: ItemsDemo,
     interaction_demo: InteractionDemo,
+    linked_axes_demo: LinkedAxisDemo,
     open_panel: Panel,
 }
 
@@ -647,7 +737,7 @@ impl super::Demo for PlotDemo {
         "🗠 Plot"
     }
 
-    fn show(&mut self, ctx: &CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
         use super::View as _;
         Window::new(self.name())
             .open(open)
@@ -663,6 +753,7 @@ impl super::View for PlotDemo {
             egui::reset_button(ui, self);
             ui.collapsing("Instructions", |ui| {
                 ui.label("Pan by dragging, or scroll (+ shift = horizontal).");
+                ui.label("Box zooming: Right click to zoom in and zoom out using a selection.");
                 if cfg!(target_arch = "wasm32") {
                     ui.label("Zoom with ctrl / ⌘ + pointer wheel, or with pinch gesture.");
                 } else if cfg!(target_os = "macos") {
@@ -682,6 +773,7 @@ impl super::View for PlotDemo {
             ui.selectable_value(&mut self.open_panel, Panel::Charts, "Charts");
             ui.selectable_value(&mut self.open_panel, Panel::Items, "Items");
             ui.selectable_value(&mut self.open_panel, Panel::Interaction, "Interaction");
+            ui.selectable_value(&mut self.open_panel, Panel::LinkedAxes, "Linked Axes");
         });
         ui.separator();
 
@@ -704,6 +796,17 @@ impl super::View for PlotDemo {
             Panel::Interaction => {
                 ui.add(&mut self.interaction_demo);
             }
+            Panel::LinkedAxes => {
+                ui.add(&mut self.linked_axes_demo);
+            }
         }
     }
 }
+
+fn is_approx_zero(val: f64) -> bool {
+    val.abs() < 1e-6
+}
+
+fn is_approx_integer(val: f64) -> bool {
+    val.fract().abs() < 1e-6
+}
diff --git a/egui_demo_lib/src/apps/demo/scrolling.rs b/egui_demo_lib/src/apps/demo/scrolling.rs
index 97d0a7fe..0c01ef11 100644
--- a/egui_demo_lib/src/apps/demo/scrolling.rs
+++ b/egui_demo_lib/src/apps/demo/scrolling.rs
@@ -29,7 +29,7 @@ impl super::Demo for Scrolling {
         "↕ Scrolling"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(false)
@@ -81,7 +81,7 @@ fn huge_content_lines(ui: &mut egui::Ui) {
     ui.add_space(4.0);
 
     let text_style = TextStyle::Body;
-    let row_height = ui.fonts()[text_style].row_height();
+    let row_height = ui.text_style_height(&text_style);
     let num_rows = 10_000;
     ScrollArea::vertical().auto_shrink([false; 2]).show_rows(
         ui,
@@ -101,8 +101,8 @@ fn huge_content_painter(ui: &mut egui::Ui) {
     ui.label("A lot of rows, but only the visible ones are painted, so performance is still good:");
     ui.add_space(4.0);
 
-    let text_style = TextStyle::Body;
-    let row_height = ui.fonts()[text_style].row_height() + ui.spacing().item_spacing.y;
+    let font_id = TextStyle::Body.resolve(ui.style());
+    let row_height = ui.fonts().row_height(&font_id) + ui.spacing().item_spacing.y;
     let num_rows = 10_000;
 
     ScrollArea::vertical()
@@ -130,7 +130,7 @@ fn huge_content_painter(ui: &mut egui::Ui) {
                     pos2(x, y),
                     Align2::LEFT_TOP,
                     text,
-                    text_style,
+                    font_id.clone(),
                     ui.visuals().text_color(),
                 );
                 used_rect = used_rect.union(text_rect);
@@ -210,32 +210,34 @@ impl super::View for ScrollTo {
         }
 
         ui.separator();
-        let (current_scroll, max_scroll) = scroll_area.show(ui, |ui| {
-            if scroll_top {
-                ui.scroll_to_cursor(Align::TOP);
-            }
-            ui.vertical(|ui| {
-                for item in 1..=50 {
-                    if track_item && item == self.track_item {
-                        let response =
-                            ui.colored_label(Color32::YELLOW, format!("This is item {}", item));
-                        response.scroll_to_me(self.tack_item_align);
-                    } else {
-                        ui.label(format!("This is item {}", item));
-                    }
+        let (current_scroll, max_scroll) = scroll_area
+            .show(ui, |ui| {
+                if scroll_top {
+                    ui.scroll_to_cursor(Align::TOP);
                 }
-            });
+                ui.vertical(|ui| {
+                    for item in 1..=50 {
+                        if track_item && item == self.track_item {
+                            let response =
+                                ui.colored_label(Color32::YELLOW, format!("This is item {}", item));
+                            response.scroll_to_me(self.tack_item_align);
+                        } else {
+                            ui.label(format!("This is item {}", item));
+                        }
+                    }
+                });
 
-            if scroll_bottom {
-                ui.scroll_to_cursor(Align::BOTTOM);
-            }
+                if scroll_bottom {
+                    ui.scroll_to_cursor(Align::BOTTOM);
+                }
 
-            let margin = ui.visuals().clip_rect_margin;
+                let margin = ui.visuals().clip_rect_margin;
 
-            let current_scroll = ui.clip_rect().top() - ui.min_rect().top() + margin;
-            let max_scroll = ui.min_rect().height() - ui.clip_rect().height() + 2.0 * margin;
-            (current_scroll, max_scroll)
-        });
+                let current_scroll = ui.clip_rect().top() - ui.min_rect().top() + margin;
+                let max_scroll = ui.min_rect().height() - ui.clip_rect().height() + 2.0 * margin;
+                (current_scroll, max_scroll)
+            })
+            .inner;
         ui.separator();
 
         ui.label(format!(
@@ -253,17 +255,11 @@ impl super::View for ScrollTo {
 
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
-#[derive(PartialEq)]
+#[derive(Default, PartialEq)]
 struct ScrollStickTo {
     n_items: usize,
 }
 
-impl Default for ScrollStickTo {
-    fn default() -> Self {
-        Self { n_items: 0 }
-    }
-}
-
 impl super::View for ScrollStickTo {
     fn ui(&mut self, ui: &mut Ui) {
         ui.label("Rows enter from the bottom, we want the scroll handle to start and stay at bottom unless moved");
@@ -271,7 +267,7 @@ impl super::View for ScrollStickTo {
         ui.add_space(4.0);
 
         let text_style = TextStyle::Body;
-        let row_height = ui.fonts()[text_style].row_height();
+        let row_height = ui.text_style_height(&text_style);
         ScrollArea::vertical().stick_to_bottom().show_rows(
             ui,
             row_height,
diff --git a/egui_demo_lib/src/apps/demo/sliders.rs b/egui_demo_lib/src/apps/demo/sliders.rs
index 24da825b..78e0cdb1 100644
--- a/egui_demo_lib/src/apps/demo/sliders.rs
+++ b/egui_demo_lib/src/apps/demo/sliders.rs
@@ -36,7 +36,7 @@ impl super::Demo for Sliders {
         "⬌ Sliders"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(false)
diff --git a/egui_demo_lib/src/apps/demo/table_demo.rs b/egui_demo_lib/src/apps/demo/table_demo.rs
index de553933..58c3792e 100644
--- a/egui_demo_lib/src/apps/demo/table_demo.rs
+++ b/egui_demo_lib/src/apps/demo/table_demo.rs
@@ -13,7 +13,7 @@ impl super::Demo for TableDemo {
         "☰ Table Demo"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(true)
diff --git a/egui_demo_lib/src/apps/demo/tests.rs b/egui_demo_lib/src/apps/demo/tests.rs
index b683236f..afe48e70 100644
--- a/egui_demo_lib/src/apps/demo/tests.rs
+++ b/egui_demo_lib/src/apps/demo/tests.rs
@@ -6,7 +6,7 @@ impl super::Demo for CursorTest {
         "Cursor Test"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name()).open(open).show(ctx, |ui| {
             use super::View as _;
             self.ui(ui);
@@ -38,7 +38,7 @@ impl super::Demo for IdTest {
         "ID Test"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name()).open(open).show(ctx, |ui| {
             use super::View as _;
             self.ui(ui);
@@ -52,7 +52,7 @@ impl super::View for IdTest {
 
         ui.label("\
             Widgets that store state require unique and persisting identifiers so we can track their state between frames.\n\
-            For instance, collapsable headers needs to store wether or not they are open. \
+            For instance, collapsable headers needs to store whether or not they are open. \
             Their Id:s are derived from their names. \
             If you fail to give them unique names then clicking one will open both. \
             To help you debug this, an error message is printed on screen:");
@@ -115,7 +115,7 @@ impl super::Demo for ManualLayoutTest {
         "Manual Layout Test"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .resizable(false)
             .open(open)
@@ -202,7 +202,7 @@ impl super::Demo for TableTest {
         "Table Test"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name()).open(open).show(ctx, |ui| {
             use super::View as _;
             self.ui(ui);
@@ -314,7 +314,7 @@ impl super::Demo for InputTest {
         "Input Test"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(false)
@@ -383,7 +383,7 @@ impl super::Demo for WindowResizeTest {
         "↔ Window Resize"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         use egui::*;
 
         Window::new("↔ auto-sized")
diff --git a/egui_demo_lib/src/apps/demo/text_edit.rs b/egui_demo_lib/src/apps/demo/text_edit.rs
index 1d2294de..5cef1d90 100644
--- a/egui_demo_lib/src/apps/demo/text_edit.rs
+++ b/egui_demo_lib/src/apps/demo/text_edit.rs
@@ -19,7 +19,7 @@ impl super::Demo for TextEdit {
         "🖹 TextEdit"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(false)
diff --git a/egui_demo_lib/src/apps/demo/widget_gallery.rs b/egui_demo_lib/src/apps/demo/widget_gallery.rs
index 73b976d4..5c79c46e 100644
--- a/egui_demo_lib/src/apps/demo/widget_gallery.rs
+++ b/egui_demo_lib/src/apps/demo/widget_gallery.rs
@@ -23,6 +23,8 @@ pub struct WidgetGallery {
     #[cfg(feature = "datetime")]
     #[serde(with = "serde_date_format")]
     date: chrono::Date<chrono::Utc>,
+    #[cfg_attr(feature = "serde", serde(skip))]
+    texture: Option<egui::TextureHandle>,
 }
 
 impl Default for WidgetGallery {
@@ -38,6 +40,7 @@ impl Default for WidgetGallery {
             animate_progress_bar: false,
             #[cfg(feature = "datetime")]
             date: chrono::offset::Utc::now().date(),
+            texture: None,
         }
     }
 }
@@ -47,7 +50,7 @@ impl super::Demo for WidgetGallery {
         "🗄 Widget Gallery"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         egui::Window::new(self.name())
             .open(open)
             .resizable(true)
@@ -108,8 +111,14 @@ impl WidgetGallery {
             color,
             animate_progress_bar,
             date,
+            texture,
         } = self;
 
+        let texture: &egui::TextureHandle = texture.get_or_insert_with(|| {
+            ui.ctx()
+                .load_texture("example", egui::ColorImage::example())
+        });
+
         ui.add(doc_link_label("Label", "label,heading"));
         ui.label("Welcome to the widget gallery!");
         ui.end_row();
@@ -189,17 +198,14 @@ impl WidgetGallery {
         ui.color_edit_button_srgba(color);
         ui.end_row();
 
+        let img_size = 16.0 * texture.size_vec2() / texture.size_vec2().y;
+
         ui.add(doc_link_label("Image", "Image"));
-        ui.image(egui::TextureId::Egui, [24.0, 16.0])
-            .on_hover_text("The egui font texture was the convenient choice to show here.");
+        ui.image(texture, img_size);
         ui.end_row();
 
         ui.add(doc_link_label("ImageButton", "ImageButton"));
-        if ui
-            .add(egui::ImageButton::new(egui::TextureId::Egui, [24.0, 16.0]))
-            .on_hover_text("The egui font texture was the convenient choice to show here.")
-            .clicked()
-        {
+        if ui.add(egui::ImageButton::new(texture, img_size)).clicked() {
             *boolean = !*boolean;
         }
         ui.end_row();
@@ -218,10 +224,11 @@ impl WidgetGallery {
         ui.add(doc_link_label("CollapsingHeader", "collapsing"));
         ui.collapsing("Click to see what is hidden!", |ui| {
             ui.horizontal_wrapped(|ui| {
-                ui.label(
-                    "Not much, as it turns out - but here is a gold star for you for checking:",
-                );
-                ui.colored_label(egui::Color32::GOLD, "☆");
+                ui.spacing_mut().item_spacing.x = 0.0;
+                ui.label("It's a ");
+                ui.add(doc_link_label("Spinner", "spinner"));
+                ui.add_space(4.0);
+                ui.add(egui::Spinner::new());
             });
         });
         ui.end_row();
@@ -239,10 +246,6 @@ impl WidgetGallery {
             This toggle switch is just 15 lines of code.",
         );
         ui.end_row();
-
-        ui.add(doc_link_label("Spinner", "spinner"));
-        ui.add(egui::Spinner::new());
-        ui.end_row();
     }
 }
 
diff --git a/egui_demo_lib/src/apps/demo/window_options.rs b/egui_demo_lib/src/apps/demo/window_options.rs
index 6759fa5b..557155c5 100644
--- a/egui_demo_lib/src/apps/demo/window_options.rs
+++ b/egui_demo_lib/src/apps/demo/window_options.rs
@@ -36,7 +36,7 @@ impl super::Demo for WindowOptions {
         "🗖 Window Options"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         let Self {
             title,
             title_bar,
diff --git a/egui_demo_lib/src/apps/demo/window_with_panels.rs b/egui_demo_lib/src/apps/demo/window_with_panels.rs
index d81520ec..b8d1af5e 100644
--- a/egui_demo_lib/src/apps/demo/window_with_panels.rs
+++ b/egui_demo_lib/src/apps/demo/window_with_panels.rs
@@ -7,7 +7,7 @@ impl super::Demo for WindowWithPanels {
         "🗖 Window With Panels"
     }
 
-    fn show(&mut self, ctx: &egui::CtxRef, open: &mut bool) {
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
         use super::View as _;
         let window = egui::Window::new("Window with Panels")
             .default_width(600.0)
diff --git a/egui_demo_lib/src/apps/fractal_clock.rs b/egui_demo_lib/src/apps/fractal_clock.rs
index 813ab343..943a0139 100644
--- a/egui_demo_lib/src/apps/fractal_clock.rs
+++ b/egui_demo_lib/src/apps/fractal_clock.rs
@@ -37,7 +37,7 @@ impl epi::App for FractalClock {
         "🕑 Fractal Clock"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, _frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, _frame: &epi::Frame) {
         egui::CentralPanel::default()
             .frame(Frame::dark_canvas(&ctx.style()))
             .show(ctx, |ui| self.ui(ui, crate::seconds_since_midnight()));
@@ -97,6 +97,7 @@ impl FractalClock {
             "Inspired by a screensaver by Rob Mayoff",
             "http://www.dqd.com/~mayoff/programs/FractalClock/",
         );
+        ui.add(crate::__egui_github_link_file!());
     }
 
     fn paint(&mut self, painter: &Painter) {
diff --git a/egui_demo_lib/src/apps/http_app.rs b/egui_demo_lib/src/apps/http_app.rs
index c7b823d8..aa6ac4f4 100644
--- a/egui_demo_lib/src/apps/http_app.rs
+++ b/egui_demo_lib/src/apps/http_app.rs
@@ -1,4 +1,4 @@
-use std::sync::mpsc::Receiver;
+use poll_promise::Promise;
 
 struct Resource {
     /// HTTP response
@@ -7,7 +7,7 @@ struct Resource {
     text: Option<String>,
 
     /// If set, the response was an image.
-    image: Option<epi::Image>,
+    texture: Option<egui::TextureHandle>,
 
     /// If set, the response was text with some supported syntax highlighting (e.g. ".rs" or ".md").
     colored_text: Option<ColoredText>,
@@ -17,21 +17,21 @@ impl Resource {
     fn from_response(ctx: &egui::Context, response: ehttp::Response) -> Self {
         let content_type = response.content_type().unwrap_or_default();
         let image = if content_type.starts_with("image/") {
-            decode_image(&response.bytes)
+            load_image(&response.bytes).ok()
         } else {
             None
         };
 
-        let text = response.text();
+        let texture = image.map(|image| ctx.load_texture(&response.url, image));
 
-        let colored_text = text
-            .as_ref()
-            .and_then(|text| syntax_highlighting(ctx, &response, text));
+        let text = response.text();
+        let colored_text = text.and_then(|text| syntax_highlighting(ctx, &response, text));
+        let text = text.map(|text| text.to_owned());
 
         Self {
             response,
             text,
-            image,
+            texture,
             colored_text,
         }
     }
@@ -42,22 +42,14 @@ pub struct HttpApp {
     url: String,
 
     #[cfg_attr(feature = "serde", serde(skip))]
-    in_progress: Option<Receiver<Result<ehttp::Response, String>>>,
-
-    #[cfg_attr(feature = "serde", serde(skip))]
-    result: Option<Result<Resource, String>>,
-
-    #[cfg_attr(feature = "serde", serde(skip))]
-    tex_mngr: TexMngr,
+    promise: Option<Promise<ehttp::Result<Resource>>>,
 }
 
 impl Default for HttpApp {
     fn default() -> Self {
         Self {
             url: "https://raw.githubusercontent.com/emilk/egui/master/README.md".to_owned(),
-            in_progress: Default::default(),
-            result: Default::default(),
-            tex_mngr: Default::default(),
+            promise: Default::default(),
         }
     }
 }
@@ -67,15 +59,7 @@ impl epi::App for HttpApp {
         "⬇ HTTP"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
-        if let Some(receiver) = &mut self.in_progress {
-            // Are we there yet?
-            if let Ok(result) = receiver.try_recv() {
-                self.in_progress = None;
-                self.result = Some(result.map(|response| Resource::from_response(ctx, response)));
-            }
-        }
-
+    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
         egui::TopBottomPanel::bottom("http_bottom").show(ctx, |ui| {
             let layout = egui::Layout::top_down(egui::Align::Center).with_main_justify(true);
             ui.allocate_ui_with_layout(ui.available_size(), layout, |ui| {
@@ -94,33 +78,36 @@ impl epi::App for HttpApp {
             });
 
             if trigger_fetch {
-                let request = ehttp::Request::get(&self.url);
+                let ctx = ctx.clone();
                 let frame = frame.clone();
-                let (sender, receiver) = std::sync::mpsc::channel();
-                self.in_progress = Some(receiver);
-
+                let (sender, promise) = Promise::new();
+                let request = ehttp::Request::get(&self.url);
                 ehttp::fetch(request, move |response| {
-                    sender.send(response).ok();
-                    frame.request_repaint();
+                    frame.request_repaint(); // wake up UI thread
+                    let resource = response.map(|response| Resource::from_response(&ctx, response));
+                    sender.send(resource);
                 });
+                self.promise = Some(promise);
             }
 
             ui.separator();
 
-            if self.in_progress.is_some() {
-                ui.label("Please wait…");
-            } else if let Some(result) = &self.result {
-                match result {
-                    Ok(resource) => {
-                        ui_resource(ui, frame, &mut self.tex_mngr, resource);
-                    }
-                    Err(error) => {
-                        // This should only happen if the fetch API isn't available or something similar.
-                        ui.colored_label(
-                            egui::Color32::RED,
-                            if error.is_empty() { "Error" } else { error },
-                        );
+            if let Some(promise) = &self.promise {
+                if let Some(result) = promise.ready() {
+                    match result {
+                        Ok(resource) => {
+                            ui_resource(ui, resource);
+                        }
+                        Err(error) => {
+                            // This should only happen if the fetch API isn't available or something similar.
+                            ui.colored_label(
+                                egui::Color32::RED,
+                                if error.is_empty() { "Error" } else { error },
+                            );
+                        }
                     }
+                } else {
+                    ui.add(egui::Spinner::new());
                 }
             }
         });
@@ -160,11 +147,11 @@ fn ui_url(ui: &mut egui::Ui, frame: &epi::Frame, url: &mut String) -> bool {
     trigger_fetch
 }
 
-fn ui_resource(ui: &mut egui::Ui, frame: &epi::Frame, tex_mngr: &mut TexMngr, resource: &Resource) {
+fn ui_resource(ui: &mut egui::Ui, resource: &Resource) {
     let Resource {
         response,
         text,
-        image,
+        texture,
         colored_text,
     } = resource;
 
@@ -211,12 +198,10 @@ fn ui_resource(ui: &mut egui::Ui, frame: &epi::Frame, tex_mngr: &mut TexMngr, re
                 ui.separator();
             }
 
-            if let Some(image) = image {
-                if let Some(texture_id) = tex_mngr.texture(frame, &response.url, image) {
-                    let mut size = egui::Vec2::new(image.size[0] as f32, image.size[1] as f32);
-                    size *= (ui.available_width() / size.x).min(1.0);
-                    ui.image(texture_id, size);
-                }
+            if let Some(texture) = texture {
+                let mut size = texture.size_vec2();
+                size *= (ui.available_width() / size.x).min(1.0);
+                ui.image(texture, size);
             } else if let Some(colored_text) = colored_text {
                 colored_text.ui(ui);
             } else if let Some(text) = &text {
@@ -231,7 +216,7 @@ fn selectable_text(ui: &mut egui::Ui, mut text: &str) {
     ui.add(
         egui::TextEdit::multiline(&mut text)
             .desired_width(f32::INFINITY)
-            .text_style(egui::TextStyle::Monospace),
+            .font(egui::TextStyle::Monospace),
     );
 }
 
@@ -272,7 +257,7 @@ impl ColoredText {
             let mut text = self.0.text.as_str();
             ui.add(
                 egui::TextEdit::multiline(&mut text)
-                    .text_style(egui::TextStyle::Monospace)
+                    .font(egui::TextStyle::Monospace)
                     .desired_width(f32::INFINITY)
                     .layouter(&mut layouter),
             );
@@ -287,39 +272,14 @@ impl ColoredText {
 }
 
 // ----------------------------------------------------------------------------
-// Texture/image handling is very manual at the moment.
 
-/// Immediate mode texture manager that supports at most one texture at the time :)
-#[derive(Default)]
-struct TexMngr {
-    loaded_url: String,
-    texture_id: Option<egui::TextureId>,
-}
-
-impl TexMngr {
-    fn texture(
-        &mut self,
-        frame: &epi::Frame,
-        url: &str,
-        image: &epi::Image,
-    ) -> Option<egui::TextureId> {
-        if self.loaded_url != url {
-            if let Some(texture_id) = self.texture_id.take() {
-                frame.free_texture(texture_id);
-            }
-
-            self.texture_id = Some(frame.alloc_texture(image.clone()));
-            self.loaded_url = url.to_owned();
-        }
-        self.texture_id
-    }
-}
-
-fn decode_image(bytes: &[u8]) -> Option<epi::Image> {
-    use image::GenericImageView;
-    let image = image::load_from_memory(bytes).ok()?;
+fn load_image(image_data: &[u8]) -> Result<egui::ColorImage, image::ImageError> {
+    let image = image::load_from_memory(image_data)?;
+    let size = [image.width() as _, image.height() as _];
     let image_buffer = image.to_rgba8();
-    let size = [image.width() as usize, image.height() as usize];
-    let pixels = image_buffer.into_vec();
-    Some(epi::Image::from_rgba_unmultiplied(size, &pixels))
+    let pixels = image_buffer.as_flat_samples();
+    Ok(egui::ColorImage::from_rgba_unmultiplied(
+        size,
+        pixels.as_slice(),
+    ))
 }
diff --git a/egui_demo_lib/src/backend_panel.rs b/egui_demo_lib/src/backend_panel.rs
index 375a41eb..81903af1 100644
--- a/egui_demo_lib/src/backend_panel.rs
+++ b/egui_demo_lib/src/backend_panel.rs
@@ -51,6 +51,7 @@ pub struct BackendPanel {
     run_mode: RunMode,
 
     /// current slider value for current gui scale
+    #[cfg_attr(feature = "serde", serde(skip))]
     pixels_per_point: Option<f32>,
 
     /// maximum size of the web browser canvas
@@ -78,7 +79,7 @@ impl Default for BackendPanel {
 }
 
 impl BackendPanel {
-    pub fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+    pub fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
         self.frame_history
             .on_new_frame(ctx.input().time, frame.info().cpu_usage);
 
@@ -88,7 +89,7 @@ impl BackendPanel {
         }
     }
 
-    pub fn end_of_frame(&mut self, ctx: &egui::CtxRef) {
+    pub fn end_of_frame(&mut self, ctx: &egui::Context) {
         self.egui_windows.windows(ctx);
     }
 
@@ -127,9 +128,9 @@ impl BackendPanel {
         ui.separator();
 
         {
-            let mut screen_reader = ui.ctx().memory().options.screen_reader;
+            let mut screen_reader = ui.ctx().options().screen_reader;
             ui.checkbox(&mut screen_reader, "🔈 Screen reader").on_hover_text("Experimental feature: checking this will turn on the screen reader on supported platforms");
-            ui.ctx().memory().options.screen_reader = screen_reader;
+            ui.ctx().options().screen_reader = screen_reader;
         }
 
         if !frame.is_web() {
@@ -195,12 +196,10 @@ impl BackendPanel {
         ui: &mut egui::Ui,
         info: &epi::IntegrationInfo,
     ) -> Option<f32> {
-        self.pixels_per_point = self
-            .pixels_per_point
-            .or(info.native_pixels_per_point)
-            .or_else(|| Some(ui.ctx().pixels_per_point()));
-
-        let pixels_per_point = self.pixels_per_point.as_mut()?;
+        let pixels_per_point = self.pixels_per_point.get_or_insert_with(|| {
+            info.native_pixels_per_point
+                .unwrap_or_else(|| ui.ctx().pixels_per_point())
+        });
 
         ui.horizontal(|ui| {
             ui.spacing_mut().slider_width = 90.0;
@@ -325,7 +324,7 @@ impl EguiWindows {
         ui.checkbox(output_events, "📤 Output Events");
     }
 
-    fn windows(&mut self, ctx: &egui::CtxRef) {
+    fn windows(&mut self, ctx: &egui::Context) {
         let Self {
             settings,
             inspection,
diff --git a/egui_demo_lib/src/easy_mark/easy_mark_editor.rs b/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
index 729d1a5f..aa1468d9 100644
--- a/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
+++ b/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
@@ -34,7 +34,7 @@ impl epi::App for EasyMarkEditor {
         "🖹 EasyMark editor"
     }
 
-    fn update(&mut self, ctx: &egui::CtxRef, _frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, _frame: &epi::Frame) {
         egui::TopBottomPanel::bottom("easy_mark_bottom").show(ctx, |ui| {
             let layout = egui::Layout::top_down(egui::Align::Center).with_main_justify(true);
             ui.allocate_ui_with_layout(ui.available_size(), layout, |ui| {
@@ -88,7 +88,7 @@ impl EasyMarkEditor {
 
         let response = if self.highlight_editor {
             let mut layouter = |ui: &egui::Ui, easymark: &str, wrap_width: f32| {
-                let mut layout_job = highlighter.highlight(ui.visuals(), easymark);
+                let mut layout_job = highlighter.highlight(ui.style(), easymark);
                 layout_job.wrap_width = wrap_width;
                 ui.fonts().layout_job(layout_job)
             };
@@ -96,7 +96,7 @@ impl EasyMarkEditor {
             ui.add(
                 egui::TextEdit::multiline(code)
                     .desired_width(f32::INFINITY)
-                    .text_style(egui::TextStyle::Monospace) // for cursor height
+                    .font(egui::TextStyle::Monospace) // for cursor height
                     .layouter(&mut layouter),
             )
         } else {
diff --git a/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs b/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
index 67c2c859..e946750c 100644
--- a/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
+++ b/egui_demo_lib/src/easy_mark/easy_mark_highlighter.rs
@@ -5,23 +5,23 @@ use crate::easy_mark::easy_mark_parser;
 /// In practice, the highlighter is fast enough not to need any caching.
 #[derive(Default)]
 pub struct MemoizedEasymarkHighlighter {
-    visuals: egui::Visuals,
+    style: egui::Style,
     code: String,
     output: egui::text::LayoutJob,
 }
 
 impl MemoizedEasymarkHighlighter {
-    pub fn highlight(&mut self, visuals: &egui::Visuals, code: &str) -> egui::text::LayoutJob {
-        if (&self.visuals, self.code.as_str()) != (visuals, code) {
-            self.visuals = visuals.clone();
+    pub fn highlight(&mut self, egui_style: &egui::Style, code: &str) -> egui::text::LayoutJob {
+        if (&self.style, self.code.as_str()) != (egui_style, code) {
+            self.style = egui_style.clone();
             self.code = code.to_owned();
-            self.output = highlight_easymark(visuals, code);
+            self.output = highlight_easymark(egui_style, code);
         }
         self.output.clone()
     }
 }
 
-pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text::LayoutJob {
+pub fn highlight_easymark(egui_style: &egui::Style, mut text: &str) -> egui::text::LayoutJob {
     let mut job = egui::text::LayoutJob::default();
     let mut style = easy_mark_parser::Style::default();
     let mut start_of_line = true;
@@ -33,7 +33,7 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
                 &text[..end],
                 0.0,
                 format_from_style(
-                    visuals,
+                    egui_style,
                     &easy_mark_parser::Style {
                         code: true,
                         ..Default::default()
@@ -50,7 +50,7 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
             let end = text[1..]
                 .find(&['`', '\n'][..])
                 .map_or_else(|| text.len(), |i| i + 2);
-            job.append(&text[..end], 0.0, format_from_style(visuals, &style));
+            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
             text = &text[end..];
             style.code = false;
             continue;
@@ -61,7 +61,7 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
         if text.starts_with('\\') && text.len() >= 2 {
             skip = 2;
         } else if start_of_line && text.starts_with(' ') {
-            // indentation we don't preview indentation, because it is confusing
+            // we don't preview indentation, because it is confusing
             skip = 1;
         } else if start_of_line && text.starts_with("# ") {
             style.heading = true;
@@ -69,15 +69,15 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
         } else if start_of_line && text.starts_with("> ") {
             style.quoted = true;
             skip = 2;
-            // indentation we don't preview indentation, because it is confusing
+            // we don't preview indentation, because it is confusing
         } else if start_of_line && text.starts_with("- ") {
             skip = 2;
-            // indentation we don't preview indentation, because it is confusing
+            // we don't preview indentation, because it is confusing
         } else if text.starts_with('*') {
             skip = 1;
             if style.strong {
-                // Include the character that i ending ths style:
-                job.append(&text[..skip], 0.0, format_from_style(visuals, &style));
+                // Include the character that is ending this style:
+                job.append(&text[..skip], 0.0, format_from_style(egui_style, &style));
                 text = &text[skip..];
                 skip = 0;
             }
@@ -85,8 +85,8 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
         } else if text.starts_with('$') {
             skip = 1;
             if style.small {
-                // Include the character that i ending ths style:
-                job.append(&text[..skip], 0.0, format_from_style(visuals, &style));
+                // Include the character that is ending this style:
+                job.append(&text[..skip], 0.0, format_from_style(egui_style, &style));
                 text = &text[skip..];
                 skip = 0;
             }
@@ -94,8 +94,8 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
         } else if text.starts_with('^') {
             skip = 1;
             if style.raised {
-                // Include the character that i ending ths style:
-                job.append(&text[..skip], 0.0, format_from_style(visuals, &style));
+                // Include the character that is ending this style:
+                job.append(&text[..skip], 0.0, format_from_style(egui_style, &style));
                 text = &text[skip..];
                 skip = 0;
             }
@@ -114,12 +114,16 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
             .map_or_else(|| text.len(), |i| (skip + i).max(1));
 
         if line_end <= end {
-            job.append(&text[..line_end], 0.0, format_from_style(visuals, &style));
+            job.append(
+                &text[..line_end],
+                0.0,
+                format_from_style(egui_style, &style),
+            );
             text = &text[line_end..];
             start_of_line = true;
             style = Default::default();
         } else {
-            job.append(&text[..end], 0.0, format_from_style(visuals, &style));
+            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
             text = &text[end..];
             start_of_line = false;
         }
@@ -129,17 +133,17 @@ pub fn highlight_easymark(visuals: &egui::Visuals, mut text: &str) -> egui::text
 }
 
 fn format_from_style(
-    visuals: &egui::Visuals,
+    egui_style: &egui::Style,
     emark_style: &easy_mark_parser::Style,
 ) -> egui::text::TextFormat {
     use egui::{Align, Color32, Stroke, TextStyle};
 
     let color = if emark_style.strong || emark_style.heading {
-        visuals.strong_text_color()
+        egui_style.visuals.strong_text_color()
     } else if emark_style.quoted {
-        visuals.weak_text_color()
+        egui_style.visuals.weak_text_color()
     } else {
-        visuals.text_color()
+        egui_style.visuals.text_color()
     };
 
     let text_style = if emark_style.heading {
@@ -153,7 +157,7 @@ fn format_from_style(
     };
 
     let background = if emark_style.code {
-        visuals.code_bg_color
+        egui_style.visuals.code_bg_color
     } else {
         Color32::TRANSPARENT
     };
@@ -177,7 +181,7 @@ fn format_from_style(
     };
 
     egui::text::TextFormat {
-        style: text_style,
+        font_id: text_style.resolve(egui_style),
         color,
         background,
         italics: emark_style.italics,
diff --git a/egui_demo_lib/src/easy_mark/easy_mark_parser.rs b/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
index abb4179f..ef66f8e6 100644
--- a/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
+++ b/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
@@ -1,9 +1,6 @@
 //! A parser for `EasyMark`: a very simple markup language.
 //!
 //! WARNING: `EasyMark` is subject to change.
-//!
-//! This module does not depend on anything else in egui
-//! and should perhaps be its own crate.
 //
 //! # `EasyMark` design goals:
 //! 1. easy to parse
diff --git a/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs b/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
index 07a1ba17..ffe79d40 100644
--- a/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
+++ b/egui_demo_lib/src/easy_mark/easy_mark_viewer.rs
@@ -18,7 +18,8 @@ pub fn easy_mark_it<'em>(ui: &mut Ui, items: impl Iterator<Item = easy_mark::Ite
 
     ui.allocate_ui_with_layout(initial_size, layout, |ui| {
         ui.spacing_mut().item_spacing.x = 0.0;
-        ui.set_row_height(ui.fonts()[TextStyle::Body].row_height());
+        let row_height = ui.text_style_height(&TextStyle::Body);
+        ui.set_row_height(row_height);
 
         for item in items {
             item_ui(ui, item);
@@ -27,7 +28,7 @@ pub fn easy_mark_it<'em>(ui: &mut Ui, items: impl Iterator<Item = easy_mark::Ite
 }
 
 pub fn item_ui(ui: &mut Ui, item: easy_mark::Item<'_>) {
-    let row_height = ui.fonts()[TextStyle::Body].row_height();
+    let row_height = ui.text_style_height(&TextStyle::Body);
     let one_indent = row_height / 2.0;
 
     match item {
@@ -133,7 +134,7 @@ fn rich_text_from_style(text: &str, style: &easy_mark::Style) -> RichText {
 }
 
 fn bullet_point(ui: &mut Ui, width: f32) -> Response {
-    let row_height = ui.fonts()[TextStyle::Body].row_height();
+    let row_height = ui.text_style_height(&TextStyle::Body);
     let (rect, response) = ui.allocate_exact_size(vec2(width, row_height), Sense::hover());
     ui.painter().circle_filled(
         rect.center(),
@@ -144,7 +145,8 @@ fn bullet_point(ui: &mut Ui, width: f32) -> Response {
 }
 
 fn numbered_point(ui: &mut Ui, width: f32, number: &str) -> Response {
-    let row_height = ui.fonts()[TextStyle::Body].row_height();
+    let font_id = TextStyle::Body.resolve(ui.style());
+    let row_height = ui.fonts().row_height(&font_id);
     let (rect, response) = ui.allocate_exact_size(vec2(width, row_height), Sense::hover());
     let text = format!("{}.", number);
     let text_color = ui.visuals().strong_text_color();
@@ -152,7 +154,7 @@ fn numbered_point(ui: &mut Ui, width: f32, number: &str) -> Response {
         rect.right_center(),
         Align2::RIGHT_CENTER,
         text,
-        TextStyle::Body,
+        font_id,
         text_color,
     );
     response
diff --git a/egui_demo_lib/src/frame_history.rs b/egui_demo_lib/src/frame_history.rs
index 1a565d7b..556d3754 100644
--- a/egui_demo_lib/src/frame_history.rs
+++ b/egui_demo_lib/src/frame_history.rs
@@ -76,7 +76,7 @@ impl FrameHistory {
         let mut shapes = Vec::with_capacity(3 + 2 * history.len());
         shapes.push(Shape::Rect(epaint::RectShape {
             rect,
-            corner_radius: style.corner_radius,
+            rounding: style.rounding,
             fill: ui.visuals().extreme_bg_color,
             stroke: ui.style().noninteractive().bg_stroke,
         }));
@@ -94,11 +94,11 @@ impl FrameHistory {
             let cpu_usage = to_screen.inverse().transform_pos(pointer_pos).y;
             let text = format!("{:.1} ms", 1e3 * cpu_usage);
             shapes.push(Shape::text(
-                ui.fonts(),
+                &*ui.fonts(),
                 pos2(rect.left(), y),
                 egui::Align2::LEFT_BOTTOM,
                 text,
-                TextStyle::Monospace,
+                TextStyle::Monospace.resolve(ui.style()),
                 color,
             ));
         }
diff --git a/egui_demo_lib/src/lib.rs b/egui_demo_lib/src/lib.rs
index c5d4caef..5527d3ca 100644
--- a/egui_demo_lib/src/lib.rs
+++ b/egui_demo_lib/src/lib.rs
@@ -140,7 +140,7 @@ Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, tur
 #[test]
 fn test_egui_e2e() {
     let mut demo_windows = crate::DemoWindows::default();
-    let mut ctx = egui::CtxRef::default();
+    let ctx = egui::Context::default();
     let raw_input = egui::RawInput::default();
 
     const NUM_FRAMES: usize = 5;
@@ -156,7 +156,7 @@ fn test_egui_e2e() {
 #[test]
 fn test_egui_zero_window_size() {
     let mut demo_windows = crate::DemoWindows::default();
-    let mut ctx = egui::CtxRef::default();
+    let ctx = egui::Context::default();
     let raw_input = egui::RawInput {
         screen_rect: Some(egui::Rect::from_min_max(egui::Pos2::ZERO, egui::Pos2::ZERO)),
         ..Default::default()
@@ -176,7 +176,7 @@ fn test_egui_zero_window_size() {
 
 /// Time of day as seconds since midnight. Used for clock in demo app.
 pub(crate) fn seconds_since_midnight() -> Option<f64> {
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "datetime")]
     {
         use chrono::Timelike;
         let time = chrono::Local::now().time();
@@ -184,6 +184,6 @@ pub(crate) fn seconds_since_midnight() -> Option<f64> {
             time.num_seconds_from_midnight() as f64 + 1e-9 * (time.nanosecond() as f64);
         Some(seconds_since_midnight)
     }
-    #[cfg(not(feature = "chrono"))]
+    #[cfg(not(feature = "datetime"))]
     None
 }
diff --git a/egui_demo_lib/src/syntax_highlighting.rs b/egui_demo_lib/src/syntax_highlighting.rs
index 9603f5ae..b7701e77 100644
--- a/egui_demo_lib/src/syntax_highlighting.rs
+++ b/egui_demo_lib/src/syntax_highlighting.rs
@@ -13,7 +13,7 @@ pub fn code_view_ui(ui: &mut egui::Ui, mut code: &str) {
 
     ui.add(
         egui::TextEdit::multiline(&mut code)
-            .text_style(egui::TextStyle::Monospace) // for cursor height
+            .font(egui::TextStyle::Monospace) // for cursor height
             .code_editor()
             .desired_rows(1)
             .lock_focus(true)
@@ -66,7 +66,7 @@ enum SyntectTheme {
 
 #[cfg(feature = "syntect")]
 impl SyntectTheme {
-    fn all() -> impl Iterator<Item = Self> {
+    fn all() -> impl ExactSizeIterator<Item = Self> {
         [
             Self::Base16EightiesDark,
             Self::Base16MochaDark,
@@ -116,7 +116,7 @@ impl SyntectTheme {
     }
 }
 
-#[derive(Clone, Copy, Hash, PartialEq)]
+#[derive(Clone, Hash, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct CodeTheme {
@@ -146,27 +146,21 @@ impl CodeTheme {
 
     pub fn from_memory(ctx: &egui::Context) -> Self {
         if ctx.style().visuals.dark_mode {
-            ctx.memory()
-                .data
+            ctx.data()
                 .get_persisted(egui::Id::new("dark"))
                 .unwrap_or_else(CodeTheme::dark)
         } else {
-            ctx.memory()
-                .data
+            ctx.data()
                 .get_persisted(egui::Id::new("light"))
                 .unwrap_or_else(CodeTheme::light)
         }
     }
 
-    pub fn store_in_memory(&self, ctx: &egui::Context) {
+    pub fn store_in_memory(self, ctx: &egui::Context) {
         if self.dark_mode {
-            ctx.memory()
-                .data
-                .insert_persisted(egui::Id::new("dark"), *self);
+            ctx.data().insert_persisted(egui::Id::new("dark"), self);
         } else {
-            ctx.memory()
-                .data
-                .insert_persisted(egui::Id::new("light"), *self);
+            ctx.data().insert_persisted(egui::Id::new("light"), self);
         }
     }
 }
@@ -201,34 +195,34 @@ impl CodeTheme {
 #[cfg(not(feature = "syntect"))]
 impl CodeTheme {
     pub fn dark() -> Self {
-        let text_style = egui::TextStyle::Monospace;
+        let font_id = egui::FontId::monospace(12.0);
         use egui::{Color32, TextFormat};
         Self {
             dark_mode: true,
             formats: enum_map::enum_map![
-                TokenType::Comment => TextFormat::simple(text_style, Color32::from_gray(120)),
-                TokenType::Keyword => TextFormat::simple(text_style, Color32::from_rgb(255, 100, 100)),
-                TokenType::Literal => TextFormat::simple(text_style, Color32::from_rgb(87, 165, 171)),
-                TokenType::StringLiteral => TextFormat::simple(text_style, Color32::from_rgb(109, 147, 226)),
-                TokenType::Punctuation => TextFormat::simple(text_style, Color32::LIGHT_GRAY),
-                TokenType::Whitespace => TextFormat::simple(text_style, Color32::TRANSPARENT),
+                TokenType::Comment => TextFormat::simple(font_id.clone(), Color32::from_gray(120)),
+                TokenType::Keyword => TextFormat::simple(font_id.clone(), Color32::from_rgb(255, 100, 100)),
+                TokenType::Literal => TextFormat::simple(font_id.clone(), Color32::from_rgb(87, 165, 171)),
+                TokenType::StringLiteral => TextFormat::simple(font_id.clone(), Color32::from_rgb(109, 147, 226)),
+                TokenType::Punctuation => TextFormat::simple(font_id.clone(), Color32::LIGHT_GRAY),
+                TokenType::Whitespace => TextFormat::simple(font_id.clone(), Color32::TRANSPARENT),
             ],
         }
     }
 
     pub fn light() -> Self {
-        let text_style = egui::TextStyle::Monospace;
+        let font_id = egui::FontId::monospace(12.0);
         use egui::{Color32, TextFormat};
         Self {
             dark_mode: false,
             #[cfg(not(feature = "syntect"))]
             formats: enum_map::enum_map![
-                TokenType::Comment => TextFormat::simple(text_style, Color32::GRAY),
-                TokenType::Keyword => TextFormat::simple(text_style, Color32::from_rgb(235, 0, 0)),
-                TokenType::Literal => TextFormat::simple(text_style, Color32::from_rgb(153, 134, 255)),
-                TokenType::StringLiteral => TextFormat::simple(text_style, Color32::from_rgb(37, 203, 105)),
-                TokenType::Punctuation => TextFormat::simple(text_style, Color32::DARK_GRAY),
-                TokenType::Whitespace => TextFormat::simple(text_style, Color32::TRANSPARENT),
+                TokenType::Comment => TextFormat::simple(font_id.clone(), Color32::GRAY),
+                TokenType::Keyword => TextFormat::simple(font_id.clone(), Color32::from_rgb(235, 0, 0)),
+                TokenType::Literal => TextFormat::simple(font_id.clone(), Color32::from_rgb(153, 134, 255)),
+                TokenType::StringLiteral => TextFormat::simple(font_id.clone(), Color32::from_rgb(37, 203, 105)),
+                TokenType::Punctuation => TextFormat::simple(font_id.clone(), Color32::DARK_GRAY),
+                TokenType::Whitespace => TextFormat::simple(font_id.clone(), Color32::TRANSPARENT),
             ],
         }
     }
@@ -237,8 +231,7 @@ impl CodeTheme {
         ui.horizontal_top(|ui| {
             let selected_id = egui::Id::null();
             let mut selected_tt: TokenType = *ui
-                .memory()
-                .data
+                .data()
                 .get_persisted_mut_or(selected_id, TokenType::Comment);
 
             ui.vertical(|ui| {
@@ -259,7 +252,7 @@ impl CodeTheme {
                         // (TokenType::Whitespace, "whitespace"),
                     ] {
                         let format = &mut self.formats[tt];
-                        ui.style_mut().override_text_style = Some(format.style);
+                        ui.style_mut().override_font_id = Some(format.font_id.clone());
                         ui.visuals_mut().override_text_color = Some(format.color);
                         ui.radio_value(&mut selected_tt, tt, tt_name);
                     }
@@ -281,7 +274,7 @@ impl CodeTheme {
 
             ui.add_space(16.0);
 
-            ui.memory().data.insert_persisted(selected_id, selected_tt);
+            ui.data().insert_persisted(selected_id, selected_tt);
 
             egui::Frame::group(ui.style())
                 .margin(egui::Vec2::splat(2.0))
@@ -325,7 +318,7 @@ impl Highligher {
             // Fallback:
             LayoutJob::simple(
                 code.into(),
-                egui::TextStyle::Monospace,
+                egui::FontId::monospace(14.0),
                 if theme.dark_mode {
                     egui::Color32::LIGHT_GRAY
                 } else {
@@ -371,7 +364,7 @@ impl Highligher {
                     leading_space: 0.0,
                     byte_range: as_byte_range(text, range),
                     format: TextFormat {
-                        style: egui::TextStyle::Monospace,
+                        font_id: egui::FontId::monospace(14.0),
                         color: text_color,
                         italics,
                         underline,
@@ -412,7 +405,7 @@ impl Highligher {
         while !text.is_empty() {
             if text.starts_with("//") {
                 let end = text.find('\n').unwrap_or_else(|| text.len());
-                job.append(&text[..end], 0.0, theme.formats[TokenType::Comment]);
+                job.append(&text[..end], 0.0, theme.formats[TokenType::Comment].clone());
                 text = &text[end..];
             } else if text.starts_with('"') {
                 let end = text[1..]
@@ -420,7 +413,11 @@ impl Highligher {
                     .map(|i| i + 2)
                     .or_else(|| text.find('\n'))
                     .unwrap_or_else(|| text.len());
-                job.append(&text[..end], 0.0, theme.formats[TokenType::StringLiteral]);
+                job.append(
+                    &text[..end],
+                    0.0,
+                    theme.formats[TokenType::StringLiteral].clone(),
+                );
                 text = &text[end..];
             } else if text.starts_with(|c: char| c.is_ascii_alphanumeric()) {
                 let end = text[1..]
@@ -432,19 +429,27 @@ impl Highligher {
                 } else {
                     TokenType::Literal
                 };
-                job.append(word, 0.0, theme.formats[tt]);
+                job.append(word, 0.0, theme.formats[tt].clone());
                 text = &text[end..];
             } else if text.starts_with(|c: char| c.is_ascii_whitespace()) {
                 let end = text[1..]
                     .find(|c: char| !c.is_ascii_whitespace())
                     .map_or_else(|| text.len(), |i| i + 1);
-                job.append(&text[..end], 0.0, theme.formats[TokenType::Whitespace]);
+                job.append(
+                    &text[..end],
+                    0.0,
+                    theme.formats[TokenType::Whitespace].clone(),
+                );
                 text = &text[end..];
             } else {
                 let mut it = text.char_indices();
                 it.next();
                 let end = it.next().map_or(text.len(), |(idx, _chr)| idx);
-                job.append(&text[..end], 0.0, theme.formats[TokenType::Punctuation]);
+                job.append(
+                    &text[..end],
+                    0.0,
+                    theme.formats[TokenType::Punctuation].clone(),
+                );
                 text = &text[end..];
             }
         }
diff --git a/egui_demo_lib/src/wrap_app.rs b/egui_demo_lib/src/wrap_app.rs
index 5eed1b0b..d07bc072 100644
--- a/egui_demo_lib/src/wrap_app.rs
+++ b/egui_demo_lib/src/wrap_app.rs
@@ -44,7 +44,7 @@ impl epi::App for WrapApp {
 
     fn setup(
         &mut self,
-        _ctx: &egui::CtxRef,
+        _ctx: &egui::Context,
         _frame: &epi::Frame,
         _storage: Option<&dyn epi::Storage>,
     ) {
@@ -67,12 +67,7 @@ impl epi::App for WrapApp {
         egui::Rgba::TRANSPARENT // we set a `CentralPanel` fill color in `demo_windows.rs`
     }
 
-    fn warm_up_enabled(&self) -> bool {
-        // The example windows use a lot of emojis. Pre-cache them by running one frame where everything is open
-        cfg!(not(debug_assertions))
-    }
-
-    fn update(&mut self, ctx: &egui::CtxRef, frame: &epi::Frame) {
+    fn update(&mut self, ctx: &egui::Context, frame: &epi::Frame) {
         if let Some(web_info) = frame.info().web_info.as_ref() {
             if let Some(anchor) = web_info.web_location_hash.strip_prefix('#') {
                 self.selected_anchor = anchor.to_owned();
@@ -165,7 +160,7 @@ impl WrapApp {
         });
     }
 
-    fn ui_file_drag_and_drop(&mut self, ctx: &egui::CtxRef) {
+    fn ui_file_drag_and_drop(&mut self, ctx: &egui::Context) {
         use egui::*;
 
         // Preview hovering files:
@@ -190,7 +185,7 @@ impl WrapApp {
                 screen_rect.center(),
                 Align2::CENTER_CENTER,
                 text,
-                TextStyle::Heading,
+                TextStyle::Heading.resolve(&ctx.style()),
                 Color32::WHITE,
             );
         }
diff --git a/egui_extras/Cargo.toml b/egui_extras/Cargo.toml
index af97659b..6f46313b 100644
--- a/egui_extras/Cargo.toml
+++ b/egui_extras/Cargo.toml
@@ -18,13 +18,11 @@ include = ["../LICENSE-APACHE", "../LICENSE-MIT", "**/*.rs", "Cargo.toml"]
 [dependencies]
 egui = { version = "0.16.0", path = "../egui", default-features = false }
 
-# feature "datetime":
 chrono = { version = "0.4", optional = true }
 
 # feature "persistence":
 serde = { version = "1", features = ["derive"], optional = true }
 
 [features]
-default = ["datetime"]
-datetime = ["chrono"]
+default = ["chrono"]
 persistence = ["serde"]
diff --git a/egui_extras/src/lib.rs b/egui_extras/src/lib.rs
index 14510e50..a32b485e 100644
--- a/egui_extras/src/lib.rs
+++ b/egui_extras/src/lib.rs
@@ -1,11 +1,15 @@
+#[cfg(feature = "chrono")]
 mod datepicker;
+
 mod grid;
 mod layout;
 mod padding;
 mod sizing;
 mod table;
 
+#[cfg(feature = "chrono")]
 pub use datepicker::DatePickerButton;
+
 pub use grid::*;
 pub(crate) use layout::Layout;
 pub use padding::Padding;
diff --git a/egui_glium/CHANGELOG.md b/egui_glium/CHANGELOG.md
index c01cd4ae..3de396f5 100644
--- a/egui_glium/CHANGELOG.md
+++ b/egui_glium/CHANGELOG.md
@@ -3,6 +3,9 @@ All notable changes to the `egui_glium` integration will be noted in this file.
 
 
 ## Unreleased
+* `EguiGlium::run` no longer returns the shapes to paint, but stores them internally until you call `EguiGlium::paint` ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Optimize the painter and texture uploading ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
 
 
 ## 0.16.0 - 2021-12-29
diff --git a/egui_glium/Cargo.toml b/egui_glium/Cargo.toml
index 8f6634bb..654f9ddb 100644
--- a/egui_glium/Cargo.toml
+++ b/egui_glium/Cargo.toml
@@ -22,15 +22,6 @@ include = [
 [package.metadata.docs.rs]
 all-features = true
 
-[dependencies]
-egui = { version = "0.16.0", path = "../egui", default-features = false, features = ["single_threaded"] }
-egui-winit = { version = "0.16.0", path = "../egui-winit", default-features = false, features = ["epi"] }
-epi = { version = "0.16.0", path = "../epi", optional = true }
-
-glium = "0.31"
-
-[dev-dependencies]
-image = { version = "0.23", default-features = false, features = ["png"] }
 
 [features]
 default = ["clipboard", "default_fonts", "links", "persistence"]
@@ -46,6 +37,7 @@ default_fonts = ["egui/default_fonts"]
 # enable opening links in a browser when an egui hyperlink is clicked.
 links = ["egui-winit/links"]
 
+# enable persisting native window options and egui memory
 persistence = [
   "egui-winit/persistence",
   "egui/persistence",
@@ -56,3 +48,19 @@ persistence = [
 
 # experimental support for a screen reader
 screen_reader = ["egui-winit/screen_reader"]
+
+
+[dependencies]
+egui = { version = "0.16.0", path = "../egui", default-features = false, features = [
+  "convert_bytemuck",
+  "single_threaded",
+] }
+egui-winit = { version = "0.16.0", path = "../egui-winit", default-features = false, features = ["epi"] }
+epi = { version = "0.16.0", path = "../epi", optional = true }
+
+ahash = "0.7"
+bytemuck = "1.7"
+glium = "0.31"
+
+[dev-dependencies]
+image = { version = "0.24", default-features = false, features = ["png"] }
diff --git a/egui_glium/examples/native_texture.rs b/egui_glium/examples/native_texture.rs
index 4c2b7a21..821c3c87 100644
--- a/egui_glium/examples/native_texture.rs
+++ b/egui_glium/examples/native_texture.rs
@@ -62,7 +62,7 @@ fn main() {
         let mut redraw = || {
             let mut quit = false;
 
-            let (needs_repaint, shapes) = egui_glium.run(&display, |egui_ctx| {
+            let needs_repaint = egui_glium.run(&display, |egui_ctx| {
                 egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
                     if ui
                         .add(egui::Button::image_and_text(
@@ -98,7 +98,7 @@ fn main() {
 
                 // draw things behind egui here
 
-                egui_glium.paint(&display, &mut target, shapes);
+                egui_glium.paint(&display, &mut target);
 
                 // draw things on top of egui here
 
diff --git a/egui_glium/examples/pure_glium.rs b/egui_glium/examples/pure_glium.rs
index 0578f4c9..52808d7b 100644
--- a/egui_glium/examples/pure_glium.rs
+++ b/egui_glium/examples/pure_glium.rs
@@ -32,7 +32,7 @@ fn main() {
         let mut redraw = || {
             let mut quit = false;
 
-            let (needs_repaint, shapes) = egui_glium.run(&display, |egui_ctx| {
+            let needs_repaint = egui_glium.run(&display, |egui_ctx| {
                 egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
                     ui.heading("Hello World!");
                     if ui.button("Quit").clicked() {
@@ -59,7 +59,7 @@ fn main() {
 
                 // draw things behind egui here
 
-                egui_glium.paint(&display, &mut target, shapes);
+                egui_glium.paint(&display, &mut target);
 
                 // draw things on top of egui here
 
diff --git a/egui_glium/src/epi_backend.rs b/egui_glium/src/epi_backend.rs
index 001b6a66..b22a5075 100644
--- a/egui_glium/src/epi_backend.rs
+++ b/egui_glium/src/epi_backend.rs
@@ -47,6 +47,7 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
     let mut painter = crate::Painter::new(&display);
     let mut integration = egui_winit::epi::EpiIntegration::new(
         "egui_glium",
+        painter.max_texture_side(),
         display.gl_window().window(),
         repaint_signal,
         persistence,
@@ -66,12 +67,12 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
                 std::thread::sleep(std::time::Duration::from_millis(10));
             }
 
-            let (needs_repaint, mut tex_allocation_data, shapes) =
+            let (needs_repaint, mut textures_delta, shapes) =
                 integration.update(display.gl_window().window());
             let clipped_meshes = integration.egui_ctx.tessellate(shapes);
 
-            for (id, image) in tex_allocation_data.creations {
-                painter.set_texture(&display, id, &image);
+            for (id, image_delta) in textures_delta.set {
+                painter.set_texture(&display, id, &image_delta);
             }
 
             // paint:
@@ -86,13 +87,12 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
                     &mut target,
                     integration.egui_ctx.pixels_per_point(),
                     clipped_meshes,
-                    &integration.egui_ctx.font_image(),
                 );
 
                 target.finish().unwrap();
             }
 
-            for id in tex_allocation_data.destructions.drain(..) {
+            for id in textures_delta.free.drain(..) {
                 painter.free_texture(id);
             }
 
diff --git a/egui_glium/src/lib.rs b/egui_glium/src/lib.rs
index 69c9645f..50426289 100644
--- a/egui_glium/src/lib.rs
+++ b/egui_glium/src/lib.rs
@@ -101,17 +101,26 @@ pub use egui_winit;
 
 /// Convenience wrapper for using [`egui`] from a [`glium`] app.
 pub struct EguiGlium {
-    pub egui_ctx: egui::CtxRef,
+    pub egui_ctx: egui::Context,
     pub egui_winit: egui_winit::State,
     pub painter: crate::Painter,
+
+    shapes: Vec<egui::epaint::ClippedShape>,
+    textures_delta: egui::TexturesDelta,
 }
 
 impl EguiGlium {
     pub fn new(display: &glium::Display) -> Self {
+        let painter = crate::Painter::new(display);
         Self {
             egui_ctx: Default::default(),
-            egui_winit: egui_winit::State::new(display.gl_window().window()),
-            painter: crate::Painter::new(display),
+            egui_winit: egui_winit::State::new(
+                painter.max_texture_side(),
+                display.gl_window().window(),
+            ),
+            painter,
+            shapes: Default::default(),
+            textures_delta: Default::default(),
         }
     }
 
@@ -125,35 +134,45 @@ impl EguiGlium {
         self.egui_winit.on_event(&self.egui_ctx, event)
     }
 
-    /// Returns `needs_repaint` and shapes to draw.
-    pub fn run(
-        &mut self,
-        display: &glium::Display,
-        run_ui: impl FnMut(&egui::CtxRef),
-    ) -> (bool, Vec<egui::epaint::ClippedShape>) {
+    /// Returns `true` if egui requests a repaint.
+    ///
+    /// Call [`Self::paint`] later to paint.
+    pub fn run(&mut self, display: &glium::Display, run_ui: impl FnMut(&egui::Context)) -> bool {
         let raw_input = self
             .egui_winit
             .take_egui_input(display.gl_window().window());
         let (egui_output, shapes) = self.egui_ctx.run(raw_input, run_ui);
         let needs_repaint = egui_output.needs_repaint;
-        self.egui_winit
-            .handle_output(display.gl_window().window(), &self.egui_ctx, egui_output);
-        (needs_repaint, shapes)
+        let textures_delta = self.egui_winit.handle_output(
+            display.gl_window().window(),
+            &self.egui_ctx,
+            egui_output,
+        );
+
+        self.shapes = shapes;
+        self.textures_delta.append(textures_delta);
+        needs_repaint
     }
 
-    pub fn paint<T: glium::Surface>(
-        &mut self,
-        display: &glium::Display,
-        target: &mut T,
-        shapes: Vec<egui::epaint::ClippedShape>,
-    ) {
+    /// Paint the results of the last call to [`Self::run`].
+    pub fn paint<T: glium::Surface>(&mut self, display: &glium::Display, target: &mut T) {
+        let shapes = std::mem::take(&mut self.shapes);
+        let mut textures_delta = std::mem::take(&mut self.textures_delta);
+
+        for (id, image_delta) in textures_delta.set {
+            self.painter.set_texture(display, id, &image_delta);
+        }
+
         let clipped_meshes = self.egui_ctx.tessellate(shapes);
         self.painter.paint_meshes(
             display,
             target,
             self.egui_ctx.pixels_per_point(),
             clipped_meshes,
-            &self.egui_ctx.font_image(),
         );
+
+        for id in textures_delta.free.drain(..) {
+            self.painter.free_texture(id);
+        }
     }
 }
diff --git a/egui_glium/src/painter.rs b/egui_glium/src/painter.rs
index d6735d63..b176a2f7 100644
--- a/egui_glium/src/painter.rs
+++ b/egui_glium/src/painter.rs
@@ -2,10 +2,8 @@
 #![allow(semicolon_in_expressions_from_macros)] // glium::program! macro
 
 use {
-    egui::{
-        emath::Rect,
-        epaint::{Color32, Mesh},
-    },
+    ahash::AHashMap,
+    egui::{emath::Rect, epaint::Mesh},
     glium::{
         implement_vertex,
         index::PrimitiveType,
@@ -14,23 +12,25 @@ use {
         uniform,
         uniforms::{MagnifySamplerFilter, SamplerWrapFunction},
     },
-    std::{collections::HashMap, rc::Rc},
+    std::rc::Rc,
 };
 
 pub struct Painter {
+    max_texture_side: usize,
     program: glium::Program,
-    egui_texture: Option<SrgbTexture2d>,
-    egui_texture_version: Option<u64>,
 
-    /// Index is the same as in [`egui::TextureId::User`].
-    user_textures: HashMap<u64, Rc<SrgbTexture2d>>,
+    textures: AHashMap<egui::TextureId, Rc<SrgbTexture2d>>,
 
     #[cfg(feature = "epi")]
-    next_native_tex_id: u64, // TODO: 128-bit texture space?
+    /// [`egui::TextureId::User`] index
+    next_native_tex_id: u64,
 }
 
 impl Painter {
     pub fn new(facade: &dyn glium::backend::Facade) -> Painter {
+        use glium::CapabilitiesSource as _;
+        let max_texture_side = facade.get_capabilities().max_texture_size as _;
+
         let program = program! {
             facade,
             120 => {
@@ -53,39 +53,16 @@ impl Painter {
         .expect("Failed to compile shader");
 
         Painter {
+            max_texture_side,
             program,
-            egui_texture: None,
-            egui_texture_version: None,
-            user_textures: Default::default(),
+            textures: Default::default(),
             #[cfg(feature = "epi")]
-            next_native_tex_id: 1 << 32,
+            next_native_tex_id: 0,
         }
     }
 
-    pub fn upload_egui_texture(
-        &mut self,
-        facade: &dyn glium::backend::Facade,
-        font_image: &egui::FontImage,
-    ) {
-        if self.egui_texture_version == Some(font_image.version) {
-            return; // No change
-        }
-
-        let pixels: Vec<Vec<(u8, u8, u8, u8)>> = font_image
-            .pixels
-            .chunks(font_image.width as usize)
-            .map(|row| {
-                row.iter()
-                    .map(|&a| Color32::from_white_alpha(a).to_tuple())
-                    .collect()
-            })
-            .collect();
-
-        let format = texture::SrgbFormat::U8U8U8U8;
-        let mipmaps = texture::MipmapsOption::NoMipmap;
-        self.egui_texture =
-            Some(SrgbTexture2d::with_format(facade, pixels, format, mipmaps).unwrap());
-        self.egui_texture_version = Some(font_image.version);
+    pub fn max_texture_side(&self) -> usize {
+        self.max_texture_side
     }
 
     /// Main entry-point for painting a frame.
@@ -97,10 +74,7 @@ impl Painter {
         target: &mut T,
         pixels_per_point: f32,
         cipped_meshes: Vec<egui::ClippedMesh>,
-        font_image: &egui::FontImage,
     ) {
-        self.upload_egui_texture(display, font_image);
-
         for egui::ClippedMesh(clip_rect, mesh) in cipped_meshes {
             self.paint_mesh(target, display, pixels_per_point, clip_rect, &mesh);
         }
@@ -118,7 +92,8 @@ impl Painter {
         debug_assert!(mesh.is_valid());
 
         let vertex_buffer = {
-            #[derive(Copy, Clone)]
+            #[repr(C)]
+            #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
             struct Vertex {
                 a_pos: [f32; 2],
                 a_tc: [f32; 2],
@@ -126,18 +101,10 @@ impl Painter {
             }
             implement_vertex!(Vertex, a_pos, a_tc, a_srgba);
 
-            let vertices: Vec<Vertex> = mesh
-                .vertices
-                .iter()
-                .map(|v| Vertex {
-                    a_pos: [v.pos.x, v.pos.y],
-                    a_tc: [v.uv.x, v.uv.y],
-                    a_srgba: v.color.to_array(),
-                })
-                .collect();
+            let vertices: &[Vertex] = bytemuck::cast_slice(&mesh.vertices);
 
             // TODO: we should probably reuse the `VertexBuffer` instead of allocating a new one each frame.
-            glium::VertexBuffer::new(display, &vertices).unwrap()
+            glium::VertexBuffer::new(display, vertices).unwrap()
         };
 
         // TODO: we should probably reuse the `IndexBuffer` instead of allocating a new one each frame.
@@ -223,41 +190,62 @@ impl Painter {
 
     // ------------------------------------------------------------------------
 
-    #[cfg(feature = "epi")]
     pub fn set_texture(
         &mut self,
         facade: &dyn glium::backend::Facade,
-        tex_id: u64,
-        image: &epi::Image,
+        tex_id: egui::TextureId,
+        delta: &egui::epaint::ImageDelta,
     ) {
-        assert_eq!(
-            image.size[0] * image.size[1],
-            image.pixels.len(),
-            "Mismatch between texture size and texel count"
-        );
-
-        let pixels: Vec<Vec<(u8, u8, u8, u8)>> = image
-            .pixels
-            .chunks(image.size[0] as usize)
-            .map(|row| row.iter().map(|srgba| srgba.to_tuple()).collect())
-            .collect();
-
+        let pixels: Vec<(u8, u8, u8, u8)> = match &delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+                image.pixels.iter().map(|color| color.to_tuple()).collect()
+            }
+            egui::ImageData::Alpha(image) => {
+                let gamma = 1.0;
+                image
+                    .srgba_pixels(gamma)
+                    .map(|color| color.to_tuple())
+                    .collect()
+            }
+        };
+        let glium_image = glium::texture::RawImage2d {
+            data: std::borrow::Cow::Owned(pixels),
+            width: delta.image.width() as _,
+            height: delta.image.height() as _,
+            format: glium::texture::ClientFormat::U8U8U8U8,
+        };
         let format = texture::SrgbFormat::U8U8U8U8;
         let mipmaps = texture::MipmapsOption::NoMipmap;
-        let gl_texture = SrgbTexture2d::with_format(facade, pixels, format, mipmaps).unwrap();
 
-        self.user_textures.insert(tex_id, gl_texture.into());
+        if let Some(pos) = delta.pos {
+            // update a sub-region
+            if let Some(gl_texture) = self.textures.get(&tex_id) {
+                let rect = glium::Rect {
+                    left: pos[0] as _,
+                    bottom: pos[1] as _,
+                    width: glium_image.width,
+                    height: glium_image.height,
+                };
+                gl_texture.main_level().write(rect, glium_image);
+            }
+        } else {
+            let gl_texture =
+                SrgbTexture2d::with_format(facade, glium_image, format, mipmaps).unwrap();
+            self.textures.insert(tex_id, gl_texture.into());
+        }
     }
 
-    pub fn free_texture(&mut self, tex_id: u64) {
-        self.user_textures.remove(&tex_id);
+    pub fn free_texture(&mut self, tex_id: egui::TextureId) {
+        self.textures.remove(&tex_id);
     }
 
     fn get_texture(&self, texture_id: egui::TextureId) -> Option<&SrgbTexture2d> {
-        match texture_id {
-            egui::TextureId::Egui => self.egui_texture.as_ref(),
-            egui::TextureId::User(id) => self.user_textures.get(&id).map(|rc| rc.as_ref()),
-        }
+        self.textures.get(&texture_id).map(|rc| rc.as_ref())
     }
 }
 
@@ -266,15 +254,13 @@ impl epi::NativeTexture for Painter {
     type Texture = Rc<SrgbTexture2d>;
 
     fn register_native_texture(&mut self, native: Self::Texture) -> egui::TextureId {
-        let id = self.next_native_tex_id;
+        let id = egui::TextureId::User(self.next_native_tex_id);
         self.next_native_tex_id += 1;
-        self.user_textures.insert(id, native);
-        egui::TextureId::User(id as u64)
+        self.textures.insert(id, native);
+        id
     }
 
     fn replace_native_texture(&mut self, id: egui::TextureId, replacing: Self::Texture) {
-        if let egui::TextureId::User(id) = id {
-            self.user_textures.insert(id, replacing);
-        }
+        self.textures.insert(id, replacing);
     }
 }
diff --git a/egui_glow/CHANGELOG.md b/egui_glow/CHANGELOG.md
index 4d107dcb..b5bcdb6d 100644
--- a/egui_glow/CHANGELOG.md
+++ b/egui_glow/CHANGELOG.md
@@ -3,7 +3,13 @@ All notable changes to the `egui_glow` integration will be noted in this file.
 
 
 ## Unreleased
-* Added `set_texture_filter` method to `Painter` ((#1041)[https://github.com/emilk/egui/pull/1041]).
+* `EguiGlow::run` no longer returns the shapes to paint, but stores them internally until you call `EguiGlow::paint` ([#1110](https://github.com/emilk/egui/pull/1110)).
+* Added `set_texture_filter` method to `Painter` ([#1041](https://github.com/emilk/egui/pull/1041)).
+* Fix failure to run in Chrome ([#1092](https://github.com/emilk/egui/pull/1092)).
+* `EguiGlow::new` now takes `&winit::Window` because there are no reason to use `&glutin::WindowedContext` ([#1151](https://github.com/emilk/egui/pull/1151)).
+* `EguiGlow::paint` now takes `&winit::Window` because there are no reason to use `&glutin::WindowedContext` ([#1151](https://github.com/emilk/egui/pull/1151)).
+* Automatically detect and apply dark or light mode from system ([#1045](https://github.com/emilk/egui/pull/1045)).
+
 
 ## 0.16.0 - 2021-12-29
 * Made winit/glutin an optional dependency ([#868](https://github.com/emilk/egui/pull/868)).
diff --git a/egui_glow/Cargo.toml b/egui_glow/Cargo.toml
index 8945b5f0..fe6870ee 100644
--- a/egui_glow/Cargo.toml
+++ b/egui_glow/Cargo.toml
@@ -22,23 +22,6 @@ include = [
 [package.metadata.docs.rs]
 all-features = true
 
-[dependencies]
-egui = { version = "0.16.0", path = "../egui", default-features = false, features = ["single_threaded"] }
-
-epi = { version = "0.16.0", path = "../epi", optional = true }
-glow = "0.11"
-memoffset = "0.6"
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-egui-winit = { version = "0.16.0", path = "../egui-winit", default-features = false, features = ["epi"], optional = true }
-glutin = { version = "0.28.0", optional = true }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-web-sys = { version = "0.3", features=["console"] }
-wasm-bindgen = { version = "0.2" }
-
-[dev-dependencies]
-image = { version = "0.23", default-features = false, features = ["png"] }
 
 [features]
 default = ["clipboard", "default_fonts", "links", "persistence", "winit"]
@@ -54,7 +37,7 @@ default_fonts = ["egui/default_fonts"]
 # enable opening links in a browser when an egui hyperlink is clicked.
 links = ["egui-winit/links"]
 
-# enable code for sabing
+# enable persisting native window options and egui memory
 persistence = [
   "egui-winit/persistence",
   "egui/persistence",
@@ -67,6 +50,29 @@ persistence = [
 screen_reader = ["egui-winit/screen_reader"]
 
 # enable glutin/winit integration.
-# if you want to use glow painter on web disable it.
-# if disabled reduce crate size and build time.
+# if you want to use glow painter on web disable this feature.
 winit = ["egui-winit", "glutin"]
+
+
+[dependencies]
+egui = { version = "0.16.0", path = "../egui", default-features = false, features = [
+  "convert_bytemuck",
+  "single_threaded",
+] }
+epi = { version = "0.16.0", path = "../epi", optional = true }
+
+bytemuck = "1.7"
+glow = "0.11"
+memoffset = "0.6"
+tracing = "0.1"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+egui-winit = { version = "0.16.0", path = "../egui-winit", default-features = false, features = ["dark-light", "epi"], optional = true }
+glutin = { version = "0.28.0", optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+web-sys = { version = "0.3", features=["console"] }
+wasm-bindgen = { version = "0.2" }
+
+[dev-dependencies]
+image = { version = "0.24", default-features = false, features = ["png"] }
diff --git a/egui_glow/examples/pure_glow.rs b/egui_glow/examples/pure_glow.rs
index e954fb2a..a6196dbd 100644
--- a/egui_glow/examples/pure_glow.rs
+++ b/egui_glow/examples/pure_glow.rs
@@ -44,13 +44,13 @@ fn main() {
     let event_loop = glutin::event_loop::EventLoop::with_user_event();
     let (gl_window, gl) = create_display(&event_loop);
 
-    let mut egui_glow = egui_glow::EguiGlow::new(&gl_window, &gl);
+    let mut egui_glow = egui_glow::EguiGlow::new(gl_window.window(), &gl);
 
     event_loop.run(move |event, _, control_flow| {
         let mut redraw = || {
             let mut quit = false;
 
-            let (needs_repaint, shapes) = egui_glow.run(gl_window.window(), |egui_ctx| {
+            let needs_repaint = egui_glow.run(gl_window.window(), |egui_ctx| {
                 egui::SidePanel::left("my_side_panel").show(egui_ctx, |ui| {
                     ui.heading("Hello World!");
                     if ui.button("Quit").clicked() {
@@ -78,7 +78,7 @@ fn main() {
 
                 // draw things behind egui here
 
-                egui_glow.paint(&gl_window, &gl, shapes);
+                egui_glow.paint(gl_window.window(), &gl);
 
                 // draw things on top of egui here
 
diff --git a/egui_glow/src/epi_backend.rs b/egui_glow/src/epi_backend.rs
index 8b48ee7a..fef06d10 100644
--- a/egui_glow/src/epi_backend.rs
+++ b/egui_glow/src/epi_backend.rs
@@ -1,8 +1,9 @@
 use crate::*;
+use egui_winit::winit;
 
 struct RequestRepaintEvent;
 
-struct GlowRepaintSignal(std::sync::Mutex<glutin::event_loop::EventLoopProxy<RequestRepaintEvent>>);
+struct GlowRepaintSignal(std::sync::Mutex<winit::event_loop::EventLoopProxy<RequestRepaintEvent>>);
 
 impl epi::backend::RepaintSignal for GlowRepaintSignal {
     fn request_repaint(&self) {
@@ -12,8 +13,8 @@ impl epi::backend::RepaintSignal for GlowRepaintSignal {
 
 #[allow(unsafe_code)]
 fn create_display(
-    window_builder: glutin::window::WindowBuilder,
-    event_loop: &glutin::event_loop::EventLoop<RequestRepaintEvent>,
+    window_builder: winit::window::WindowBuilder,
+    event_loop: &winit::event_loop::EventLoop<RequestRepaintEvent>,
 ) -> (
     glutin::WindowedContext<glutin::PossiblyCurrent>,
     glow::Context,
@@ -51,7 +52,7 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
     let window_settings = persistence.load_window_settings();
     let window_builder =
         egui_winit::epi::window_builder(native_options, &window_settings).with_title(app.name());
-    let event_loop = glutin::event_loop::EventLoop::with_user_event();
+    let event_loop = winit::event_loop::EventLoop::with_user_event();
     let (gl_window, gl) = create_display(window_builder, &event_loop);
 
     let repaint_signal = std::sync::Arc::new(GlowRepaintSignal(std::sync::Mutex::new(
@@ -59,10 +60,10 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
     )));
 
     let mut painter = crate::Painter::new(&gl, None, "")
-        .map_err(|error| eprintln!("some OpenGL error occurred {}\n", error))
-        .unwrap();
+        .unwrap_or_else(|error| panic!("some OpenGL error occurred {}\n", error));
     let mut integration = egui_winit::epi::EpiIntegration::new(
         "egui_glow",
+        painter.max_texture_side(),
         gl_window.window(),
         repaint_signal,
         persistence,
@@ -82,12 +83,12 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
                 std::thread::sleep(std::time::Duration::from_millis(10));
             }
 
-            let (needs_repaint, mut tex_allocation_data, shapes) =
+            let (needs_repaint, mut textures_delta, shapes) =
                 integration.update(gl_window.window());
             let clipped_meshes = integration.egui_ctx.tessellate(shapes);
 
-            for (id, image) in tex_allocation_data.creations {
-                painter.set_texture(&gl, id, &image);
+            for (id, image_delta) in textures_delta.set {
+                painter.set_texture(&gl, id, &image_delta);
             }
 
             // paint:
@@ -99,7 +100,6 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
                     gl.clear_color(color[0], color[1], color[2], color[3]);
                     gl.clear(glow::COLOR_BUFFER_BIT);
                 }
-                painter.upload_egui_texture(&gl, &integration.egui_ctx.font_image());
                 painter.paint_meshes(
                     &gl,
                     gl_window.window().inner_size().into(),
@@ -110,18 +110,18 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
                 gl_window.swap_buffers().unwrap();
             }
 
-            for id in tex_allocation_data.destructions.drain(..) {
-                painter.free_texture(id);
+            for id in textures_delta.free.drain(..) {
+                painter.free_texture(&gl, id);
             }
 
             {
                 *control_flow = if integration.should_quit() {
-                    glutin::event_loop::ControlFlow::Exit
+                    winit::event_loop::ControlFlow::Exit
                 } else if needs_repaint {
                     gl_window.window().request_redraw();
-                    glutin::event_loop::ControlFlow::Poll
+                    winit::event_loop::ControlFlow::Poll
                 } else {
-                    glutin::event_loop::ControlFlow::Wait
+                    winit::event_loop::ControlFlow::Wait
                 };
             }
 
@@ -132,30 +132,30 @@ pub fn run(app: Box<dyn epi::App>, native_options: &epi::NativeOptions) -> ! {
             // Platform-dependent event handlers to workaround a winit bug
             // See: https://github.com/rust-windowing/winit/issues/987
             // See: https://github.com/rust-windowing/winit/issues/1619
-            glutin::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
-            glutin::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
+            winit::event::Event::RedrawEventsCleared if cfg!(windows) => redraw(),
+            winit::event::Event::RedrawRequested(_) if !cfg!(windows) => redraw(),
 
-            glutin::event::Event::WindowEvent { event, .. } => {
-                if let glutin::event::WindowEvent::Focused(new_focused) = event {
+            winit::event::Event::WindowEvent { event, .. } => {
+                if let winit::event::WindowEvent::Focused(new_focused) = event {
                     is_focused = new_focused;
                 }
 
-                if let glutin::event::WindowEvent::Resized(physical_size) = event {
+                if let winit::event::WindowEvent::Resized(physical_size) = event {
                     gl_window.resize(physical_size);
                 }
 
                 integration.on_event(&event);
                 if integration.should_quit() {
-                    *control_flow = glutin::event_loop::ControlFlow::Exit;
+                    *control_flow = winit::event_loop::ControlFlow::Exit;
                 }
 
                 gl_window.window().request_redraw(); // TODO: ask egui if the events warrants a repaint instead
             }
-            glutin::event::Event::LoopDestroyed => {
+            winit::event::Event::LoopDestroyed => {
                 integration.on_exit(gl_window.window());
                 painter.destroy(&gl);
             }
-            glutin::event::Event::UserEvent(RequestRepaintEvent) => {
+            winit::event::Event::UserEvent(RequestRepaintEvent) => {
                 gl_window.window().request_redraw();
             }
             _ => (),
diff --git a/egui_glow/src/lib.rs b/egui_glow/src/lib.rs
index c7878585..84b91209 100644
--- a/egui_glow/src/lib.rs
+++ b/egui_glow/src/lib.rs
@@ -88,6 +88,8 @@
 #![allow(clippy::manual_range_contains)]
 
 pub mod painter;
+#[cfg(feature = "winit")]
+use egui_winit::winit;
 pub use glow;
 pub use painter::Painter;
 #[cfg(feature = "winit")]
@@ -109,25 +111,29 @@ pub use epi_backend::{run, NativeOptions};
 /// Use [`egui`] from a [`glow`] app.
 #[cfg(feature = "winit")]
 pub struct EguiGlow {
-    pub egui_ctx: egui::CtxRef,
+    pub egui_ctx: egui::Context,
     pub egui_winit: egui_winit::State,
     pub painter: crate::Painter,
+
+    shapes: Vec<egui::epaint::ClippedShape>,
+    textures_delta: egui::TexturesDelta,
 }
 
 #[cfg(feature = "winit")]
 impl EguiGlow {
-    pub fn new(
-        gl_window: &glutin::WindowedContext<glutin::PossiblyCurrent>,
-        gl: &glow::Context,
-    ) -> Self {
+    pub fn new(window: &winit::window::Window, gl: &glow::Context) -> Self {
+        let painter = crate::Painter::new(gl, None, "")
+            .map_err(|error| {
+                tracing::error!("error occurred in initializing painter:\n{}", error);
+            })
+            .unwrap();
+
         Self {
             egui_ctx: Default::default(),
-            egui_winit: egui_winit::State::new(gl_window.window()),
-            painter: crate::Painter::new(gl, None, "")
-                .map_err(|error| {
-                    eprintln!("some error occurred in initializing painter\n{}", error);
-                })
-                .unwrap(),
+            egui_winit: egui_winit::State::new(painter.max_texture_side(), window),
+            painter,
+            shapes: Default::default(),
+            textures_delta: Default::default(),
         }
     }
 
@@ -137,40 +143,51 @@ impl EguiGlow {
     /// and only when this returns `false` pass on the events to your game.
     ///
     /// Note that egui uses `tab` to move focus between elements, so this will always return `true` for tabs.
-    pub fn on_event(&mut self, event: &glutin::event::WindowEvent<'_>) -> bool {
+    pub fn on_event(&mut self, event: &winit::event::WindowEvent<'_>) -> bool {
         self.egui_winit.on_event(&self.egui_ctx, event)
     }
 
-    /// Returns `needs_repaint` and shapes to draw.
+    /// Returns `true` if egui requests a repaint.
+    ///
+    /// Call [`Self::paint`] later to paint.
     pub fn run(
         &mut self,
-        window: &glutin::window::Window,
-        run_ui: impl FnMut(&egui::CtxRef),
-    ) -> (bool, Vec<egui::epaint::ClippedShape>) {
+        window: &winit::window::Window,
+        run_ui: impl FnMut(&egui::Context),
+    ) -> bool {
         let raw_input = self.egui_winit.take_egui_input(window);
         let (egui_output, shapes) = self.egui_ctx.run(raw_input, run_ui);
         let needs_repaint = egui_output.needs_repaint;
-        self.egui_winit
+        let textures_delta = self
+            .egui_winit
             .handle_output(window, &self.egui_ctx, egui_output);
-        (needs_repaint, shapes)
+
+        self.shapes = shapes;
+        self.textures_delta.append(textures_delta);
+        needs_repaint
     }
 
-    pub fn paint(
-        &mut self,
-        gl_window: &glutin::WindowedContext<glutin::PossiblyCurrent>,
-        gl: &glow::Context,
-        shapes: Vec<egui::epaint::ClippedShape>,
-    ) {
+    /// Paint the results of the last call to [`Self::run`].
+    pub fn paint(&mut self, window: &winit::window::Window, gl: &glow::Context) {
+        let shapes = std::mem::take(&mut self.shapes);
+        let mut textures_delta = std::mem::take(&mut self.textures_delta);
+
+        for (id, image_delta) in textures_delta.set {
+            self.painter.set_texture(gl, id, &image_delta);
+        }
+
         let clipped_meshes = self.egui_ctx.tessellate(shapes);
-        let dimensions: [u32; 2] = gl_window.window().inner_size().into();
-        self.painter
-            .upload_egui_texture(gl, &self.egui_ctx.font_image());
+        let dimensions: [u32; 2] = window.inner_size().into();
         self.painter.paint_meshes(
             gl,
             dimensions,
             self.egui_ctx.pixels_per_point(),
             clipped_meshes,
         );
+
+        for id in textures_delta.free.drain(..) {
+            self.painter.free_texture(gl, id);
+        }
     }
 
     /// Call to release the allocated graphics resources.
diff --git a/egui_glow/src/misc_util.rs b/egui_glow/src/misc_util.rs
index 7c711813..4547c261 100644
--- a/egui_glow/src/misc_util.rs
+++ b/egui_glow/src/misc_util.rs
@@ -2,93 +2,18 @@
 use glow::HasContext;
 use std::option::Option::Some;
 
-use crate::painter::TextureFilter;
-
-pub(crate) fn srgbtexture2d(
-    gl: &glow::Context,
-    is_webgl_1: bool,
-    srgb_support: bool,
-    texture_filter: TextureFilter,
-    data: &[u8],
-    w: usize,
-    h: usize,
-) -> glow::Texture {
-    assert_eq!(data.len(), w * h * 4);
-    assert!(w >= 1);
-    assert!(h >= 1);
-    unsafe {
-        let tex = gl.create_texture().unwrap();
-        gl.bind_texture(glow::TEXTURE_2D, Some(tex));
-
-        gl.tex_parameter_i32(
-            glow::TEXTURE_2D,
-            glow::TEXTURE_MAG_FILTER,
-            texture_filter.glow_code() as i32,
+pub fn check_for_gl_error(gl: &glow::Context, context: &str) {
+    let error_code = unsafe { gl.get_error() };
+    if error_code != glow::NO_ERROR {
+        tracing::error!(
+            "GL error, at: '{}', code: {} (0x{:X})",
+            context,
+            error_code,
+            error_code
         );
-        gl.tex_parameter_i32(
-            glow::TEXTURE_2D,
-            glow::TEXTURE_MIN_FILTER,
-            texture_filter.glow_code() as i32,
-        );
-        gl.tex_parameter_i32(
-            glow::TEXTURE_2D,
-            glow::TEXTURE_WRAP_S,
-            glow::CLAMP_TO_EDGE as i32,
-        );
-        gl.tex_parameter_i32(
-            glow::TEXTURE_2D,
-            glow::TEXTURE_WRAP_T,
-            glow::CLAMP_TO_EDGE as i32,
-        );
-        if is_webgl_1 {
-            let format = if srgb_support {
-                glow::SRGB_ALPHA
-            } else {
-                glow::RGBA
-            };
-            gl.tex_image_2d(
-                glow::TEXTURE_2D,
-                0,
-                format as i32,
-                w as i32,
-                h as i32,
-                0,
-                format,
-                glow::UNSIGNED_BYTE,
-                Some(data),
-            );
-        } else {
-            gl.tex_storage_2d(glow::TEXTURE_2D, 1, glow::SRGB8_ALPHA8, w as i32, h as i32);
-            gl.tex_sub_image_2d(
-                glow::TEXTURE_2D,
-                0,
-                0,
-                0,
-                w as i32,
-                h as i32,
-                glow::RGBA,
-                glow::UNSIGNED_BYTE,
-                glow::PixelUnpackData::Slice(data),
-            );
-        }
-        assert_eq!(gl.get_error(), glow::NO_ERROR, "OpenGL error occurred!");
-        tex
     }
 }
 
-pub(crate) unsafe fn as_u8_slice<T>(s: &[T]) -> &[u8] {
-    std::slice::from_raw_parts(s.as_ptr().cast::<u8>(), s.len() * std::mem::size_of::<T>())
-}
-
-#[cfg(target_arch = "wasm32")]
-pub(crate) fn glow_debug_print(s: impl std::fmt::Display) {
-    web_sys::console::log_1(&format!("egui_glow: {}", s).into());
-}
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn glow_debug_print(s: impl std::fmt::Display) {
-    eprintln!("egui_glow: {}", s);
-}
-
 pub(crate) unsafe fn compile_shader(
     gl: &glow::Context,
     shader_type: u32,
@@ -187,40 +112,36 @@ impl VAO {
 
 /// If returned true no need to emulate vao
 pub(crate) fn supports_vao(gl: &glow::Context) -> bool {
-    let web_sig = "WebGL ";
-    let es_sig = "OpenGL ES ";
+    const WEBGL_PREFIX: &str = "WebGL ";
+    const OPENGL_ES_PREFIX: &str = "OpenGL ES ";
+
     let version_string = unsafe { gl.get_parameter_string(glow::VERSION) };
-    if let Some(pos) = version_string.rfind(web_sig) {
-        let version_str = &version_string[pos + web_sig.len()..];
-        glow_debug_print(format!(
-            "detected WebGL prefix at {}:{}",
-            pos + web_sig.len(),
-            version_str
-        ));
+    tracing::debug!("GL version: {:?}.", version_string);
+
+    // Examples:
+    // * "WebGL 2.0 (OpenGL ES 3.0 Chromium)"
+    // * "WebGL 2.0"
+
+    if let Some(pos) = version_string.rfind(WEBGL_PREFIX) {
+        let version_str = &version_string[pos + WEBGL_PREFIX.len()..];
         if version_str.contains("1.0") {
-            //need to test OES_vertex_array_object .
+            // need to test OES_vertex_array_object .
             gl.supported_extensions()
                 .contains("OES_vertex_array_object")
         } else {
             true
         }
-    } else if let Some(pos) = version_string.rfind(es_sig) {
-        //glow targets es2.0+ so we don't concern about OpenGL ES-CM,OpenGL ES-CL
-        glow_debug_print(format!(
-            "detected OpenGL ES prefix at {}:{}",
-            pos + es_sig.len(),
-            &version_string[pos + es_sig.len()..]
-        ));
+    } else if version_string.contains(OPENGL_ES_PREFIX) {
+        // glow targets es2.0+ so we don't concern about OpenGL ES-CM,OpenGL ES-CL
         if version_string.contains("2.0") {
-            //need to test OES_vertex_array_object .
+            // need to test OES_vertex_array_object .
             gl.supported_extensions()
                 .contains("OES_vertex_array_object")
         } else {
             true
         }
     } else {
-        glow_debug_print(format!("detected OpenGL: {:?}", version_string));
-        //from OpenGL 3 vao into core
+        // from OpenGL 3 vao into core
         if version_string.starts_with('2') {
             // I found APPLE_vertex_array_object , GL_ATI_vertex_array_object ,ARB_vertex_array_object
             // but APPLE's and ATI's very old extension.
diff --git a/egui_glow/src/painter.rs b/egui_glow/src/painter.rs
index a23037a0..0f9d5f44 100644
--- a/egui_glow/src/painter.rs
+++ b/egui_glow/src/painter.rs
@@ -9,9 +9,7 @@ use egui::{
 use glow::HasContext;
 use memoffset::offset_of;
 
-use crate::misc_util::{
-    as_u8_slice, compile_shader, glow_debug_print, link_program, srgbtexture2d,
-};
+use crate::misc_util::{check_for_gl_error, compile_shader, link_program};
 use crate::post_process::PostProcess;
 use crate::shader_version::ShaderVersion;
 use crate::vao_emulate;
@@ -26,11 +24,11 @@ const FRAG_SRC: &str = include_str!("shader/fragment.glsl");
 /// This struct must be destroyed with [`Painter::destroy`] before dropping, to ensure OpenGL
 /// objects have been properly deleted and are not leaked.
 pub struct Painter {
+    max_texture_side: usize,
+
     program: glow::Program,
     u_screen_size: glow::UniformLocation,
     u_sampler: glow::UniformLocation,
-    egui_texture: Option<glow::Texture>,
-    egui_texture_version: Option<u64>,
     is_webgl_1: bool,
     is_embedded: bool,
     vertex_array: crate::misc_util::VAO,
@@ -41,8 +39,7 @@ pub struct Painter {
     vertex_buffer: glow::Buffer,
     element_array_buffer: glow::Buffer,
 
-    /// Index is the same as in [`egui::TextureId::User`].
-    user_textures: HashMap<u64, glow::Texture>,
+    textures: HashMap<egui::TextureId, glow::Texture>,
 
     #[cfg(feature = "epi")]
     next_native_tex_id: u64, // TODO: 128-bit texture space?
@@ -93,20 +90,24 @@ impl Painter {
         pp_fb_extent: Option<[i32; 2]>,
         shader_prefix: &str,
     ) -> Result<Painter, String> {
+        check_for_gl_error(gl, "before Painter::new");
+
+        let max_texture_side = unsafe { gl.get_parameter_i32(glow::MAX_TEXTURE_SIZE) } as usize;
+
         let support_vao = crate::misc_util::supports_vao(gl);
         let shader_version = ShaderVersion::get(gl);
         let is_webgl_1 = shader_version == ShaderVersion::Es100;
         let header = shader_version.version();
-        glow_debug_print(format!("Shader header: {:?}", header));
+        tracing::debug!("Shader header: {:?}.", header);
         let srgb_support = gl.supported_extensions().contains("EXT_sRGB");
 
         let (post_process, srgb_support_define) = match (shader_version, srgb_support) {
-            //WebGL2 support sRGB default
+            // WebGL2 support sRGB default
             (ShaderVersion::Es300, _) | (ShaderVersion::Es100, true) => unsafe {
-                //Add sRGB support marker for fragment shader
+                // Add sRGB support marker for fragment shader
                 if let Some([width, height]) = pp_fb_extent {
-                    glow_debug_print("WebGL with sRGB enabled so turn on post process");
-                    //install post process to correct sRGB color
+                    tracing::debug!("WebGL with sRGB enabled. Turning on post processing for linear framebuffer blending.");
+                    // install post process to correct sRGB color:
                     (
                         Some(PostProcess::new(
                             gl,
@@ -119,13 +120,15 @@ impl Painter {
                         "#define SRGB_SUPPORTED",
                     )
                 } else {
-                    glow_debug_print("WebGL or OpenGL ES detected but PostProcess disabled because dimension is None");
+                    tracing::debug!("WebGL or OpenGL ES detected but PostProcess disabled because dimension is None");
                     (None, "")
                 }
             },
-            //WebGL1 without sRGB support disable postprocess and use fallback shader
+
+            // WebGL1 without sRGB support disable postprocess and use fallback shader
             (ShaderVersion::Es100, false) => (None, ""),
-            //OpenGL 2.1 or above always support sRGB so add sRGB support marker
+
+            // OpenGL 2.1 or above always support sRGB so add sRGB support marker
             _ => (None, "#define SRGB_SUPPORTED"),
         };
 
@@ -201,14 +204,13 @@ impl Painter {
             vertex_array.add_new_attribute(gl, position_buffer_info);
             vertex_array.add_new_attribute(gl, tex_coord_buffer_info);
             vertex_array.add_new_attribute(gl, color_buffer_info);
-            assert_eq!(gl.get_error(), glow::NO_ERROR, "OpenGL error occurred!");
+            check_for_gl_error(gl, "after Painter::new");
 
             Ok(Painter {
+                max_texture_side,
                 program,
                 u_screen_size,
                 u_sampler,
-                egui_texture: None,
-                egui_texture_version: None,
                 is_webgl_1,
                 is_embedded: matches!(shader_version, ShaderVersion::Es100 | ShaderVersion::Es300),
                 vertex_array,
@@ -217,7 +219,7 @@ impl Painter {
                 post_process,
                 vertex_buffer,
                 element_array_buffer,
-                user_textures: Default::default(),
+                textures: Default::default(),
                 #[cfg(feature = "epi")]
                 next_native_tex_id: 1 << 32,
                 textures_to_destroy: Vec::new(),
@@ -226,39 +228,8 @@ impl Painter {
         }
     }
 
-    pub fn upload_egui_texture(&mut self, gl: &glow::Context, font_image: &egui::FontImage) {
-        self.assert_not_destroyed();
-
-        if self.egui_texture_version == Some(font_image.version) {
-            return; // No change
-        }
-        let gamma = if self.is_embedded && self.post_process.is_none() {
-            1.0 / 2.2
-        } else {
-            1.0
-        };
-        let pixels: Vec<u8> = font_image
-            .srgba_pixels(gamma)
-            .flat_map(|a| Vec::from(a.to_array()))
-            .collect();
-
-        if let Some(old_tex) = std::mem::replace(
-            &mut self.egui_texture,
-            Some(srgbtexture2d(
-                gl,
-                self.is_webgl_1,
-                self.srgb_support,
-                self.texture_filter,
-                &pixels,
-                font_image.width,
-                font_image.height,
-            )),
-        ) {
-            unsafe {
-                gl.delete_texture(old_tex);
-            }
-        }
-        self.egui_texture_version = Some(font_image.version);
+    pub fn max_texture_side(&self) -> usize {
+        self.max_texture_side
     }
 
     unsafe fn prepare_painting(
@@ -346,7 +317,7 @@ impl Painter {
 
             gl.disable(glow::SCISSOR_TEST);
 
-            assert_eq!(glow::NO_ERROR, gl.get_error(), "GL error occurred!");
+            check_for_gl_error(gl, "painting");
         }
     }
 
@@ -365,19 +336,20 @@ impl Painter {
                 gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vertex_buffer));
                 gl.buffer_data_u8_slice(
                     glow::ARRAY_BUFFER,
-                    as_u8_slice(mesh.vertices.as_slice()),
+                    bytemuck::cast_slice(&mesh.vertices),
                     glow::STREAM_DRAW,
                 );
 
                 gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.element_array_buffer));
                 gl.buffer_data_u8_slice(
                     glow::ELEMENT_ARRAY_BUFFER,
-                    as_u8_slice(mesh.indices.as_slice()),
+                    bytemuck::cast_slice(&mesh.indices),
                     glow::STREAM_DRAW,
                 );
 
                 gl.bind_texture(glow::TEXTURE_2D, Some(texture));
             }
+
             // Transform clip rect to physical pixels:
             let clip_min_x = pixels_per_point * clip_rect.min.x;
             let clip_min_y = pixels_per_point * clip_rect.min.y;
@@ -420,57 +392,147 @@ impl Painter {
 
     // ------------------------------------------------------------------------
 
-    #[cfg(feature = "epi")]
-    pub fn set_texture(&mut self, gl: &glow::Context, tex_id: u64, image: &epi::Image) {
+    pub fn set_texture(
+        &mut self,
+        gl: &glow::Context,
+        tex_id: egui::TextureId,
+        delta: &egui::epaint::ImageDelta,
+    ) {
         self.assert_not_destroyed();
 
-        assert_eq!(
-            image.size[0] * image.size[1],
-            image.pixels.len(),
-            "Mismatch between texture size and texel count"
-        );
+        let glow_texture = *self
+            .textures
+            .entry(tex_id)
+            .or_insert_with(|| unsafe { gl.create_texture().unwrap() });
+        unsafe {
+            gl.bind_texture(glow::TEXTURE_2D, Some(glow_texture));
+        }
 
-        // TODO: optimize
-        let pixels: Vec<u8> = image
-            .pixels
-            .iter()
-            .flat_map(|srgba| Vec::from(srgba.to_array()))
-            .collect();
+        match &delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
 
-        let gl_texture = srgbtexture2d(
-            gl,
-            self.is_webgl_1,
-            self.srgb_support,
-            self.texture_filter,
-            &pixels,
-            image.size[0],
-            image.size[1],
-        );
+                let data: &[u8] = bytemuck::cast_slice(image.pixels.as_ref());
 
-        if let Some(old_tex) = self.user_textures.insert(tex_id, gl_texture) {
-            self.textures_to_destroy.push(old_tex);
+                self.upload_texture_srgb(gl, delta.pos, image.size, data);
+            }
+            egui::ImageData::Alpha(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+
+                let gamma = if self.is_embedded && self.post_process.is_none() {
+                    1.0 / 2.2
+                } else {
+                    1.0
+                };
+                let data: Vec<u8> = image
+                    .srgba_pixels(gamma)
+                    .flat_map(|a| a.to_array())
+                    .collect();
+
+                self.upload_texture_srgb(gl, delta.pos, image.size, &data);
+            }
+        };
+    }
+
+    fn upload_texture_srgb(
+        &mut self,
+        gl: &glow::Context,
+        pos: Option<[usize; 2]>,
+        [w, h]: [usize; 2],
+        data: &[u8],
+    ) {
+        assert_eq!(data.len(), w * h * 4);
+        assert!(w >= 1 && h >= 1);
+        unsafe {
+            gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_MAG_FILTER,
+                self.texture_filter.glow_code() as i32,
+            );
+            gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_MIN_FILTER,
+                self.texture_filter.glow_code() as i32,
+            );
+
+            gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_WRAP_S,
+                glow::CLAMP_TO_EDGE as i32,
+            );
+            gl.tex_parameter_i32(
+                glow::TEXTURE_2D,
+                glow::TEXTURE_WRAP_T,
+                glow::CLAMP_TO_EDGE as i32,
+            );
+            check_for_gl_error(gl, "tex_parameter");
+
+            let (internal_format, src_format) = if self.is_webgl_1 {
+                let format = if self.srgb_support {
+                    glow::SRGB_ALPHA
+                } else {
+                    glow::RGBA
+                };
+                (format, format)
+            } else {
+                (glow::SRGB8_ALPHA8, glow::RGBA)
+            };
+
+            gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1);
+
+            let level = 0;
+            if let Some([x, y]) = pos {
+                gl.tex_sub_image_2d(
+                    glow::TEXTURE_2D,
+                    level,
+                    x as _,
+                    y as _,
+                    w as _,
+                    h as _,
+                    src_format,
+                    glow::UNSIGNED_BYTE,
+                    glow::PixelUnpackData::Slice(data),
+                );
+                check_for_gl_error(gl, "tex_sub_image_2d");
+            } else {
+                let border = 0;
+                gl.tex_image_2d(
+                    glow::TEXTURE_2D,
+                    level,
+                    internal_format as _,
+                    w as _,
+                    h as _,
+                    border,
+                    src_format,
+                    glow::UNSIGNED_BYTE,
+                    Some(data),
+                );
+                check_for_gl_error(gl, "tex_image_2d");
+            }
         }
     }
 
-    pub fn free_texture(&mut self, tex_id: u64) {
-        self.user_textures.remove(&tex_id);
+    pub fn free_texture(&mut self, gl: &glow::Context, tex_id: egui::TextureId) {
+        if let Some(old_tex) = self.textures.remove(&tex_id) {
+            unsafe { gl.delete_texture(old_tex) };
+        }
     }
 
     fn get_texture(&self, texture_id: egui::TextureId) -> Option<glow::Texture> {
-        self.assert_not_destroyed();
-
-        match texture_id {
-            egui::TextureId::Egui => self.egui_texture,
-            egui::TextureId::User(id) => self.user_textures.get(&id).copied(),
-        }
+        self.textures.get(&texture_id).copied()
     }
 
     unsafe fn destroy_gl(&self, gl: &glow::Context) {
         gl.delete_program(self.program);
-        if let Some(tex) = self.egui_texture {
-            gl.delete_texture(tex);
-        }
-        for tex in self.user_textures.values() {
+        for tex in self.textures.values() {
             gl.delete_texture(*tex);
         }
         gl.delete_buffer(self.vertex_buffer);
@@ -520,7 +582,7 @@ pub fn clear(gl: &glow::Context, dimension: [u32; 2], clear_color: egui::Rgba) {
 impl Drop for Painter {
     fn drop(&mut self) {
         if !self.destroyed {
-            eprintln!(
+            tracing::warn!(
                 "You forgot to call destroy() on the egui glow painter. Resources will leak!"
             );
         }
@@ -533,20 +595,15 @@ impl epi::NativeTexture for Painter {
 
     fn register_native_texture(&mut self, native: Self::Texture) -> egui::TextureId {
         self.assert_not_destroyed();
-
-        let id = self.next_native_tex_id;
+        let id = egui::TextureId::User(self.next_native_tex_id);
         self.next_native_tex_id += 1;
-
-        self.user_textures.insert(id, native);
-
-        egui::TextureId::User(id as u64)
+        self.textures.insert(id, native);
+        id
     }
 
     fn replace_native_texture(&mut self, id: egui::TextureId, replacing: Self::Texture) {
-        if let egui::TextureId::User(id) = id {
-            if let Some(old_tex) = self.user_textures.insert(id, replacing) {
-                self.textures_to_destroy.push(old_tex);
-            }
+        if let Some(old_tex) = self.textures.insert(id, replacing) {
+            self.textures_to_destroy.push(old_tex);
         }
     }
 }
diff --git a/egui_glow/src/post_process.rs b/egui_glow/src/post_process.rs
index ecfc2abc..e12c1a0e 100644
--- a/egui_glow/src/post_process.rs
+++ b/egui_glow/src/post_process.rs
@@ -1,5 +1,5 @@
 #![allow(unsafe_code)]
-use crate::misc_util::{compile_shader, link_program};
+use crate::misc_util::{check_for_gl_error, compile_shader, link_program};
 use crate::vao_emulate::BufferInfo;
 use glow::HasContext;
 
@@ -76,13 +76,7 @@ impl PostProcess {
             glow::UNSIGNED_BYTE,
             None,
         );
-        let error_code = gl.get_error();
-        assert_eq!(
-            error_code,
-            glow::NO_ERROR,
-            "Error occurred in post process texture initialization. code : 0x{:x}",
-            error_code
-        );
+        check_for_gl_error(gl, "post process texture initialization");
 
         gl.framebuffer_texture_2d(
             glow::FRAMEBUFFER,
@@ -122,7 +116,7 @@ impl PostProcess {
         gl.bind_buffer(glow::ARRAY_BUFFER, Some(pos_buffer));
         gl.buffer_data_u8_slice(
             glow::ARRAY_BUFFER,
-            crate::misc_util::as_u8_slice(&positions),
+            bytemuck::cast_slice(&positions),
             glow::STATIC_DRAW,
         );
 
@@ -151,13 +145,7 @@ impl PostProcess {
         gl.buffer_data_u8_slice(glow::ELEMENT_ARRAY_BUFFER, &indices, glow::STATIC_DRAW);
 
         gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, None);
-        let error_code = gl.get_error();
-        assert_eq!(
-            error_code,
-            glow::NO_ERROR,
-            "Error occurred in post process initialization. code : 0x{:x}",
-            error_code
-        );
+        check_for_gl_error(gl, "post process initialization");
 
         Ok(PostProcess {
             pos_buffer,
diff --git a/egui_glow/src/shader_version.rs b/egui_glow/src/shader_version.rs
index a3d69dc0..ae4af65e 100644
--- a/egui_glow/src/shader_version.rs
+++ b/egui_glow/src/shader_version.rs
@@ -1,5 +1,5 @@
 #![allow(unsafe_code)]
-use crate::misc_util::glow_debug_print;
+
 use glow::HasContext;
 use std::convert::TryInto;
 
@@ -17,10 +17,11 @@ impl ShaderVersion {
         let shading_lang_string =
             unsafe { gl.get_parameter_string(glow::SHADING_LANGUAGE_VERSION) };
         let shader_version = Self::parse(&shading_lang_string);
-        glow_debug_print(format!(
-            "Shader version: {:?} ({:?})",
-            shader_version, shading_lang_string
-        ));
+        tracing::debug!(
+            "Shader version: {:?} ({:?}).",
+            shader_version,
+            shading_lang_string
+        );
         shader_version
     }
 
diff --git a/egui_web/CHANGELOG.md b/egui_web/CHANGELOG.md
index 68714197..f76bdb30 100644
--- a/egui_web/CHANGELOG.md
+++ b/egui_web/CHANGELOG.md
@@ -6,6 +6,10 @@ All notable changes to the `egui_web` integration will be noted in this file.
 ## Unreleased
 * The default painter is now glow instead of WebGL ([#1020](https://github.com/emilk/egui/pull/1020)).
 * Made the WebGL painter opt-in ([#1020](https://github.com/emilk/egui/pull/1020)).
+* Fixed glow failure on Chromium ([#1092](https://github.com/emilk/egui/pull/1092)).
+* Shift-scroll will now result in horizontal scrolling ([#1136](https://github.com/emilk/egui/pull/1136)).
+* Updated `epi::IntegrationInfo::web_location_hash` on `hashchange` event ([#1140](https://github.com/emilk/egui/pull/1140)).
+* Panics will now be logged using `console.error`.
 
 
 ## 0.16.0 - 2021-12-29
diff --git a/egui_web/Cargo.toml b/egui_web/Cargo.toml
index ae60cf96..bc1ac916 100644
--- a/egui_web/Cargo.toml
+++ b/egui_web/Cargo.toml
@@ -25,18 +25,6 @@ all-features = true
 [lib]
 crate-type = ["cdylib", "rlib"]
 
-[dependencies]
-egui = { version = "0.16.0", path = "../egui", default-features = false, features = [
-  "single_threaded",
-] }
-egui_glow = { version = "0.16.0",path = "../egui_glow", default-features = false, optional = true }
-epi = { version = "0.16.0", path = "../epi" }
-js-sys = "0.3"
-ron = { version = "0.7", optional = true }
-serde = { version = "1", optional = true }
-tts = { version = "0.19", optional = true } # feature screen_reader
-wasm-bindgen = "0.2"
-wasm-bindgen-futures = "0.4"
 
 [features]
 default = ["default_fonts", "glow"]
@@ -51,8 +39,34 @@ glow = ["egui_glow", "egui_glow/epi"]
 # Alternative to the glow renderer.
 webgl = []
 
+# enable persisting egui memory
 persistence = ["egui/persistence", "ron", "serde"]
-screen_reader = ["tts"] # experimental
+
+# enable screen reader support (requires `ctx.options().screen_reader = true;`)
+screen_reader = ["tts"]
+
+
+[dependencies]
+egui = { version = "0.16.0", path = "../egui", default-features = false, features = [
+  "convert_bytemuck",
+  "single_threaded",
+  "tracing",
+] }
+egui_glow = { version = "0.16.0",path = "../egui_glow", default-features = false, optional = true }
+epi = { version = "0.16.0", path = "../epi" }
+
+bytemuck = "1.7"
+console_error_panic_hook = "0.1.6"
+js-sys = "0.3"
+tracing = "0.1"
+tracing-wasm = "0.2"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+
+# Optional:
+ron = { version = "0.7", optional = true }
+serde = { version = "1", optional = true }
+tts = { version = "0.20", optional = true } # feature screen_reader
 
 [dependencies.web-sys]
 version = "0.3.52"
diff --git a/egui_web/README.md b/egui_web/README.md
index abdec071..ac4f194d 100644
--- a/egui_web/README.md
+++ b/egui_web/README.md
@@ -8,7 +8,7 @@
 
 This crates allows you to compile GUI code written with [egui](https://crates.io/crates/egui) to [WASM](https://en.wikipedia.org/wiki/WebAssembly) to run on a web page.
 
-[Run the web demo](https://emilk.github.io/egui/index.html) to try it now.
+[Run the web demo](https://www.egui.rs/#demo) to try it now.
 
 Check out [eframe_template](https://github.com/emilk/eframe_template) for an example of how to set it up.
 
diff --git a/egui_web/src/backend.rs b/egui_web/src/backend.rs
index 259df51d..fe4a2c28 100644
--- a/egui_web/src/backend.rs
+++ b/egui_web/src/backend.rs
@@ -1,5 +1,6 @@
 use crate::*;
 
+use egui::TexturesDelta;
 pub use egui::{pos2, Color32};
 
 // ----------------------------------------------------------------------------
@@ -7,16 +8,16 @@ pub use egui::{pos2, Color32};
 fn create_painter(canvas_id: &str) -> Result<Box<dyn Painter>, JsValue> {
     // Glow takes precedence:
     #[cfg(all(feature = "glow"))]
-    return Ok(Box::new(crate::glow_wrapping::WrappedGlowPainter::new(
-        canvas_id,
-    )));
+    return Ok(Box::new(
+        crate::glow_wrapping::WrappedGlowPainter::new(canvas_id).map_err(JsValue::from)?,
+    ));
 
     #[cfg(all(feature = "webgl", not(feature = "glow")))]
     if let Ok(webgl2_painter) = webgl2::WebGl2Painter::new(canvas_id) {
-        console_log("Using WebGL2 backend");
+        tracing::debug!("Using WebGL2 backend");
         Ok(Box::new(webgl2_painter))
     } else {
-        console_log("Falling back to WebGL1 backend");
+        tracing::debug!("Falling back to WebGL1 backend");
         let webgl1_painter = webgl1::WebGlPainter::new(canvas_id)?;
         Ok(Box::new(webgl1_painter))
     }
@@ -81,8 +82,8 @@ impl epi::backend::RepaintSignal for NeedRepaint {
 // ----------------------------------------------------------------------------
 
 pub struct AppRunner {
-    frame: epi::Frame,
-    egui_ctx: egui::CtxRef,
+    pub(crate) frame: epi::Frame,
+    egui_ctx: egui::Context,
     painter: Box<dyn Painter>,
     pub(crate) input: WebInput,
     app: Box<dyn epi::App>,
@@ -92,7 +93,7 @@ pub struct AppRunner {
     screen_reader: crate::screen_reader::ScreenReader,
     pub(crate) text_cursor_pos: Option<egui::Pos2>,
     pub(crate) mutable_text_under_cursor: bool,
-    pending_texture_destructions: Vec<u64>,
+    textures_delta: TexturesDelta,
 }
 
 impl AppRunner {
@@ -117,7 +118,7 @@ impl AppRunner {
             repaint_signal: needs_repaint.clone(),
         });
 
-        let egui_ctx = egui::CtxRef::default();
+        let egui_ctx = egui::Context::default();
         load_memory(&egui_ctx);
         if prefer_dark_mode == Some(true) {
             egui_ctx.set_visuals(egui::Visuals::dark());
@@ -139,9 +140,11 @@ impl AppRunner {
             screen_reader: Default::default(),
             text_cursor_pos: None,
             mutable_text_under_cursor: false,
-            pending_texture_destructions: Default::default(),
+            textures_delta: Default::default(),
         };
 
+        runner.input.raw.max_texture_side = runner.painter.max_texture_side();
+
         {
             runner
                 .app
@@ -151,7 +154,7 @@ impl AppRunner {
         Ok(runner)
     }
 
-    pub fn egui_ctx(&self) -> &egui::CtxRef {
+    pub fn egui_ctx(&self) -> &egui::Context {
         &self.egui_ctx
     }
 
@@ -174,7 +177,7 @@ impl AppRunner {
 
     pub fn warm_up(&mut self) -> Result<(), JsValue> {
         if self.app.warm_up_enabled() {
-            let saved_memory = self.egui_ctx.memory().clone();
+            let saved_memory: egui::Memory = self.egui_ctx.memory().clone();
             self.egui_ctx.memory().set_everything_is_visible(true);
             self.logic()?;
             *self.egui_ctx.memory() = saved_memory; // We don't want to remember that windows were huge.
@@ -183,7 +186,10 @@ impl AppRunner {
         Ok(())
     }
 
-    pub fn logic(&mut self) -> Result<(egui::Output, Vec<egui::ClippedMesh>), JsValue> {
+    /// Returns `true` if egui requests a repaint.
+    ///
+    /// Call [`Self::paint`] later to paint
+    pub fn logic(&mut self) -> Result<(bool, Vec<egui::ClippedMesh>), JsValue> {
         let frame_start = now_sec();
 
         resize_canvas_to_screen_size(self.canvas_id(), self.app.max_size_points());
@@ -195,7 +201,9 @@ impl AppRunner {
         });
         let clipped_meshes = self.egui_ctx.tessellate(shapes);
 
-        self.handle_egui_output(&egui_output);
+        let needs_repaint = egui_output.needs_repaint;
+        let textures_delta = self.handle_egui_output(egui_output);
+        self.textures_delta.append(textures_delta);
 
         {
             let app_output = self.frame.take_app_output();
@@ -205,33 +213,33 @@ impl AppRunner {
                 window_title: _, // TODO: change title of window
                 decorated: _,    // Can't toggle decorations
                 drag_window: _,  // Can't be dragged
-                tex_allocation_data,
             } = app_output;
-
-            for (id, image) in tex_allocation_data.creations {
-                self.painter.set_texture(id, image);
-            }
-            self.pending_texture_destructions = tex_allocation_data.destructions;
         }
 
         self.frame.lock().info.cpu_usage = Some((now_sec() - frame_start) as f32);
-        Ok((egui_output, clipped_meshes))
+        Ok((needs_repaint, clipped_meshes))
     }
 
+    /// Paint the results of the last call to [`Self::logic`].
     pub fn paint(&mut self, clipped_meshes: Vec<egui::ClippedMesh>) -> Result<(), JsValue> {
-        self.painter
-            .upload_egui_texture(&self.egui_ctx.font_image());
+        let textures_delta = std::mem::take(&mut self.textures_delta);
+        for (id, image_delta) in textures_delta.set {
+            self.painter.set_texture(id, &image_delta);
+        }
+
         self.painter.clear(self.app.clear_color());
         self.painter
             .paint_meshes(clipped_meshes, self.egui_ctx.pixels_per_point())?;
-        for id in self.pending_texture_destructions.drain(..) {
+
+        for id in textures_delta.free {
             self.painter.free_texture(id);
         }
+
         Ok(())
     }
 
-    fn handle_egui_output(&mut self, output: &egui::Output) {
-        if self.egui_ctx.memory().options.screen_reader {
+    fn handle_egui_output(&mut self, output: egui::Output) -> egui::TexturesDelta {
+        if self.egui_ctx.options().screen_reader {
             self.screen_reader.speak(&output.events_description());
         }
 
@@ -243,33 +251,42 @@ impl AppRunner {
             events: _,        // already handled
             mutable_text_under_cursor,
             text_cursor_pos,
+            textures_delta,
         } = output;
 
-        set_cursor_icon(*cursor_icon);
+        set_cursor_icon(cursor_icon);
         if let Some(open) = open_url {
             crate::open_url(&open.url, open.new_tab);
         }
 
         #[cfg(web_sys_unstable_apis)]
         if !copied_text.is_empty() {
-            set_clipboard_text(copied_text);
+            set_clipboard_text(&copied_text);
         }
 
         #[cfg(not(web_sys_unstable_apis))]
         let _ = copied_text;
 
-        self.mutable_text_under_cursor = *mutable_text_under_cursor;
+        self.mutable_text_under_cursor = mutable_text_under_cursor;
 
-        if &self.text_cursor_pos != text_cursor_pos {
+        if self.text_cursor_pos != text_cursor_pos {
             move_text_cursor(text_cursor_pos, self.canvas_id());
-            self.text_cursor_pos = *text_cursor_pos;
+            self.text_cursor_pos = text_cursor_pos;
         }
+
+        textures_delta
     }
 }
 
 /// Install event listeners to register different input events
 /// and start running the given app.
 pub fn start(canvas_id: &str, app: Box<dyn epi::App>) -> Result<AppRunnerRef, JsValue> {
+    // Make sure panics are logged using `console.error`.
+    console_error_panic_hook::set_once();
+
+    // Redirect tracing to console.log and friends:
+    tracing_wasm::set_as_global_default();
+
     let mut runner = AppRunner::new(canvas_id, app)?;
     runner.warm_up()?;
     start_runner(runner)
diff --git a/egui_web/src/glow_wrapping.rs b/egui_web/src/glow_wrapping.rs
index ac2eba79..839b23e4 100644
--- a/egui_web/src/glow_wrapping.rs
+++ b/egui_web/src/glow_wrapping.rs
@@ -1,77 +1,48 @@
-use crate::{canvas_element_or_die, console_error};
-use egui::{ClippedMesh, FontImage, Rgba};
+use egui::{ClippedMesh, Rgba};
 use egui_glow::glow;
 use wasm_bindgen::JsCast;
 use wasm_bindgen::JsValue;
 use web_sys::HtmlCanvasElement;
 #[cfg(not(target_arch = "wasm32"))]
-use web_sys::WebGl2RenderingContext;
-use web_sys::WebGlRenderingContext;
+use web_sys::{WebGl2RenderingContext, WebGlRenderingContext};
 
 pub(crate) struct WrappedGlowPainter {
-    pub(crate) gl_ctx: glow::Context,
+    pub(crate) glow_ctx: glow::Context,
     pub(crate) canvas: HtmlCanvasElement,
     pub(crate) canvas_id: String,
     pub(crate) painter: egui_glow::Painter,
 }
 
 impl WrappedGlowPainter {
-    pub fn new(canvas_id: &str) -> Self {
-        let canvas = canvas_element_or_die(canvas_id);
+    pub fn new(canvas_id: &str) -> Result<Self, String> {
+        let canvas = crate::canvas_element_or_die(canvas_id);
 
-        let shader_prefix = if requires_brightening(&canvas) {
-            crate::console_log("Enabling webkitGTK brightening workaround");
-            "#define APPLY_BRIGHTENING_GAMMA"
-        } else {
-            ""
-        };
+        let (glow_ctx, shader_prefix) = init_glow_context_from_canvas(&canvas)?;
 
-        let gl_ctx = init_glow_context_from_canvas(&canvas);
         let dimension = [canvas.width() as i32, canvas.height() as i32];
-        let painter = egui_glow::Painter::new(&gl_ctx, Some(dimension), shader_prefix)
-            .map_err(|error| {
-                console_error(format!(
-                    "some error occurred in initializing glow painter\n {}",
-                    error
-                ))
-            })
-            .unwrap();
+        let painter = egui_glow::Painter::new(&glow_ctx, Some(dimension), shader_prefix)
+            .map_err(|error| format!("Error starting glow painter: {}", error))?;
 
-        Self {
-            gl_ctx,
+        Ok(Self {
+            glow_ctx,
             canvas,
             canvas_id: canvas_id.to_owned(),
             painter,
-        }
+        })
     }
 }
 
-fn requires_brightening(canvas: &web_sys::HtmlCanvasElement) -> bool {
-    // See https://github.com/emilk/egui/issues/794
-
-    // detect WebKitGTK
-
-    // WebKitGTK currently support only webgl,so request webgl context.
-    // WebKitGTK use WebKit default unmasked vendor and renderer
-    // but safari use same vendor and renderer
-    // so exclude "Mac OS X" user-agent.
-    let gl = canvas
-        .get_context("webgl")
-        .unwrap()
-        .unwrap()
-        .dyn_into::<WebGlRenderingContext>()
-        .unwrap();
-    let user_agent = web_sys::window().unwrap().navigator().user_agent().unwrap();
-    crate::is_safari_and_webkit_gtk(&gl) && !user_agent.contains("Mac OS X")
-}
-
 impl crate::Painter for WrappedGlowPainter {
-    fn set_texture(&mut self, tex_id: u64, image: epi::Image) {
-        self.painter.set_texture(&self.gl_ctx, tex_id, &image);
+    fn max_texture_side(&self) -> usize {
+        self.painter.max_texture_side()
     }
 
-    fn free_texture(&mut self, tex_id: u64) {
-        self.painter.free_texture(tex_id);
+    fn set_texture(&mut self, tex_id: egui::TextureId, delta: &egui::epaint::ImageDelta) {
+        self.painter.set_texture(&self.glow_ctx, tex_id, delta);
+    }
+
+    fn free_texture(&mut self, tex_id: egui::TextureId) {
+        self.painter.free_texture(&self.glow_ctx, tex_id);
     }
 
     fn debug_info(&self) -> String {
@@ -86,13 +57,9 @@ impl crate::Painter for WrappedGlowPainter {
         &self.canvas_id
     }
 
-    fn upload_egui_texture(&mut self, font_image: &FontImage) {
-        self.painter.upload_egui_texture(&self.gl_ctx, font_image)
-    }
-
     fn clear(&mut self, clear_color: Rgba) {
         let canvas_dimension = [self.canvas.width(), self.canvas.height()];
-        egui_glow::painter::clear(&self.gl_ctx, canvas_dimension, clear_color)
+        egui_glow::painter::clear(&self.glow_ctx, canvas_dimension, clear_color)
     }
 
     fn paint_meshes(
@@ -102,7 +69,7 @@ impl crate::Painter for WrappedGlowPainter {
     ) -> Result<(), JsValue> {
         let canvas_dimension = [self.canvas.width(), self.canvas.height()];
         self.painter.paint_meshes(
-            &self.gl_ctx,
+            &self.glow_ctx,
             canvas_dimension,
             pixels_per_point,
             clipped_meshes,
@@ -115,30 +82,67 @@ impl crate::Painter for WrappedGlowPainter {
     }
 }
 
-pub fn init_glow_context_from_canvas(canvas: &HtmlCanvasElement) -> glow::Context {
+/// Returns glow context and shader prefix.
+fn init_glow_context_from_canvas(
+    canvas: &HtmlCanvasElement,
+) -> Result<(glow::Context, &'static str), String> {
+    const BEST_FIRST: bool = true;
+
+    let result = if BEST_FIRST {
+        // Trying WebGl2 first
+        init_webgl2(canvas).or_else(|| init_webgl1(canvas))
+    } else {
+        // Trying WebGl1 first (useful for testing).
+        tracing::warn!("Looking for WebGL1 first");
+        init_webgl1(canvas).or_else(|| init_webgl2(canvas))
+    };
+
+    if let Some(result) = result {
+        Ok(result)
+    } else {
+        Err("WebGL isn't supported".into())
+    }
+}
+
+fn init_webgl1(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
+    let gl1_ctx = canvas
+        .get_context("webgl")
+        .expect("Failed to query about WebGL2 context");
+
+    let gl1_ctx = gl1_ctx?;
+    tracing::debug!("WebGL1 selected.");
+
+    let gl1_ctx = gl1_ctx
+        .dyn_into::<web_sys::WebGlRenderingContext>()
+        .unwrap();
+
+    let shader_prefix = if crate::webgl1_requires_brightening(&gl1_ctx) {
+        tracing::debug!("Enabling webkitGTK brightening workaround.");
+        "#define APPLY_BRIGHTENING_GAMMA"
+    } else {
+        ""
+    };
+
+    let glow_ctx = glow::Context::from_webgl1_context(gl1_ctx);
+
+    Some((glow_ctx, shader_prefix))
+}
+
+fn init_webgl2(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'static str)> {
     let gl2_ctx = canvas
         .get_context("webgl2")
         .expect("Failed to query about WebGL2 context");
 
-    if let Some(gl2_ctx) = gl2_ctx {
-        crate::console_log("WebGL2 found");
-        let gl2_ctx = gl2_ctx
-            .dyn_into::<web_sys::WebGl2RenderingContext>()
-            .unwrap();
-        glow::Context::from_webgl2_context(gl2_ctx)
-    } else {
-        let gl1 = canvas
-            .get_context("webgl")
-            .expect("Failed to query about WebGL1 context");
+    let gl2_ctx = gl2_ctx?;
+    tracing::debug!("WebGL2 selected.");
 
-        if let Some(gl1) = gl1 {
-            crate::console_log("WebGL2 not available - falling back to WebGL2");
-            let gl1_ctx = gl1.dyn_into::<web_sys::WebGlRenderingContext>().unwrap();
-            glow::Context::from_webgl1_context(gl1_ctx)
-        } else {
-            panic!("Failed to get WebGL context.");
-        }
-    }
+    let gl2_ctx = gl2_ctx
+        .dyn_into::<web_sys::WebGl2RenderingContext>()
+        .unwrap();
+    let glow_ctx = glow::Context::from_webgl2_context(gl2_ctx);
+    let shader_prefix = "";
+
+    Some((glow_ctx, shader_prefix))
 }
 
 trait DummyWebGLConstructor {
@@ -150,10 +154,10 @@ trait DummyWebGLConstructor {
 #[cfg(not(target_arch = "wasm32"))]
 impl DummyWebGLConstructor for glow::Context {
     fn from_webgl1_context(_context: WebGlRenderingContext) -> Self {
-        panic!("you cant use egui_web(glow) on native")
+        panic!("you can't use egui_web(glow) on native")
     }
 
     fn from_webgl2_context(_context: WebGl2RenderingContext) -> Self {
-        panic!("you cant use egui_web(glow) on native")
+        panic!("you can't use egui_web(glow) on native")
     }
 }
diff --git a/egui_web/src/lib.rs b/egui_web/src/lib.rs
index 36ea3f24..7fcec9d1 100644
--- a/egui_web/src/lib.rs
+++ b/egui_web/src/lib.rs
@@ -40,22 +40,6 @@ use wasm_bindgen::prelude::*;
 static AGENT_ID: &str = "egui_text_agent";
 
 // ----------------------------------------------------------------------------
-// Helpers to hide some of the verbosity of web_sys
-
-/// Log some text to the developer console (`console.log(…)` in JS)
-pub fn console_log(s: impl Into<JsValue>) {
-    web_sys::console::log_1(&s.into());
-}
-
-/// Log a warning to the developer console (`console.warn(…)` in JS)
-pub fn console_warn(s: impl Into<JsValue>) {
-    web_sys::console::warn_1(&s.into());
-}
-
-/// Log an error to the developer console (`console.error(…)` in JS)
-pub fn console_error(s: impl Into<JsValue>) {
-    web_sys::console::error_1(&s.into());
-}
 
 /// Current time in seconds (since undefined point in time)
 pub fn now_sec() -> f64 {
@@ -69,7 +53,7 @@ pub fn now_sec() -> f64 {
 
 pub fn screen_size_in_native_points() -> Option<egui::Vec2> {
     let window = web_sys::window()?;
-    Some(egui::Vec2::new(
+    Some(egui::vec2(
         window.inner_width().ok()?.as_f64()? as f32,
         window.inner_height().ok()?.as_f64()? as f32,
     ))
@@ -259,7 +243,7 @@ pub fn load_memory(ctx: &egui::Context) {
                 *ctx.memory() = memory;
             }
             Err(err) => {
-                console_error(format!("Failed to parse memory RON: {}", err));
+                tracing::error!("Failed to parse memory RON: {}", err);
             }
         }
     }
@@ -275,7 +259,7 @@ pub fn save_memory(ctx: &egui::Context) {
             local_storage_set("egui_memory_ron", &ron);
         }
         Err(err) => {
-            console_error(format!("Failed to serialize memory as RON: {}", err));
+            tracing::error!("Failed to serialize memory as RON: {}", err);
         }
     }
 }
@@ -315,7 +299,7 @@ pub fn set_clipboard_text(s: &str) {
             let future = wasm_bindgen_futures::JsFuture::from(promise);
             let future = async move {
                 if let Err(err) = future.await {
-                    console_error(format!("Copy/cut action denied: {:?}", err));
+                    tracing::error!("Copy/cut action denied: {:?}", err);
                 }
             };
             wasm_bindgen_futures::spawn_local(future);
@@ -482,9 +466,9 @@ fn paint_and_schedule(runner_ref: AppRunnerRef) -> Result<(), JsValue> {
     fn paint_if_needed(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
         let mut runner_lock = runner_ref.0.lock();
         if runner_lock.needs_repaint.fetch_and_clear() {
-            let (output, clipped_meshes) = runner_lock.logic()?;
+            let (needs_repaint, clipped_meshes) = runner_lock.logic()?;
             runner_lock.paint(clipped_meshes)?;
-            if output.needs_repaint {
+            if needs_repaint {
                 runner_lock.needs_repaint.set_true();
             }
             runner_lock.auto_save();
@@ -575,12 +559,12 @@ fn install_document_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                 false
             };
 
-            // console_log(format!(
+            // tracing::debug!(
             //     "On key-down {:?}, egui_wants_keyboard: {}, prevent_default: {}",
             //     event.key().as_str(),
             //     egui_wants_keyboard,
             //     prevent_default
-            // ));
+            // );
 
             if prevent_default {
                 event.prevent_default();
@@ -622,7 +606,7 @@ fn install_document_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                         .input
                         .raw
                         .events
-                        .push(egui::Event::Text(text.replace("\r\n", "\n")));
+                        .push(egui::Event::Paste(text.replace("\r\n", "\n")));
                     runner_lock.needs_repaint.set_true();
                     event.stop_propagation();
                     event.prevent_default();
@@ -668,6 +652,22 @@ fn install_document_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
         closure.forget();
     }
 
+    {
+        // hashchange
+        let runner_ref = runner_ref.clone();
+        let closure = Closure::wrap(Box::new(move || {
+            let runner_lock = runner_ref.0.lock();
+            let mut frame_lock = runner_lock.frame.lock();
+
+            // `epi::Frame::info(&self)` clones `epi::IntegrationInfo`, but we need to modify the original here
+            if let Some(web_info) = &mut frame_lock.info.web_info {
+                web_info.web_location_hash = location_hash().unwrap_or_default();
+            }
+        }) as Box<dyn FnMut()>);
+        window.add_event_listener_with_callback("hashchange", closure.as_ref().unchecked_ref())?;
+        closure.forget();
+    }
+
     Ok(())
 }
 
@@ -764,7 +764,7 @@ fn install_text_agent(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                 }
                 "compositionupdate" => event.data().map(egui::Event::CompositionUpdate),
                 s => {
-                    console_error(format!("Unknown composition event type: {:?}", s));
+                    tracing::error!("Unknown composition event type: {:?}", s);
                     None
                 }
             };
@@ -835,7 +835,7 @@ fn install_canvas_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                 runner_lock.needs_repaint.set_true();
             }
             event.stop_propagation();
-            event.prevent_default();
+            // Note: prevent_default breaks VSCode tab focusing, hence why we don't call it here.
         }) as Box<dyn FnMut(_)>);
         canvas.add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())?;
         closure.forget();
@@ -1022,11 +1022,11 @@ fn install_canvas_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                     let points_per_scroll_line = 8.0; // Note that this is intentionally different from what we use in egui_glium / winit.
                     points_per_scroll_line
                 }
-                _ => 1.0,
+                _ => 1.0, // DOM_DELTA_PIXEL
             };
 
-            let delta = -scroll_multiplier
-                * egui::Vec2::new(event.delta_x() as f32, event.delta_y() as f32);
+            let mut delta =
+                -scroll_multiplier * egui::vec2(event.delta_x() as f32, event.delta_y() as f32);
 
             // Report a zoom event in case CTRL (on Windows or Linux) or CMD (on Mac) is pressed.
             // This if-statement is equivalent to how `Modifiers.command` is determined in
@@ -1035,6 +1035,12 @@ fn install_canvas_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                 let factor = (delta.y / 200.0).exp();
                 runner_lock.input.raw.events.push(egui::Event::Zoom(factor));
             } else {
+                if event.shift_key() {
+                    // Treat as horizontal scrolling.
+                    // Note: one Mac we already get horizontal scroll events when shift is down.
+                    delta = egui::vec2(delta.x + delta.y, 0.0);
+                }
+
                 runner_lock
                     .input
                     .raw
@@ -1106,7 +1112,7 @@ fn install_canvas_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                             let last_modified = std::time::UNIX_EPOCH
                                 + std::time::Duration::from_millis(file.last_modified() as u64);
 
-                            console_log(format!("Loading {:?} ({} bytes)…", name, file.size()));
+                            tracing::debug!("Loading {:?} ({} bytes)…", name, file.size());
 
                             let future = wasm_bindgen_futures::JsFuture::from(file.array_buffer());
 
@@ -1115,11 +1121,11 @@ fn install_canvas_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                                 match future.await {
                                     Ok(array_buffer) => {
                                         let bytes = js_sys::Uint8Array::new(&array_buffer).to_vec();
-                                        console_log(format!(
+                                        tracing::debug!(
                                             "Loaded {:?} ({} bytes).",
                                             name,
                                             bytes.len()
-                                        ));
+                                        );
 
                                         let mut runner_lock = runner_ref.0.lock();
                                         runner_lock.input.raw.dropped_files.push(
@@ -1133,7 +1139,7 @@ fn install_canvas_events(runner_ref: &AppRunnerRef) -> Result<(), JsValue> {
                                         runner_lock.needs_repaint.set_true();
                                     }
                                     Err(err) => {
-                                        console_error(format!("Failed to read file: {:?}", err));
+                                        tracing::error!("Failed to read file: {:?}", err);
                                     }
                                 }
                             };
@@ -1214,7 +1220,7 @@ fn is_mobile() -> Option<bool> {
 // 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.
-fn move_text_cursor(cursor: &Option<egui::Pos2>, canvas_id: &str) -> Option<()> {
+fn move_text_cursor(cursor: Option<egui::Pos2>, canvas_id: &str) -> Option<()> {
     let style = text_agent().style();
     // Note: movint agent on mobile devices will lead to unpredictable scroll.
     if is_mobile() == Some(false) {
@@ -1238,6 +1244,18 @@ fn move_text_cursor(cursor: &Option<egui::Pos2>, canvas_id: &str) -> Option<()>
     }
 }
 
+pub(crate) fn webgl1_requires_brightening(gl: &web_sys::WebGlRenderingContext) -> bool {
+    // See https://github.com/emilk/egui/issues/794
+
+    // detect WebKitGTK
+
+    // WebKitGTK use WebKit default unmasked vendor and renderer
+    // but safari use same vendor and renderer
+    // so exclude "Mac OS X" user-agent.
+    let user_agent = web_sys::window().unwrap().navigator().user_agent().unwrap();
+    !user_agent.contains("Mac OS X") && crate::is_safari_and_webkit_gtk(gl)
+}
+
 /// detecting Safari and webkitGTK.
 ///
 /// Safari and webkitGTK use unmasked renderer :Apple GPU
@@ -1245,12 +1263,22 @@ fn move_text_cursor(cursor: &Option<egui::Pos2>, canvas_id: &str) -> Option<()>
 /// If we detect safari or webkitGTK returns true.
 ///
 /// This function used to avoid displaying linear color with `sRGB` supported systems.
-pub(crate) fn is_safari_and_webkit_gtk(gl: &web_sys::WebGlRenderingContext) -> bool {
-    if let Ok(renderer) = gl.get_parameter(web_sys::WebglDebugRendererInfo::UNMASKED_RENDERER_WEBGL)
+fn is_safari_and_webkit_gtk(gl: &web_sys::WebGlRenderingContext) -> bool {
+    // This call produces a warning in Firefox ("WEBGL_debug_renderer_info is deprecated in Firefox and will be removed.")
+    // but unless we call it we get errors in Chrome when we call `get_parameter` below.
+    // TODO: do something smart based on user agent?
+    if gl
+        .get_extension("WEBGL_debug_renderer_info")
+        .unwrap()
+        .is_some()
     {
-        if let Some(renderer) = renderer.as_string() {
-            if renderer.contains("Apple") {
-                return true;
+        if let Ok(renderer) =
+            gl.get_parameter(web_sys::WebglDebugRendererInfo::UNMASKED_RENDERER_WEBGL)
+        {
+            if let Some(renderer) = renderer.as_string() {
+                if renderer.contains("Apple") {
+                    return true;
+                }
             }
         }
     }
diff --git a/egui_web/src/painter.rs b/egui_web/src/painter.rs
index 269761c8..16bc8e49 100644
--- a/egui_web/src/painter.rs
+++ b/egui_web/src/painter.rs
@@ -1,17 +1,18 @@
 use wasm_bindgen::prelude::JsValue;
 
 pub trait Painter {
-    fn set_texture(&mut self, tex_id: u64, image: epi::Image);
+    /// Max size of one side of a texture.
+    fn max_texture_side(&self) -> usize;
 
-    fn free_texture(&mut self, tex_id: u64);
+    fn set_texture(&mut self, tex_id: egui::TextureId, delta: &egui::epaint::ImageDelta);
+
+    fn free_texture(&mut self, tex_id: egui::TextureId);
 
     fn debug_info(&self) -> String;
 
     /// id of the canvas html element containing the rendering
     fn canvas_id(&self) -> &str;
 
-    fn upload_egui_texture(&mut self, font_image: &egui::FontImage);
-
     fn clear(&mut self, clear_color: egui::Rgba);
 
     fn paint_meshes(
diff --git a/egui_web/src/screen_reader.rs b/egui_web/src/screen_reader.rs
index e8f3ac95..11c36efd 100644
--- a/egui_web/src/screen_reader.rs
+++ b/egui_web/src/screen_reader.rs
@@ -15,11 +15,11 @@ impl Default for ScreenReader {
     fn default() -> Self {
         let tts = match tts::Tts::default() {
             Ok(screen_reader) => {
-                crate::console_log("Initialized screen reader.");
+                tracing::debug!("Initialized screen reader.");
                 Some(screen_reader)
             }
             Err(err) => {
-                crate::console_warn(format!("Failed to load screen reader: {}", err));
+                tracing::warn!("Failed to load screen reader: {}", err);
                 None
             }
         };
@@ -37,10 +37,10 @@ impl ScreenReader {
             return;
         }
         if let Some(tts) = &mut self.tts {
-            crate::console_log(format!("Speaking: {:?}", text));
+            tracing::debug!("Speaking: {:?}", text);
             let interrupt = true;
             if let Err(err) = tts.speak(text, interrupt) {
-                crate::console_warn(format!("Failed to read: {}", err));
+                tracing::warn!("Failed to read: {}", err);
             }
         }
     }
diff --git a/egui_web/src/webgl1.rs b/egui_web/src/webgl1.rs
index 7b847c7c..bfa39762 100644
--- a/egui_web/src/webgl1.rs
+++ b/egui_web/src/webgl1.rs
@@ -9,10 +9,7 @@ use {
     },
 };
 
-use egui::{
-    emath::vec2,
-    epaint::{Color32, FontImage},
-};
+use egui::{emath::vec2, epaint::Color32};
 
 type Gl = WebGlRenderingContext;
 
@@ -28,13 +25,8 @@ pub struct WebGlPainter {
     texture_format: u32,
     post_process: Option<PostProcess>,
 
-    egui_texture: WebGlTexture,
-    egui_texture_version: Option<u64>,
-
-    /// Index is the same as in [`egui::TextureId::User`].
-    user_textures: HashMap<u64, WebGlTexture>,
-
-    next_native_tex_id: u64, // TODO: 128-bit texture space?
+    textures: HashMap<egui::TextureId, WebGlTexture>,
+    next_native_tex_id: u64,
 }
 
 impl WebGlPainter {
@@ -43,18 +35,11 @@ impl WebGlPainter {
 
         let gl = canvas
             .get_context("webgl")?
-            .ok_or_else(|| JsValue::from("Failed to get WebGl context"))?
+            .ok_or_else(|| JsValue::from("Failed to get WebGL context"))?
             .dyn_into::<WebGlRenderingContext>()?;
 
         // --------------------------------------------------------------------
 
-        let egui_texture = gl.create_texture().unwrap();
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&egui_texture));
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_S, Gl::CLAMP_TO_EDGE as i32);
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_T, Gl::CLAMP_TO_EDGE as i32);
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MIN_FILTER, Gl::LINEAR as i32);
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MAG_FILTER, Gl::LINEAR as i32);
-
         let srgb_supported = matches!(gl.get_extension("EXT_sRGB"), Ok(Some(_)));
 
         let vert_shader = compile_shader(
@@ -101,18 +86,13 @@ impl WebGlPainter {
             color_buffer,
             texture_format,
             post_process,
-            egui_texture,
-            egui_texture_version: None,
-            user_textures: Default::default(),
+            textures: Default::default(),
             next_native_tex_id: 1 << 32,
         })
     }
 
     fn get_texture(&self, texture_id: egui::TextureId) -> Option<&WebGlTexture> {
-        match texture_id {
-            egui::TextureId::Egui => Some(&self.egui_texture),
-            egui::TextureId::User(id) => self.user_textures.get(&id),
-        }
+        self.textures.get(&texture_id)
     }
 
     fn paint_mesh(&self, mesh: &egui::epaint::Mesh16) -> Result<(), JsValue> {
@@ -234,77 +214,125 @@ impl WebGlPainter {
 
         Ok(())
     }
-}
-
-impl epi::NativeTexture for WebGlPainter {
-    type Texture = WebGlTexture;
-
-    fn register_native_texture(&mut self, native: Self::Texture) -> egui::TextureId {
-        let id = self.next_native_tex_id;
-        self.next_native_tex_id += 1;
-        self.user_textures.insert(id, native);
-        egui::TextureId::User(id as u64)
-    }
-
-    fn replace_native_texture(&mut self, id: egui::TextureId, replacing: Self::Texture) {
-        if let egui::TextureId::User(id) = id {
-            if let Some(user_texture) = self.user_textures.get_mut(&id) {
-                *user_texture = replacing;
-            }
-        }
-    }
-}
-
-impl crate::Painter for WebGlPainter {
-    fn set_texture(&mut self, tex_id: u64, image: epi::Image) {
-        assert_eq!(
-            image.size[0] * image.size[1],
-            image.pixels.len(),
-            "Mismatch between texture size and texel count"
-        );
-
-        // TODO: optimize
-        let mut pixels: Vec<u8> = Vec::with_capacity(image.pixels.len() * 4);
-        for srgba in image.pixels {
-            pixels.push(srgba.r());
-            pixels.push(srgba.g());
-            pixels.push(srgba.b());
-            pixels.push(srgba.a());
-        }
 
+    fn set_texture_rgba(
+        &mut self,
+        tex_id: egui::TextureId,
+        pos: Option<[usize; 2]>,
+        [w, h]: [usize; 2],
+        pixels: &[u8],
+    ) {
         let gl = &self.gl;
-        let gl_texture = gl.create_texture().unwrap();
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&gl_texture));
+
+        let gl_texture = self
+            .textures
+            .entry(tex_id)
+            .or_insert_with(|| gl.create_texture().unwrap());
+
+        gl.bind_texture(Gl::TEXTURE_2D, Some(gl_texture));
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_S, Gl::CLAMP_TO_EDGE as _);
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_T, Gl::CLAMP_TO_EDGE as _);
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MIN_FILTER, Gl::LINEAR as _);
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MAG_FILTER, Gl::LINEAR as _);
 
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&gl_texture));
-
         let level = 0;
         let internal_format = self.texture_format;
         let border = 0;
         let src_format = self.texture_format;
         let src_type = Gl::UNSIGNED_BYTE;
-        gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
-            Gl::TEXTURE_2D,
-            level,
-            internal_format as _,
-            image.size[0] as _,
-            image.size[1] as _,
-            border,
-            src_format,
-            src_type,
-            Some(&pixels),
-        )
-        .unwrap();
 
-        self.user_textures.insert(tex_id, gl_texture);
+        gl.pixel_storei(Gl::UNPACK_ALIGNMENT, 1);
+
+        if let Some([x, y]) = pos {
+            gl.tex_sub_image_2d_with_i32_and_i32_and_u32_and_type_and_opt_u8_array(
+                Gl::TEXTURE_2D,
+                level,
+                x as _,
+                y as _,
+                w as _,
+                h as _,
+                src_format,
+                src_type,
+                Some(pixels),
+            )
+            .unwrap();
+        } else {
+            gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
+                Gl::TEXTURE_2D,
+                level,
+                internal_format as _,
+                w as _,
+                h as _,
+                border,
+                src_format,
+                src_type,
+                Some(pixels),
+            )
+            .unwrap();
+        }
+    }
+}
+
+impl epi::NativeTexture for WebGlPainter {
+    type Texture = WebGlTexture;
+
+    fn register_native_texture(&mut self, texture: Self::Texture) -> egui::TextureId {
+        let id = egui::TextureId::User(self.next_native_tex_id);
+        self.next_native_tex_id += 1;
+        self.textures.insert(id, texture);
+        id
     }
 
-    fn free_texture(&mut self, tex_id: u64) {
-        self.user_textures.remove(&tex_id);
+    fn replace_native_texture(&mut self, id: egui::TextureId, texture: Self::Texture) {
+        self.textures.insert(id, texture);
+    }
+}
+
+impl crate::Painter for WebGlPainter {
+    fn max_texture_side(&self) -> usize {
+        if let Ok(max_texture_side) = self
+            .gl
+            .get_parameter(web_sys::WebGlRenderingContext::MAX_TEXTURE_SIZE)
+        {
+            if let Some(max_texture_side) = max_texture_side.as_f64() {
+                return max_texture_side as usize;
+            }
+        }
+
+        tracing::error!("Failed to query max texture size");
+
+        2048
+    }
+
+    fn set_texture(&mut self, tex_id: egui::TextureId, delta: &egui::epaint::ImageDelta) {
+        match &delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+
+                let data: &[u8] = bytemuck::cast_slice(image.pixels.as_ref());
+                self.set_texture_rgba(tex_id, delta.pos, image.size, data);
+            }
+            egui::ImageData::Alpha(image) => {
+                let gamma = if self.post_process.is_none() {
+                    1.0 / 2.2 // HACK due to non-linear framebuffer blending.
+                } else {
+                    1.0 // post process enables linear blending
+                };
+                let data: Vec<u8> = image
+                    .srgba_pixels(gamma)
+                    .flat_map(|a| a.to_array())
+                    .collect();
+                self.set_texture_rgba(tex_id, delta.pos, image.size, &data);
+            }
+        };
+    }
+
+    fn free_texture(&mut self, tex_id: egui::TextureId) {
+        self.textures.remove(&tex_id);
     }
 
     fn debug_info(&self) -> String {
@@ -323,48 +351,6 @@ impl crate::Painter for WebGlPainter {
         &self.canvas_id
     }
 
-    fn upload_egui_texture(&mut self, font_image: &FontImage) {
-        if self.egui_texture_version == Some(font_image.version) {
-            return; // No change
-        }
-
-        let gamma = if self.post_process.is_none() {
-            1.0 / 2.2 // HACK due to non-linear framebuffer blending.
-        } else {
-            1.0 // post process enables linear blending
-        };
-        let mut pixels: Vec<u8> = Vec::with_capacity(font_image.pixels.len() * 4);
-        for srgba in font_image.srgba_pixels(gamma) {
-            pixels.push(srgba.r());
-            pixels.push(srgba.g());
-            pixels.push(srgba.b());
-            pixels.push(srgba.a());
-        }
-
-        let gl = &self.gl;
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&self.egui_texture));
-
-        let level = 0;
-        let internal_format = self.texture_format;
-        let border = 0;
-        let src_format = self.texture_format;
-        let src_type = Gl::UNSIGNED_BYTE;
-        gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
-            Gl::TEXTURE_2D,
-            level,
-            internal_format as i32,
-            font_image.width as i32,
-            font_image.height as i32,
-            border,
-            src_format,
-            src_type,
-            Some(&pixels),
-        )
-        .unwrap();
-
-        self.egui_texture_version = Some(font_image.version);
-    }
-
     fn clear(&mut self, clear_color: egui::Rgba) {
         let gl = &self.gl;
 
@@ -445,10 +431,7 @@ impl crate::Painter for WebGlPainter {
                     self.paint_mesh(&mesh)?;
                 }
             } else {
-                crate::console_warn(format!(
-                    "WebGL: Failed to find texture {:?}",
-                    mesh.texture_id
-                ));
+                tracing::warn!("WebGL: Failed to find texture {:?}", mesh.texture_id);
             }
         }
 
@@ -475,13 +458,6 @@ struct PostProcess {
     program: WebGlProgram,
 }
 
-fn requires_brightening(gl: &web_sys::WebGlRenderingContext) -> bool {
-    // See https://github.com/emilk/egui/issues/794
-
-    let user_agent = web_sys::window().unwrap().navigator().user_agent().unwrap();
-    crate::is_safari_and_webkit_gtk(gl) && !user_agent.contains("Mac OS X")
-}
-
 impl PostProcess {
     fn new(gl: Gl, width: i32, height: i32) -> Result<PostProcess, JsValue> {
         let fbo = gl
@@ -519,8 +495,8 @@ impl PostProcess {
         gl.bind_texture(Gl::TEXTURE_2D, None);
         gl.bind_framebuffer(Gl::FRAMEBUFFER, None);
 
-        let shader_prefix = if requires_brightening(&gl) {
-            crate::console_log("Enabling webkitGTK brightening workaround");
+        let shader_prefix = if crate::webgl1_requires_brightening(&gl) {
+            tracing::debug!("Enabling webkitGTK brightening workaround");
             "#define APPLY_BRIGHTENING_GAMMA"
         } else {
             ""
diff --git a/egui_web/src/webgl2.rs b/egui_web/src/webgl2.rs
index b5f2e29b..c8ede7fd 100644
--- a/egui_web/src/webgl2.rs
+++ b/egui_web/src/webgl2.rs
@@ -10,10 +10,7 @@ use {
     },
 };
 
-use egui::{
-    emath::vec2,
-    epaint::{Color32, FontImage},
-};
+use egui::{emath::vec2, epaint::Color32};
 
 type Gl = WebGl2RenderingContext;
 
@@ -28,13 +25,8 @@ pub struct WebGl2Painter {
     color_buffer: WebGlBuffer,
     post_process: PostProcess,
 
-    egui_texture: WebGlTexture,
-    egui_texture_version: Option<u64>,
-
-    /// Index is the same as in [`egui::TextureId::User`].
-    user_textures: HashMap<u64, WebGlTexture>,
-
-    next_native_tex_id: u64, // TODO: 128-bit texture space?
+    textures: HashMap<egui::TextureId, WebGlTexture>,
+    next_native_tex_id: u64,
 }
 
 impl WebGl2Painter {
@@ -48,13 +40,6 @@ impl WebGl2Painter {
 
         // --------------------------------------------------------------------
 
-        let egui_texture = gl.create_texture().unwrap();
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&egui_texture));
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_S, Gl::CLAMP_TO_EDGE as i32);
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_T, Gl::CLAMP_TO_EDGE as i32);
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MIN_FILTER, Gl::LINEAR as i32);
-        gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MAG_FILTER, Gl::LINEAR as i32);
-
         let vert_shader = compile_shader(
             &gl,
             Gl::VERTEX_SHADER,
@@ -85,18 +70,13 @@ impl WebGl2Painter {
             tc_buffer,
             color_buffer,
             post_process,
-            egui_texture,
-            egui_texture_version: None,
-            user_textures: Default::default(),
+            textures: Default::default(),
             next_native_tex_id: 1 << 32,
         })
     }
 
     fn get_texture(&self, texture_id: egui::TextureId) -> Option<&WebGlTexture> {
-        match texture_id {
-            egui::TextureId::Egui => Some(&self.egui_texture),
-            egui::TextureId::User(id) => self.user_textures.get(&id),
-        }
+        self.textures.get(&texture_id)
     }
 
     fn paint_mesh(&self, mesh: &egui::epaint::Mesh16) -> Result<(), JsValue> {
@@ -218,77 +198,121 @@ impl WebGl2Painter {
 
         Ok(())
     }
-}
-
-impl epi::NativeTexture for WebGl2Painter {
-    type Texture = WebGlTexture;
-
-    fn register_native_texture(&mut self, native: Self::Texture) -> egui::TextureId {
-        let id = self.next_native_tex_id;
-        self.next_native_tex_id += 1;
-        self.user_textures.insert(id, native);
-        egui::TextureId::User(id as u64)
-    }
-
-    fn replace_native_texture(&mut self, id: egui::TextureId, replacing: Self::Texture) {
-        if let egui::TextureId::User(id) = id {
-            if let Some(user_texture) = self.user_textures.get_mut(&id) {
-                *user_texture = replacing;
-            }
-        }
-    }
-}
-
-impl crate::Painter for WebGl2Painter {
-    fn set_texture(&mut self, tex_id: u64, image: epi::Image) {
-        assert_eq!(
-            image.size[0] * image.size[1],
-            image.pixels.len(),
-            "Mismatch between texture size and texel count"
-        );
-
-        // TODO: optimize
-        let mut pixels: Vec<u8> = Vec::with_capacity(image.pixels.len() * 4);
-        for srgba in image.pixels {
-            pixels.push(srgba.r());
-            pixels.push(srgba.g());
-            pixels.push(srgba.b());
-            pixels.push(srgba.a());
-        }
 
+    fn set_texture_rgba(
+        &mut self,
+        tex_id: egui::TextureId,
+        pos: Option<[usize; 2]>,
+        [w, h]: [usize; 2],
+        pixels: &[u8],
+    ) {
         let gl = &self.gl;
-        let gl_texture = gl.create_texture().unwrap();
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&gl_texture));
+
+        let gl_texture = self
+            .textures
+            .entry(tex_id)
+            .or_insert_with(|| gl.create_texture().unwrap());
+
+        gl.bind_texture(Gl::TEXTURE_2D, Some(gl_texture));
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_S, Gl::CLAMP_TO_EDGE as _);
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_WRAP_T, Gl::CLAMP_TO_EDGE as _);
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MIN_FILTER, Gl::LINEAR as _);
         gl.tex_parameteri(Gl::TEXTURE_2D, Gl::TEXTURE_MAG_FILTER, Gl::LINEAR as _);
 
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&gl_texture));
-
         let level = 0;
         let internal_format = Gl::SRGB8_ALPHA8;
         let border = 0;
         let src_format = Gl::RGBA;
         let src_type = Gl::UNSIGNED_BYTE;
-        gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
-            Gl::TEXTURE_2D,
-            level,
-            internal_format as _,
-            image.size[0] as _,
-            image.size[1] as _,
-            border,
-            src_format,
-            src_type,
-            Some(&pixels),
-        )
-        .unwrap();
 
-        self.user_textures.insert(tex_id, gl_texture);
+        gl.pixel_storei(Gl::UNPACK_ALIGNMENT, 1);
+
+        if let Some([x, y]) = pos {
+            gl.tex_sub_image_2d_with_i32_and_i32_and_u32_and_type_and_opt_u8_array(
+                Gl::TEXTURE_2D,
+                level,
+                x as _,
+                y as _,
+                w as _,
+                h as _,
+                src_format,
+                src_type,
+                Some(pixels),
+            )
+            .unwrap();
+        } else {
+            gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
+                Gl::TEXTURE_2D,
+                level,
+                internal_format as _,
+                w as _,
+                h as _,
+                border,
+                src_format,
+                src_type,
+                Some(pixels),
+            )
+            .unwrap();
+        }
+    }
+}
+
+impl epi::NativeTexture for WebGl2Painter {
+    type Texture = WebGlTexture;
+
+    fn register_native_texture(&mut self, native: Self::Texture) -> egui::TextureId {
+        let id = egui::TextureId::User(self.next_native_tex_id);
+        self.next_native_tex_id += 1;
+        self.textures.insert(id, native);
+        id
     }
 
-    fn free_texture(&mut self, tex_id: u64) {
-        self.user_textures.remove(&tex_id);
+    fn replace_native_texture(&mut self, id: egui::TextureId, native: Self::Texture) {
+        self.textures.insert(id, native);
+    }
+}
+
+impl crate::Painter for WebGl2Painter {
+    fn max_texture_side(&self) -> usize {
+        if let Ok(max_texture_side) = self
+            .gl
+            .get_parameter(web_sys::WebGl2RenderingContext::MAX_TEXTURE_SIZE)
+        {
+            if let Some(max_texture_side) = max_texture_side.as_f64() {
+                return max_texture_side as usize;
+            }
+        }
+
+        tracing::error!("Failed to query max texture size");
+
+        2048
+    }
+
+    fn set_texture(&mut self, tex_id: egui::TextureId, delta: &egui::epaint::ImageDelta) {
+        match &delta.image {
+            egui::ImageData::Color(image) => {
+                assert_eq!(
+                    image.width() * image.height(),
+                    image.pixels.len(),
+                    "Mismatch between texture size and texel count"
+                );
+
+                let data: &[u8] = bytemuck::cast_slice(image.pixels.as_ref());
+                self.set_texture_rgba(tex_id, delta.pos, image.size, data);
+            }
+            egui::ImageData::Alpha(image) => {
+                let gamma = 1.0;
+                let data: Vec<u8> = image
+                    .srgba_pixels(gamma)
+                    .flat_map(|a| a.to_array())
+                    .collect();
+                self.set_texture_rgba(tex_id, delta.pos, image.size, &data);
+            }
+        };
+    }
+
+    fn free_texture(&mut self, tex_id: egui::TextureId) {
+        self.textures.remove(&tex_id);
     }
 
     fn debug_info(&self) -> String {
@@ -307,44 +331,6 @@ impl crate::Painter for WebGl2Painter {
         &self.canvas_id
     }
 
-    fn upload_egui_texture(&mut self, font_image: &FontImage) {
-        if self.egui_texture_version == Some(font_image.version) {
-            return; // No change
-        }
-
-        let mut pixels: Vec<u8> = Vec::with_capacity(font_image.pixels.len() * 4);
-        for srgba in font_image.srgba_pixels(1.0) {
-            pixels.push(srgba.r());
-            pixels.push(srgba.g());
-            pixels.push(srgba.b());
-            pixels.push(srgba.a());
-        }
-
-        let gl = &self.gl;
-        gl.bind_texture(Gl::TEXTURE_2D, Some(&self.egui_texture));
-
-        let level = 0;
-        let internal_format = Gl::SRGB8_ALPHA8;
-        let border = 0;
-        let src_format = Gl::RGBA;
-        let src_type = Gl::UNSIGNED_BYTE;
-        gl.pixel_storei(Gl::UNPACK_ALIGNMENT, 1);
-        gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
-            Gl::TEXTURE_2D,
-            level,
-            internal_format as i32,
-            font_image.width as i32,
-            font_image.height as i32,
-            border,
-            src_format,
-            src_type,
-            Some(&pixels),
-        )
-        .unwrap();
-
-        self.egui_texture_version = Some(font_image.version);
-    }
-
     fn clear(&mut self, clear_color: egui::Rgba) {
         let gl = &self.gl;
 
@@ -424,10 +410,7 @@ impl crate::Painter for WebGl2Painter {
                     self.paint_mesh(&mesh)?;
                 }
             } else {
-                crate::console_warn(format!(
-                    "WebGL: Failed to find texture {:?}",
-                    mesh.texture_id
-                ));
+                tracing::warn!("WebGL: Failed to find texture {:?}", mesh.texture_id);
             }
         }
 
diff --git a/emath/Cargo.toml b/emath/Cargo.toml
index ef827550..61d63fa6 100644
--- a/emath/Cargo.toml
+++ b/emath/Cargo.toml
@@ -23,10 +23,6 @@ all-features = true
 
 [lib]
 
-[dependencies]
-bytemuck = { version = "1.7.2", features = ["derive"], optional = true }
-mint = { version = "0.5.6", optional = true }
-serde = { version = "1", features = ["derive"], optional = true }
 
 [features]
 default = []
@@ -35,3 +31,9 @@ default = []
 extra_debug_asserts = []
 # Always enable additional checks.
 extra_asserts = []
+
+
+[dependencies]
+bytemuck = { version = "1.7.2", features = ["derive"], optional = true }
+mint = { version = "0.5.6", optional = true }
+serde = { version = "1", features = ["derive"], optional = true }
diff --git a/emath/src/align.rs b/emath/src/align.rs
index 144a6eae..016b7d71 100644
--- a/emath/src/align.rs
+++ b/emath/src/align.rs
@@ -5,7 +5,6 @@ use crate::*;
 /// left/center/right or top/center/bottom alignment for e.g. anchors and layouts.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub enum Align {
     /// Left or top.
     Min,
@@ -47,20 +46,64 @@ impl Align {
         }
     }
 
-    /// ``` rust
-    /// assert_eq!(emath::Align::Min.align_size_within_range(2.0, 10.0..=20.0), 10.0..=12.0);
-    /// assert_eq!(emath::Align::Center.align_size_within_range(2.0, 10.0..=20.0), 14.0..=16.0);
-    /// assert_eq!(emath::Align::Max.align_size_within_range(2.0, 10.0..=20.0), 18.0..=20.0);
-    /// assert_eq!(emath::Align::Min.align_size_within_range(f32::INFINITY, 10.0..=20.0), 10.0..=f32::INFINITY);
-    /// assert_eq!(emath::Align::Center.align_size_within_range(f32::INFINITY, 10.0..=20.0), f32::NEG_INFINITY..=f32::INFINITY);
-    /// assert_eq!(emath::Align::Max.align_size_within_range(f32::INFINITY, 10.0..=20.0), f32::NEG_INFINITY..=20.0);
+    /// Returns a range of given size within a specified range.
     ///
-    /// assert_eq!(emath::Align::Min.align_size_within_range(f32::INFINITY, 10.0..=f32::INFINITY), 10.0..=f32::INFINITY);
-    /// assert_eq!(emath::Align::Min.align_size_within_range(f32::INFINITY, f32::NEG_INFINITY..=10.0), f32::NEG_INFINITY..=10.0);
-    /// assert_eq!(emath::Align::Center.align_size_within_range(f32::INFINITY, 10.0..=f32::INFINITY), 10.0..=f32::INFINITY);
-    /// assert_eq!(emath::Align::Center.align_size_within_range(f32::INFINITY, f32::NEG_INFINITY..=10.0), f32::NEG_INFINITY..=10.0);
-    /// assert_eq!(emath::Align::Max.align_size_within_range(f32::INFINITY, 10.0..=f32::INFINITY), 10.0..=f32::INFINITY);
-    /// assert_eq!(emath::Align::Max.align_size_within_range(f32::INFINITY, f32::NEG_INFINITY..=10.0), f32::NEG_INFINITY..=10.0);
+    /// If the requested `size` is bigger than the size of `range`, then the returned
+    /// range will not fit into the available `range`. The extra space will be allocated
+    /// from:
+    ///
+    /// |Align |Side        |
+    /// |------|------------|
+    /// |Min   |right (end) |
+    /// |Center|both        |
+    /// |Max   |left (start)|
+    ///
+    /// # Examples
+    /// ```
+    /// use std::f32::{INFINITY, NEG_INFINITY};
+    /// use emath::Align::*;
+    ///
+    /// // The size is smaller than a range
+    /// assert_eq!(Min   .align_size_within_range(2.0, 10.0..=20.0), 10.0..=12.0);
+    /// assert_eq!(Center.align_size_within_range(2.0, 10.0..=20.0), 14.0..=16.0);
+    /// assert_eq!(Max   .align_size_within_range(2.0, 10.0..=20.0), 18.0..=20.0);
+    ///
+    /// // The size is bigger than a range
+    /// assert_eq!(Min   .align_size_within_range(20.0, 10.0..=20.0), 10.0..=30.0);
+    /// assert_eq!(Center.align_size_within_range(20.0, 10.0..=20.0),  5.0..=25.0);
+    /// assert_eq!(Max   .align_size_within_range(20.0, 10.0..=20.0),  0.0..=20.0);
+    ///
+    /// // The size is infinity, but range is finite - a special case of a previous example
+    /// assert_eq!(Min   .align_size_within_range(INFINITY, 10.0..=20.0),         10.0..=INFINITY);
+    /// assert_eq!(Center.align_size_within_range(INFINITY, 10.0..=20.0), NEG_INFINITY..=INFINITY);
+    /// assert_eq!(Max   .align_size_within_range(INFINITY, 10.0..=20.0), NEG_INFINITY..=20.0);
+    /// ```
+    ///
+    /// The infinity-sized ranges can produce a surprising results, if the size is also infinity,
+    /// use such ranges with carefully!
+    ///
+    /// ```
+    /// use std::f32::{INFINITY, NEG_INFINITY};
+    /// use emath::Align::*;
+    ///
+    /// // Allocating a size aligned for infinity bound will lead to empty ranges!
+    /// assert_eq!(Min   .align_size_within_range(2.0, 10.0..=INFINITY),     10.0..=12.0);
+    /// assert_eq!(Center.align_size_within_range(2.0, 10.0..=INFINITY), INFINITY..=INFINITY);// (!)
+    /// assert_eq!(Max   .align_size_within_range(2.0, 10.0..=INFINITY), INFINITY..=INFINITY);// (!)
+    ///
+    /// assert_eq!(Min   .align_size_within_range(2.0, NEG_INFINITY..=20.0), NEG_INFINITY..=NEG_INFINITY);// (!)
+    /// assert_eq!(Center.align_size_within_range(2.0, NEG_INFINITY..=20.0), NEG_INFINITY..=NEG_INFINITY);// (!)
+    /// assert_eq!(Max   .align_size_within_range(2.0, NEG_INFINITY..=20.0),         18.0..=20.0);
+    ///
+    ///
+    /// // The infinity size will always return the given range if it has at least one infinity bound
+    /// assert_eq!(Min   .align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
+    /// assert_eq!(Center.align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
+    /// assert_eq!(Max   .align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
+    ///
+    /// assert_eq!(Min   .align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
+    /// assert_eq!(Center.align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
+    /// assert_eq!(Max   .align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
     /// ```
     #[inline]
     pub fn align_size_within_range(
@@ -102,7 +145,6 @@ impl Default for Align {
 /// Two-dimension alignment, e.g. [`Align2::LEFT_TOP`].
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub struct Align2(pub [Align; 2]);
 
 impl Align2 {
@@ -118,11 +160,13 @@ impl Align2 {
 }
 
 impl Align2 {
+    /// Returns an alignment by the X (horizontal) axis
     #[inline(always)]
     pub fn x(self) -> Align {
         self.0[0]
     }
 
+    /// Returns an alignment by the Y (vertical) axis
     #[inline(always)]
     pub fn y(self) -> Align {
         self.0[1]
@@ -156,6 +200,26 @@ impl Align2 {
         Rect::from_x_y_ranges(x_range, y_range)
     }
 
+    /// Returns the point on the rect's frame or in the center of a rect according
+    /// to the alignments of this object.
+    ///
+    /// ```text
+    /// (*)-----------+------(*)------+-----------(*)--> X
+    ///  |            |               |            |
+    ///  |  Min, Min  |  Center, Min  |  Max, Min  |
+    ///  |            |               |            |
+    ///  +------------+---------------+------------+
+    ///  |            |               |            |
+    /// (*)Min, Center|Center(*)Center|Max, Center(*)
+    ///  |            |               |            |
+    ///  +------------+---------------+------------+
+    ///  |            |               |            |
+    ///  |  Min, Max  | Center, Max   |  Max, Max  |
+    ///  |            |               |            |
+    /// (*)-----------+------(*)------+-----------(*)
+    ///  |
+    ///  Y
+    /// ```
     pub fn pos_in_rect(self, frame: &Rect) -> Pos2 {
         let x = match self.x() {
             Align::Min => frame.left(),
@@ -188,6 +252,11 @@ impl std::ops::IndexMut<usize> for Align2 {
     }
 }
 
+/// Allocates a rectangle of the specified `size` inside the `frame` rectangle
+/// around of its center.
+///
+/// If `size` is bigger than the `frame`s size the returned rect will bounce out
+/// of the `frame`.
 pub fn center_size_in_rect(size: Vec2, frame: Rect) -> Rect {
     Align2::CENTER_CENTER.align_size_within_rect(size, frame)
 }
diff --git a/emath/src/lib.rs b/emath/src/lib.rs
index efd11c6f..97fb41ed 100644
--- a/emath/src/lib.rs
+++ b/emath/src/lib.rs
@@ -8,6 +8,12 @@
 //! * X+ is right and Y+ is down.
 //! * (0,0) is left top.
 //! * Dimension order is always `x y`
+//!
+//! ## Integrating with other math libraries.
+//! `emath` does not strive to become a general purpose or all-powerful math library.
+//!
+//! For that, use something else ([`glam`](https://docs.rs/glam), [`nalgebra`](https://docs.rs/nalgebra), …)
+//! and enable the `mint` feature flag in `emath` to enable implicit conversion to/from `emath`.
 
 // Forbid warnings in release builds:
 #![cfg_attr(not(debug_assertions), deny(warnings))]
diff --git a/emath/src/pos2.rs b/emath/src/pos2.rs
index 460a40b0..409b0493 100644
--- a/emath/src/pos2.rs
+++ b/emath/src/pos2.rs
@@ -13,12 +13,14 @@ use crate::*;
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
 pub struct Pos2 {
+    /// How far to the right.
     pub x: f32,
+    /// How far down.
     pub y: f32,
     // implicit w = 1
 }
 
-/// `pos2(x,y) == Pos2::new(x, y)`
+/// `pos2(x, y) == Pos2::new(x, y)`
 #[inline(always)]
 pub const fn pos2(x: f32, y: f32) -> Pos2 {
     Pos2 { x, y }
@@ -91,6 +93,7 @@ impl From<&Pos2> for (f32, f32) {
 
 #[cfg(feature = "mint")]
 impl From<mint::Point2<f32>> for Pos2 {
+    #[inline(always)]
     fn from(v: mint::Point2<f32>) -> Self {
         Self::new(v.x, v.y)
     }
@@ -98,6 +101,7 @@ impl From<mint::Point2<f32>> for Pos2 {
 
 #[cfg(feature = "mint")]
 impl From<Pos2> for mint::Point2<f32> {
+    #[inline(always)]
     fn from(v: Pos2) -> Self {
         Self { x: v.x, y: v.y }
     }
diff --git a/emath/src/rect.rs b/emath/src/rect.rs
index a67af7a4..00617310 100644
--- a/emath/src/rect.rs
+++ b/emath/src/rect.rs
@@ -5,18 +5,29 @@ use crate::*;
 
 /// A rectangular region of space.
 ///
-/// Normally given in points, e.g. logical pixels.
+/// Usually a `Rect` has a positive (or zero) size,
+/// and then [`Self::min`] `<=` [`Self::max`].
+/// In these cases [`Self::min`] is the left-top corner
+/// and [`Self::max`] is the right-bottom corner.
+///
+/// A rectangle is allowed to have a negative size, which happens when the order
+/// of `min` and `max` are swapped. These are usually a sign of an error.
+///
+/// Normally the unit is points (logical pixels) in screen space coordinates.
 #[repr(C)]
 #[derive(Clone, Copy, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
 pub struct Rect {
+    /// One of the corners of the rectangle, usually the left top one.
     pub min: Pos2,
+
+    /// The other corner, opposing [`Self::min`]. Usually the right bottom one.
     pub max: Pos2,
 }
 
 impl Rect {
-    /// Infinite rectangle that contains everything.
+    /// Infinite rectangle that contains every point.
     pub const EVERYTHING: Self = Self {
         min: pos2(-INFINITY, -INFINITY),
         max: pos2(INFINITY, INFINITY),
@@ -25,19 +36,14 @@ impl Rect {
     /// The inverse of [`Self::EVERYTHING`]: stretches from positive infinity to negative infinity.
     /// Contains no points.
     ///
-    /// This is useful as the seed for bounding bounding boxes.
-    ///
-    /// ```
-    /// # use emath::*;
-    /// let inf = f32::INFINITY;
-    /// assert!(Rect::NOTHING.size() == Vec2::splat(-inf));
-    /// assert!(Rect::NOTHING.contains(pos2(0.0, 0.0)) == false);
-    /// ```
+    /// This is useful as the seed for bounding boxes.
     ///
     /// # Example:
     /// ```
     /// # use emath::*;
     /// let mut rect = Rect::NOTHING;
+    /// assert!(rect.size() == Vec2::splat(-f32::INFINITY));
+    /// assert!(rect.contains(pos2(0.0, 0.0)) == false);
     /// rect.extend_with(pos2(2.0, 1.0));
     /// rect.extend_with(pos2(0.0, 3.0));
     /// assert_eq!(rect, Rect::from_min_max(pos2(0.0, 1.0), pos2(2.0, 3.0)))
@@ -50,7 +56,7 @@ impl Rect {
     /// An invalid `Rect` filled with [`f32::NAN`];
     pub const NAN: Self = Self {
         min: pos2(f32::NAN, f32::NAN),
-        max: pos2(-f32::NAN, -f32::NAN),
+        max: pos2(f32::NAN, f32::NAN),
     };
 
     #[inline(always)]
@@ -58,6 +64,7 @@ impl Rect {
         Rect { min, max }
     }
 
+    /// left-top corner plus a size (stretching right-down).
     #[inline(always)]
     pub fn from_min_size(min: Pos2, size: Vec2) -> Self {
         Rect {
@@ -82,6 +89,7 @@ impl Rect {
         }
     }
 
+    /// Returns the bounding rectangle of the two points.
     #[inline]
     pub fn from_two_pos(a: Pos2, b: Pos2) -> Self {
         Rect {
@@ -90,7 +98,7 @@ impl Rect {
         }
     }
 
-    /// Bounding-box around the points
+    /// Bounding-box around the points.
     pub fn from_points(points: &[Pos2]) -> Self {
         let mut rect = Rect::NOTHING;
         for &p in points {
diff --git a/emath/src/vec2.rs b/emath/src/vec2.rs
index 2a8595bc..35205d16 100644
--- a/emath/src/vec2.rs
+++ b/emath/src/vec2.rs
@@ -11,11 +11,13 @@ use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
 pub struct Vec2 {
+    /// Rightwards. Width.
     pub x: f32,
+    /// Downwards. Height.
     pub y: f32,
 }
 
-/// `vec2(x,y) == Vec2::new(x, y)`
+/// `vec2(x, y) == Vec2::new(x, y)`
 #[inline(always)]
 pub const fn vec2(x: f32, y: f32) -> Vec2 {
     Vec2 { x, y }
@@ -88,6 +90,7 @@ impl From<&Vec2> for (f32, f32) {
 
 #[cfg(feature = "mint")]
 impl From<mint::Vector2<f32>> for Vec2 {
+    #[inline]
     fn from(v: mint::Vector2<f32>) -> Self {
         Self::new(v.x, v.y)
     }
@@ -95,6 +98,7 @@ impl From<mint::Vector2<f32>> for Vec2 {
 
 #[cfg(feature = "mint")]
 impl From<Vec2> for mint::Vector2<f32> {
+    #[inline]
     fn from(v: Vec2) -> Self {
         Self { x: v.x, y: v.y }
     }
diff --git a/epaint/CHANGELOG.md b/epaint/CHANGELOG.md
index 90b9522c..4395c203 100644
--- a/epaint/CHANGELOG.md
+++ b/epaint/CHANGELOG.md
@@ -4,8 +4,13 @@ All notable changes to the epaint crate will be documented in this file.
 
 
 ## Unreleased
-
+* Much improved font selection ([#1154](https://github.com/emilk/egui/pull/1154)):
+  * Replaced `TextStyle` with `FontId` which lets you pick any font size and font family.
+  * Replaced `Fonts::font_image` with `font_image_delta` for partial font atlas updates.
+* Added `ImageData` and `TextureManager` for loading images into textures ([#1110](https://github.com/emilk/egui/pull/1110)).
 * Added `Shape::dashed_line_many` ([#1027](https://github.com/emilk/egui/pull/1027)).
+* Replaced `corner_radius: f32` with `rounding: Rounding`, allowing per-corner rounding settings ([#1206](https://github.com/emilk/egui/pull/1206)).
+
 
 ## 0.16.0 - 2021-12-29
 * Anti-alias path ends  ([#893](https://github.com/emilk/egui/pull/893)).
@@ -16,5 +21,5 @@ All notable changes to the epaint crate will be documented in this file.
 ## 0.15.0 - 2021-10-24
 * `Fonts::layout_job`: New text layout engine allowing mixing fonts, colors and styles, with underlining and strikethrough.
 * New `CircleShape`, `PathShape`, `RectShape` and `TextShape` used in `enum Shape`.
-* Add support for rotated text (see `TextShape`).
+* Added support for rotated text (see `TextShape`).
 * Added `"convert_bytemuck"` feature.
diff --git a/epaint/Cargo.toml b/epaint/Cargo.toml
index debfc233..3ea7eaa1 100644
--- a/epaint/Cargo.toml
+++ b/epaint/Cargo.toml
@@ -25,17 +25,6 @@ all-features = true
 
 [lib]
 
-[dependencies]
-emath = { version = "0.16.0", path = "../emath" }
-
-ab_glyph = "0.2.11"
-ahash = { version = "0.7", features = ["std"], default-features = false }
-atomic_refcell = { version = "0.1", optional = true } # Used instead of parking_lot when you are always using epaint in a single thread. About as fast as parking_lot. Panics on multi-threaded use.
-bytemuck = { version = "1.7.2", features = ["derive"], optional = true }
-cint = { version = "^0.2.2", optional = true }
-nohash-hasher = "0.2"
-parking_lot = { version = "0.11", optional = true } # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
-serde = { version = "1", features = ["derive"], optional = true }
 
 [features]
 default = ["default_fonts", "multi_threaded"]
@@ -64,9 +53,23 @@ single_threaded = ["atomic_refcell"]
 # It comes with a minor performance impact.
 multi_threaded = ["parking_lot"]
 
+
+[dependencies]
+emath = { version = "0.16.0", path = "../emath" }
+
+ab_glyph = "0.2.11"
+ahash = { version = "0.7", features = ["std"], default-features = false }
+atomic_refcell = { version = "0.1", optional = true } # Used instead of parking_lot when you are always using epaint in a single thread. About as fast as parking_lot. Panics on multi-threaded use.
+bytemuck = { version = "1.7.2", features = ["derive"], optional = true }
+cint = { version = "^0.2.2", optional = true }
+nohash-hasher = "0.2"
+parking_lot = { version = "0.11", optional = true } # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
+serde = { version = "1", features = ["derive", "rc"], optional = true }
+
 [dev-dependencies]
 criterion = { version = "0.3", default-features = false }
 
+
 [[bench]]
 name = "benchmark"
 harness = false
diff --git a/epaint/src/bezier.rs b/epaint/src/bezier.rs
new file mode 100644
index 00000000..b17cf912
--- /dev/null
+++ b/epaint/src/bezier.rs
@@ -0,0 +1,1101 @@
+#![allow(clippy::many_single_char_names)]
+use std::ops::Range;
+
+use crate::{shape::Shape, Color32, PathShape, Stroke};
+use emath::*;
+
+// ----------------------------------------------------------------------------
+
+/// How to paint a cubic Bezier curve on screen.
+/// The definition: [Bezier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+/// This implementation is only for cubic Bezier curve, or the Bezier curve of degree 3.
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct CubicBezierShape {
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle points are the control points.
+    pub points: [Pos2; 4],
+    pub closed: bool,
+
+    pub fill: Color32,
+    pub stroke: Stroke,
+}
+
+impl CubicBezierShape {
+    /// Creates a cubic Bezier curve based on 4 points and stroke.
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle points are the control points.
+    /// The number of points must be 4.
+    pub fn from_points_stroke(
+        points: Vec<Pos2>,
+        closed: bool,
+        fill: Color32,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        crate::epaint_assert!(points.len() == 4, "Cubic needs 4 points");
+        Self {
+            points: points.try_into().unwrap(),
+            closed,
+            fill,
+            stroke: stroke.into(),
+        }
+    }
+
+    /// Creates a cubic Bezier curve based on the screen coordinates for the 4 points.
+    pub fn to_screen(&self, to_screen: &RectTransform) -> Self {
+        let mut points = [Pos2::default(); 4];
+        for (i, origin_point) in self.points.iter().enumerate() {
+            points[i] = to_screen * *origin_point;
+        }
+        CubicBezierShape {
+            points,
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    /// Convert the cubic Bezier curve to one or two `PathShapes`.
+    /// When the curve is closed and it has to intersect with the base line, it will be converted into two shapes.
+    /// Otherwise, it will be converted into one shape.
+    /// The `tolerance` will be used to control the max distance between the curve and the base line.
+    /// The `epsilon` is used when comparing two floats.
+    pub fn to_pathshapes(&self, tolerance: Option<f32>, epsilon: Option<f32>) -> Vec<PathShape> {
+        let mut pathshapes = Vec::new();
+        let mut points_vec = self.flatten_closed(tolerance, epsilon);
+        for points in points_vec.drain(..) {
+            let pathshape = PathShape {
+                points,
+                closed: self.closed,
+                fill: self.fill,
+                stroke: self.stroke,
+            };
+            pathshapes.push(pathshape);
+        }
+        pathshapes
+    }
+    /// Screen-space bounding rectangle.
+    pub fn bounding_rect(&self) -> Rect {
+        //temporary solution
+        let (mut min_x, mut max_x) = if self.points[0].x < self.points[3].x {
+            (self.points[0].x, self.points[3].x)
+        } else {
+            (self.points[3].x, self.points[0].x)
+        };
+        let (mut min_y, mut max_y) = if self.points[0].y < self.points[3].y {
+            (self.points[0].y, self.points[3].y)
+        } else {
+            (self.points[3].y, self.points[0].y)
+        };
+
+        // find the inflection points and get the x value
+        cubic_for_each_local_extremum(
+            self.points[0].x,
+            self.points[1].x,
+            self.points[2].x,
+            self.points[3].x,
+            &mut |t| {
+                let x = self.sample(t).x;
+                if x < min_x {
+                    min_x = x;
+                }
+                if x > max_x {
+                    max_x = x;
+                }
+            },
+        );
+
+        // find the inflection points and get the y value
+        cubic_for_each_local_extremum(
+            self.points[0].y,
+            self.points[1].y,
+            self.points[2].y,
+            self.points[3].y,
+            &mut |t| {
+                let y = self.sample(t).y;
+                if y < min_y {
+                    min_y = y;
+                }
+                if y > max_y {
+                    max_y = y;
+                }
+            },
+        );
+
+        Rect {
+            min: Pos2 { x: min_x, y: min_y },
+            max: Pos2 { x: max_x, y: max_y },
+        }
+    }
+
+    /// split the original cubic curve into a new one within a range.
+    pub fn split_range(&self, t_range: Range<f32>) -> Self {
+        crate::epaint_assert!(
+            t_range.start >= 0.0 && t_range.end <= 1.0 && t_range.start <= t_range.end,
+            "range should be in [0.0,1.0]"
+        );
+
+        let from = self.sample(t_range.start);
+        let to = self.sample(t_range.end);
+
+        let d_from = self.points[1] - self.points[0].to_vec2();
+        let d_ctrl = self.points[2] - self.points[1].to_vec2();
+        let d_to = self.points[3] - self.points[2].to_vec2();
+        let q = QuadraticBezierShape {
+            points: [d_from, d_ctrl, d_to],
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        };
+        let delta_t = t_range.end - t_range.start;
+        let q_start = q.sample(t_range.start);
+        let q_end = q.sample(t_range.end);
+        let ctrl1 = from + q_start.to_vec2() * delta_t;
+        let ctrl2 = to - q_end.to_vec2() * delta_t;
+        CubicBezierShape {
+            points: [from, ctrl1, ctrl2, to],
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    // copied from lyon::geom::flattern_cubic.rs
+    // Computes the number of quadratic bézier segments to approximate a cubic one.
+    // Derived by Raph Levien from section 10.6 of Sedeberg's CAGD notes
+    // https://scholarsarchive.byu.edu/cgi/viewcontent.cgi?article=1000&context=facpub#section.10.6
+    // and the error metric from the caffein owl blog post http://caffeineowl.com/graphics/2d/vectorial/cubic2quad01.html
+    pub fn num_quadratics(&self, tolerance: f32) -> u32 {
+        crate::epaint_assert!(tolerance > 0.0, "the tolerance should be positive");
+
+        let x =
+            self.points[0].x - 3.0 * self.points[1].x + 3.0 * self.points[2].x - self.points[3].x;
+        let y =
+            self.points[0].y - 3.0 * self.points[1].y + 3.0 * self.points[2].y - self.points[3].y;
+        let err = x * x + y * y;
+
+        (err / (432.0 * tolerance * tolerance))
+            .powf(1.0 / 6.0)
+            .ceil()
+            .max(1.0) as u32
+    }
+
+    /// Find out the t value for the point where the curve is intersected with the base line.
+    /// The base line is the line from P0 to P3.
+    /// If the curve only has two intersection points with the base line, they should be 0.0 and 1.0.
+    /// In this case, the "fill" will be simple since the curve is a convex line.
+    /// If the curve has more than two intersection points with the base line, the "fill" will be a problem.
+    /// We need to find out where is the 3rd t value (0<t<1)
+    /// And the original cubic curve will be split into two curves (0.0..t and t..1.0).
+    /// B(t) = (1-t)^3*P0 + 3*t*(1-t)^2*P1 + 3*t^2*(1-t)*P2 + t^3*P3
+    /// or B(t) = (P3 - 3*P2 + 3*P1 - P0)*t^3 + (3*P2 - 6*P1 + 3*P0)*t^2 + (3*P1 - 3*P0)*t + P0
+    /// this B(t) should be on the line between P0 and P3. Therefore:
+    /// (B.x - P0.x)/(P3.x - P0.x) = (B.y - P0.y)/(P3.y - P0.y), or:
+    /// B.x * (P3.y - P0.y) - B.y * (P3.x - P0.x) + P0.x * (P0.y - P3.y) + P0.y * (P3.x - P0.x) = 0
+    /// B.x = (P3.x - 3 * P2.x + 3 * P1.x - P0.x) * t^3 + (3 * P2.x - 6 * P1.x + 3 * P0.x) * t^2 + (3 * P1.x - 3 * P0.x) * t + P0.x
+    /// B.y = (P3.y - 3 * P2.y + 3 * P1.y - P0.y) * t^3 + (3 * P2.y - 6 * P1.y + 3 * P0.y) * t^2 + (3 * P1.y - 3 * P0.y) * t + P0.y
+    /// Combine the above three equations and iliminate B.x and B.y, we get:
+    /// t^3 * ( (P3.x - 3*P2.x + 3*P1.x - P0.x) * (P3.y - P0.y) - (P3.y - 3*P2.y + 3*P1.y - P0.y) * (P3.x - P0.x))
+    /// + t^2 * ( (3 * P2.x - 6 * P1.x + 3 * P0.x) * (P3.y - P0.y) - (3 * P2.y - 6 * P1.y + 3 * P0.y) * (P3.x - P0.x))
+    /// + t^1 * ( (3 * P1.x - 3 * P0.x) * (P3.y - P0.y) - (3 * P1.y - 3 * P0.y) * (P3.x - P0.x))
+    /// + (P0.x * (P3.y - P0.y) - P0.y * (P3.x - P0.x)) + P0.x * (P0.y - P3.y) + P0.y * (P3.x - P0.x)
+    /// = 0
+    /// or a * t^3 + b * t^2 + c * t + d = 0
+    ///
+    /// let x = t - b / (3 * a), then we have:
+    /// x^3 + p * x + q = 0, where:
+    /// p = (3.0 * a * c - b^2) / (3.0 * a^2)
+    /// q = (2.0 * b^3 - 9.0 * a * b * c + 27.0 * a^2 * d) / (27.0 * a^3)
+    ///
+    /// when p > 0, there will be one real root, two complex roots
+    /// when p = 0, there will be two real roots, when p=q=0, there will be three real roots but all 0.
+    /// when p < 0, there will be three unique real roots. this is what we need. (x1, x2, x3)
+    ///  t = x + b / (3 * a), then we have: t1, t2, t3.
+    /// the one between 0.0 and 1.0 is what we need.
+    /// <`https://baike.baidu.com/item/%E4%B8%80%E5%85%83%E4%B8%89%E6%AC%A1%E6%96%B9%E7%A8%8B/8388473 /`>
+    ///
+    pub fn find_cross_t(&self, epsilon: f32) -> Option<f32> {
+        let p0 = self.points[0];
+        let p1 = self.points[1];
+        let p2 = self.points[2];
+        let p3 = self.points[3];
+
+        let a = (p3.x - 3.0 * p2.x + 3.0 * p1.x - p0.x) * (p3.y - p0.y)
+            - (p3.y - 3.0 * p2.y + 3.0 * p1.y - p0.y) * (p3.x - p0.x);
+        let b = (3.0 * p2.x - 6.0 * p1.x + 3.0 * p0.x) * (p3.y - p0.y)
+            - (3.0 * p2.y - 6.0 * p1.y + 3.0 * p0.y) * (p3.x - p0.x);
+        let c =
+            (3.0 * p1.x - 3.0 * p0.x) * (p3.y - p0.y) - (3.0 * p1.y - 3.0 * p0.y) * (p3.x - p0.x);
+        let d = p0.x * (p3.y - p0.y) - p0.y * (p3.x - p0.x)
+            + p0.x * (p0.y - p3.y)
+            + p0.y * (p3.x - p0.x);
+
+        let h = -b / (3.0 * a);
+        let p = (3.0 * a * c - b * b) / (3.0 * a * a);
+        let q = (2.0 * b * b * b - 9.0 * a * b * c + 27.0 * a * a * d) / (27.0 * a * a * a);
+
+        if p > 0.0 {
+            return None;
+        }
+        let r = (-1.0 * (p / 3.0).powi(3)).sqrt();
+        let theta = (-1.0 * q / (2.0 * r)).acos() / 3.0;
+
+        let t1 = 2.0 * r.cbrt() * theta.cos() + h;
+        let t2 = 2.0 * r.cbrt() * (theta + 120.0 * std::f32::consts::PI / 180.0).cos() + h;
+        let t3 = 2.0 * r.cbrt() * (theta + 240.0 * std::f32::consts::PI / 180.0).cos() + h;
+
+        if t1 > epsilon && t1 < 1.0 - epsilon {
+            return Some(t1);
+        }
+        if t2 > epsilon && t2 < 1.0 - epsilon {
+            return Some(t2);
+        }
+        if t3 > epsilon && t3 < 1.0 - epsilon {
+            return Some(t3);
+        }
+        None
+    }
+
+    /// Calculate the point (x,y) at t based on the cubic bezier curve equation.
+    /// t is in [0.0,1.0]
+    /// [Bezier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Cubic_B.C3.A9zier_curves)
+    ///
+    pub fn sample(&self, t: f32) -> Pos2 {
+        crate::epaint_assert!(
+            t >= 0.0 && t <= 1.0,
+            "the sample value should be in [0.0,1.0]"
+        );
+
+        let h = 1.0 - t;
+        let a = t * t * t;
+        let b = 3.0 * t * t * h;
+        let c = 3.0 * t * h * h;
+        let d = h * h * h;
+        let result = self.points[3].to_vec2() * a
+            + self.points[2].to_vec2() * b
+            + self.points[1].to_vec2() * c
+            + self.points[0].to_vec2() * d;
+        result.to_pos2()
+    }
+
+    /// find a set of points that approximate the cubic bezier curve.
+    /// the number of points is determined by the tolerance.
+    /// the points may not be evenly distributed in the range [0.0,1.0] (t value)
+    pub fn flatten(&self, tolerance: Option<f32>) -> Vec<Pos2> {
+        let tolerance = tolerance.unwrap_or((self.points[0].x - self.points[3].x).abs() * 0.001);
+        let mut result = vec![self.points[0]];
+        self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+            result.push(p);
+        });
+        result
+    }
+
+    /// find a set of points that approximate the cubic bezier curve.
+    /// the number of points is determined by the tolerance.
+    /// the points may not be evenly distributed in the range [0.0,1.0] (t value)
+    /// this api will check whether the curve will cross the base line or not when closed = true.
+    /// The result will be a vec of vec of Pos2. it will store two closed aren in different vec.
+    /// The epsilon is used to compare a float value.
+    pub fn flatten_closed(&self, tolerance: Option<f32>, epsilon: Option<f32>) -> Vec<Vec<Pos2>> {
+        let tolerance = tolerance.unwrap_or((self.points[0].x - self.points[3].x).abs() * 0.001);
+        let epsilon = epsilon.unwrap_or(1.0e-5);
+        let mut result = Vec::new();
+        let mut first_half = Vec::new();
+        let mut second_half = Vec::new();
+        let mut flipped = false;
+        first_half.push(self.points[0]);
+
+        let cross = self.find_cross_t(epsilon);
+        match cross {
+            Some(cross) => {
+                if self.closed {
+                    self.for_each_flattened_with_t(tolerance, &mut |p, t| {
+                        if t < cross {
+                            first_half.push(p);
+                        } else {
+                            if !flipped {
+                                // when just crossed the base line, flip the order of the points
+                                // add the cross point to the first half as the last point
+                                // and add the cross point to the second half as the first point
+                                flipped = true;
+                                let cross_point = self.sample(cross);
+                                first_half.push(cross_point);
+                                second_half.push(cross_point);
+                            }
+                            second_half.push(p);
+                        }
+                    });
+                } else {
+                    self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+                        first_half.push(p);
+                    });
+                }
+            }
+            None => {
+                self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+                    first_half.push(p);
+                });
+            }
+        }
+
+        result.push(first_half);
+        if !second_half.is_empty() {
+            result.push(second_half);
+        }
+        result
+    }
+    // from lyon_geom::cubic_bezier.rs
+    /// Iterates through the curve invoking a callback at each point.
+    pub fn for_each_flattened_with_t<F: FnMut(Pos2, f32)>(&self, tolerance: f32, callback: &mut F) {
+        flatten_cubic_bezier_with_t(self, tolerance, callback);
+    }
+}
+
+impl From<CubicBezierShape> for Shape {
+    #[inline(always)]
+    fn from(shape: CubicBezierShape) -> Self {
+        Self::CubicBezier(shape)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct QuadraticBezierShape {
+    /// The first point is the starting point and the last one is the ending point of the curve.
+    /// The middle point is the control points.
+    pub points: [Pos2; 3],
+    pub closed: bool,
+
+    pub fill: Color32,
+    pub stroke: Stroke,
+}
+
+impl QuadraticBezierShape {
+    /// create a new quadratic bezier shape based on the 3 points and stroke.
+    /// the first point is the starting point and the last one is the ending point of the curve.
+    /// the middle point is the control points.
+    /// the points should be in the order [start, control, end]
+    ///
+    pub fn from_points_stroke(
+        points: Vec<Pos2>,
+        closed: bool,
+        fill: Color32,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        crate::epaint_assert!(points.len() == 3, "Quadratic needs 3 points");
+
+        QuadraticBezierShape {
+            points: points.try_into().unwrap(), // it's safe to unwrap because we just checked
+            closed,
+            fill,
+            stroke: stroke.into(),
+        }
+    }
+
+    /// create a new quadratic bezier shape based on the screen coordination for the 3 points.
+    pub fn to_screen(&self, to_screen: &RectTransform) -> Self {
+        let mut points = [Pos2::default(); 3];
+        for (i, origin_point) in self.points.iter().enumerate() {
+            points[i] = to_screen * *origin_point;
+        }
+        QuadraticBezierShape {
+            points,
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+
+    /// Convert the quadratic Bezier curve to one `PathShape`.
+    /// The `tolerance` will be used to control the max distance between the curve and the base line.
+    pub fn to_pathshape(&self, tolerance: Option<f32>) -> PathShape {
+        let points = self.flatten(tolerance);
+        PathShape {
+            points,
+            closed: self.closed,
+            fill: self.fill,
+            stroke: self.stroke,
+        }
+    }
+    /// bounding box of the quadratic bezier shape
+    pub fn bounding_rect(&self) -> Rect {
+        let (mut min_x, mut max_x) = if self.points[0].x < self.points[2].x {
+            (self.points[0].x, self.points[2].x)
+        } else {
+            (self.points[2].x, self.points[0].x)
+        };
+        let (mut min_y, mut max_y) = if self.points[0].y < self.points[2].y {
+            (self.points[0].y, self.points[2].y)
+        } else {
+            (self.points[2].y, self.points[0].y)
+        };
+
+        quadratic_for_each_local_extremum(
+            self.points[0].x,
+            self.points[1].x,
+            self.points[2].x,
+            &mut |t| {
+                let x = self.sample(t).x;
+                if x < min_x {
+                    min_x = x;
+                }
+                if x > max_x {
+                    max_x = x;
+                }
+            },
+        );
+
+        quadratic_for_each_local_extremum(
+            self.points[0].y,
+            self.points[1].y,
+            self.points[2].y,
+            &mut |t| {
+                let y = self.sample(t).y;
+                if y < min_y {
+                    min_y = y;
+                }
+                if y > max_y {
+                    max_y = y;
+                }
+            },
+        );
+
+        Rect {
+            min: Pos2 { x: min_x, y: min_y },
+            max: Pos2 { x: max_x, y: max_y },
+        }
+    }
+
+    /// Calculate the point (x,y) at t based on the quadratic bezier curve equation.
+    /// t is in [0.0,1.0]
+    /// [Bezier Curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Quadratic_B.C3.A9zier_curves)
+    ///
+    pub fn sample(&self, t: f32) -> Pos2 {
+        crate::epaint_assert!(
+            t >= 0.0 && t <= 1.0,
+            "the sample value should be in [0.0,1.0]"
+        );
+
+        let h = 1.0 - t;
+        let a = t * t;
+        let b = 2.0 * t * h;
+        let c = h * h;
+        let result = self.points[2].to_vec2() * a
+            + self.points[1].to_vec2() * b
+            + self.points[0].to_vec2() * c;
+        result.to_pos2()
+    }
+
+    /// find a set of points that approximate the quadratic bezier curve.
+    /// the number of points is determined by the tolerance.
+    /// the points may not be evenly distributed in the range [0.0,1.0] (t value)
+    pub fn flatten(&self, tolerance: Option<f32>) -> Vec<Pos2> {
+        let tolerance = tolerance.unwrap_or((self.points[0].x - self.points[2].x).abs() * 0.001);
+        let mut result = vec![self.points[0]];
+        self.for_each_flattened_with_t(tolerance, &mut |p, _t| {
+            result.push(p);
+        });
+        result
+    }
+
+    // copied from https://docs.rs/lyon_geom/latest/lyon_geom/
+    /// Compute a flattened approximation of the curve, invoking a callback at
+    /// each step.
+    ///
+    /// The callback takes the point and corresponding curve parameter at each step.
+    ///
+    /// This implements the algorithm described by Raph Levien at
+    /// <https://raphlinus.github.io/graphics/curves/2019/12/23/flatten-quadbez.html>
+    pub fn for_each_flattened_with_t<F>(&self, tolerance: f32, callback: &mut F)
+    where
+        F: FnMut(Pos2, f32),
+    {
+        let params = FlatteningParameters::from_curve(self, tolerance);
+        if params.is_point {
+            return;
+        }
+
+        let count = params.count as u32;
+        for index in 1..count {
+            let t = params.t_at_iteration(index as f32);
+
+            callback(self.sample(t), t);
+        }
+
+        callback(self.sample(1.0), 1.0);
+    }
+}
+
+impl From<QuadraticBezierShape> for Shape {
+    #[inline(always)]
+    fn from(shape: QuadraticBezierShape) -> Self {
+        Self::QuadraticBezier(shape)
+    }
+}
+
+// lyon_geom::flatten_cubic.rs
+// copied from https://docs.rs/lyon_geom/latest/lyon_geom/
+fn flatten_cubic_bezier_with_t<F: FnMut(Pos2, f32)>(
+    curve: &CubicBezierShape,
+    tolerance: f32,
+    callback: &mut F,
+) {
+    // debug_assert!(tolerance >= S::EPSILON * S::EPSILON);
+    let quadratics_tolerance = tolerance * 0.2;
+    let flattening_tolerance = tolerance * 0.8;
+
+    let num_quadratics = curve.num_quadratics(quadratics_tolerance);
+    let step = 1.0 / num_quadratics as f32;
+    let n = num_quadratics;
+    let mut t0 = 0.0;
+    for _ in 0..(n - 1) {
+        let t1 = t0 + step;
+
+        let quadratic = single_curve_approximation(&curve.split_range(t0..t1));
+        quadratic.for_each_flattened_with_t(flattening_tolerance, &mut |point, t_sub| {
+            let t = t0 + step * t_sub;
+            callback(point, t);
+        });
+
+        t0 = t1;
+    }
+
+    // Do the last step manually to make sure we finish at t = 1.0 exactly.
+    let quadratic = single_curve_approximation(&curve.split_range(t0..1.0));
+    quadratic.for_each_flattened_with_t(flattening_tolerance, &mut |point, t_sub| {
+        let t = t0 + step * t_sub;
+        callback(point, t);
+    });
+}
+// from lyon_geom::quadratic_bezier.rs
+// copied from https://docs.rs/lyon_geom/latest/lyon_geom/
+struct FlatteningParameters {
+    count: f32,
+    integral_from: f32,
+    integral_step: f32,
+    inv_integral_from: f32,
+    div_inv_integral_diff: f32,
+    is_point: bool,
+}
+
+impl FlatteningParameters {
+    // https://raphlinus.github.io/graphics/curves/2019/12/23/flatten-quadbez.html
+    pub fn from_curve(curve: &QuadraticBezierShape, tolerance: f32) -> Self {
+        // Map the quadratic bézier segment to y = x^2 parabola.
+        let from = curve.points[0];
+        let ctrl = curve.points[1];
+        let to = curve.points[2];
+
+        let ddx = 2.0 * ctrl.x - from.x - to.x;
+        let ddy = 2.0 * ctrl.y - from.y - to.y;
+        let cross = (to.x - from.x) * ddy - (to.y - from.y) * ddx;
+        let inv_cross = 1.0 / cross;
+        let parabola_from = ((ctrl.x - from.x) * ddx + (ctrl.y - from.y) * ddy) * inv_cross;
+        let parabola_to = ((to.x - ctrl.x) * ddx + (to.y - ctrl.y) * ddy) * inv_cross;
+        // Note, scale can be NaN, for example with straight lines. When it happens the NaN will
+        // propagate to other parameters. We catch it all by setting the iteration count to zero
+        // and leave the rest as garbage.
+        let scale = cross.abs() / (ddx.hypot(ddy) * (parabola_to - parabola_from).abs());
+
+        let integral_from = approx_parabola_integral(parabola_from);
+        let integral_to = approx_parabola_integral(parabola_to);
+        let integral_diff = integral_to - integral_from;
+
+        let inv_integral_from = approx_parabola_inv_integral(integral_from);
+        let inv_integral_to = approx_parabola_inv_integral(integral_to);
+        let div_inv_integral_diff = 1.0 / (inv_integral_to - inv_integral_from);
+
+        // the original author thinks it can be stored as integer if it's not generic.
+        // but if so, we have to handle the edge case of the integral being infinite.
+        let mut count = (0.5 * integral_diff.abs() * (scale / tolerance).sqrt()).ceil();
+        let mut is_point = false;
+        // If count is NaN the curve can be approximated by a single straight line or a point.
+        if !count.is_finite() {
+            count = 0.0;
+            is_point = (to.x - from.x).hypot(to.y - from.y) < tolerance * tolerance;
+        }
+
+        let integral_step = integral_diff / count;
+
+        FlatteningParameters {
+            count,
+            integral_from,
+            integral_step,
+            inv_integral_from,
+            div_inv_integral_diff,
+            is_point,
+        }
+    }
+
+    fn t_at_iteration(&self, iteration: f32) -> f32 {
+        let u = approx_parabola_inv_integral(self.integral_from + self.integral_step * iteration);
+        (u - self.inv_integral_from) * self.div_inv_integral_diff
+    }
+}
+
+/// Compute an approximation to integral (1 + 4x^2) ^ -0.25 dx used in the flattening code.
+fn approx_parabola_integral(x: f32) -> f32 {
+    let d: f32 = 0.67;
+    let quarter = 0.25;
+    x / (1.0 - d + (d.powi(4) + quarter * x * x).sqrt().sqrt())
+}
+
+/// Approximate the inverse of the function above.
+fn approx_parabola_inv_integral(x: f32) -> f32 {
+    let b = 0.39;
+    let quarter = 0.25;
+    x * (1.0 - b + (b * b + quarter * x * x).sqrt())
+}
+
+fn single_curve_approximation(curve: &CubicBezierShape) -> QuadraticBezierShape {
+    let c1_x = (curve.points[1].x * 3.0 - curve.points[0].x) * 0.5;
+    let c1_y = (curve.points[1].y * 3.0 - curve.points[0].y) * 0.5;
+    let c2_x = (curve.points[2].x * 3.0 - curve.points[3].x) * 0.5;
+    let c2_y = (curve.points[2].y * 3.0 - curve.points[3].y) * 0.5;
+    let c = Pos2 {
+        x: (c1_x + c2_x) * 0.5,
+        y: (c1_y + c2_y) * 0.5,
+    };
+    QuadraticBezierShape {
+        points: [curve.points[0], c, curve.points[3]],
+        closed: curve.closed,
+        fill: curve.fill,
+        stroke: curve.stroke,
+    }
+}
+
+fn quadratic_for_each_local_extremum<F: FnMut(f32)>(p0: f32, p1: f32, p2: f32, cb: &mut F) {
+    // A quadratic bezier curve can be derived by a linear function:
+    // p(t) = p0 + t(p1 - p0) + t^2(p2 - 2p1 + p0)
+    // The derivative is:
+    // p'(t) = (p1 - p0) + 2(p2 - 2p1 + p0)t or:
+    // f(x) = a* x + b
+    let a = p2 - 2.0 * p1 + p0;
+    // let b = p1 - p0;
+    // no need to check for zero, since we're only interested in local extrema
+    if a == 0.0 {
+        return;
+    }
+
+    let t = (p0 - p1) / a;
+    if t > 0.0 && t < 1.0 {
+        cb(t);
+    }
+}
+
+fn cubic_for_each_local_extremum<F: FnMut(f32)>(p0: f32, p1: f32, p2: f32, p3: f32, cb: &mut F) {
+    // See www.faculty.idc.ac.il/arik/quality/appendixa.html for an explanation
+    // A cubic bezier curve can be derivated by the following equation:
+    // B'(t) = 3(1-t)^2(p1-p0) + 6(1-t)t(p2-p1) + 3t^2(p3-p2) or
+    // f(x) = a * x² + b * x + c
+    let a = 3.0 * (p3 + 3.0 * (p1 - p2) - p0);
+    let b = 6.0 * (p2 - 2.0 * p1 + p0);
+    let c = 3.0 * (p1 - p0);
+
+    let in_range = |t: f32| t <= 1.0 && t >= 0.0;
+
+    // linear situation
+    if a == 0.0 {
+        if b != 0.0 {
+            let t = -c / b;
+            if in_range(t) {
+                cb(t);
+            }
+        }
+        return;
+    }
+
+    let discr = b * b - 4.0 * a * c;
+    // no Real solution
+    if discr < 0.0 {
+        return;
+    }
+
+    // one Real solution
+    if discr == 0.0 {
+        let t = -b / (2.0 * a);
+        if in_range(t) {
+            cb(t);
+        }
+        return;
+    }
+
+    // two Real solutions
+    let discr = discr.sqrt();
+    let t1 = (-b - discr) / (2.0 * a);
+    let t2 = (-b + discr) / (2.0 * a);
+    if in_range(t1) {
+        cb(t1);
+    }
+    if in_range(t2) {
+        cb(t2);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quadratic_bounding_box() {
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2 { x: 110.0, y: 170.0 },
+                Pos2 { x: 10.0, y: 10.0 },
+                Pos2 { x: 180.0, y: 30.0 },
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+        let bbox = curve.bounding_rect();
+        assert!((bbox.min.x - 72.96).abs() < 0.01);
+        assert!((bbox.min.y - 27.78).abs() < 0.01);
+
+        assert!((bbox.max.x - 180.0).abs() < 0.01);
+        assert!((bbox.max.y - 170.0).abs() < 0.01);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 26);
+
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2 { x: 110.0, y: 170.0 },
+                Pos2 { x: 180.0, y: 30.0 },
+                Pos2 { x: 10.0, y: 10.0 },
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+        let bbox = curve.bounding_rect();
+        assert!((bbox.min.x - 10.0).abs() < 0.01);
+        assert!((bbox.min.y - 10.0).abs() < 0.01);
+
+        assert!((bbox.max.x - 130.42).abs() < 0.01);
+        assert!((bbox.max.y - 170.0).abs() < 0.01);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 25);
+    }
+
+    #[test]
+    fn test_quadratic_dfferent_tolerance() {
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2 { x: 110.0, y: 170.0 },
+                Pos2 { x: 180.0, y: 30.0 },
+                Pos2 { x: 10.0, y: 10.0 },
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(1.0, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 9);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 25);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 77);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.001, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 240);
+    }
+    #[test]
+    fn test_cubic_bounding_box() {
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(10.0, 10.0),
+                Pos2::new(110.0, 170.0),
+                Pos2::new(180.0, 30.0),
+                Pos2::new(270.0, 210.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let bbox = curve.bounding_rect();
+        assert_eq!(bbox.min.x, 10.0);
+        assert_eq!(bbox.min.y, 10.0);
+        assert_eq!(bbox.max.x, 270.0);
+        assert_eq!(bbox.max.y, 210.0);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(10.0, 10.0),
+                Pos2::new(110.0, 170.0),
+                Pos2::new(270.0, 210.0),
+                Pos2::new(180.0, 30.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let bbox = curve.bounding_rect();
+        assert_eq!(bbox.min.x, 10.0);
+        assert_eq!(bbox.min.y, 10.0);
+        assert!((bbox.max.x - 206.50).abs() < 0.01);
+        assert!((bbox.max.y - 148.48).abs() < 0.01);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(110.0, 170.0),
+                Pos2::new(10.0, 10.0),
+                Pos2::new(270.0, 210.0),
+                Pos2::new(180.0, 30.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let bbox = curve.bounding_rect();
+        assert!((bbox.min.x - 86.71).abs() < 0.01);
+        assert!((bbox.min.y - 30.0).abs() < 0.01);
+
+        assert!((bbox.max.x - 199.27).abs() < 0.01);
+        assert!((bbox.max.y - 170.0).abs() < 0.01);
+    }
+    #[test]
+    fn test_cubic_different_tolerance_flattening() {
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(0.0, 0.0),
+                Pos2::new(100.0, 0.0),
+                Pos2::new(100.0, 100.0),
+                Pos2::new(100.0, 200.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(1.0, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 10);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.5, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 13);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 28);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 83);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.001, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 248);
+    }
+
+    #[test]
+    fn test_cubic_different_shape_flattening() {
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(90.0, 110.0),
+                Pos2::new(30.0, 170.0),
+                Pos2::new(210.0, 170.0),
+                Pos2::new(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 117);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(90.0, 110.0),
+                Pos2::new(90.0, 170.0),
+                Pos2::new(170.0, 170.0),
+                Pos2::new(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 91);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(90.0, 110.0),
+                Pos2::new(110.0, 170.0),
+                Pos2::new(150.0, 170.0),
+                Pos2::new(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 75);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(90.0, 110.0),
+                Pos2::new(110.0, 170.0),
+                Pos2::new(230.0, 110.0),
+                Pos2::new(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 100);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(90.0, 110.0),
+                Pos2::new(110.0, 170.0),
+                Pos2::new(210.0, 70.0),
+                Pos2::new(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 71);
+
+        let curve = CubicBezierShape {
+            points: [
+                Pos2::new(90.0, 110.0),
+                Pos2::new(110.0, 170.0),
+                Pos2::new(150.0, 50.0),
+                Pos2::new(170.0, 110.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 88);
+    }
+
+    #[test]
+    fn test_quadrtic_flattening() {
+        let curve = QuadraticBezierShape {
+            points: [
+                Pos2::new(0.0, 0.0),
+                Pos2::new(80.0, 200.0),
+                Pos2::new(100.0, 30.0),
+            ],
+            closed: false,
+            fill: Default::default(),
+            stroke: Default::default(),
+        };
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(1.0, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 9);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.5, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 11);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.1, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 24);
+
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.01, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 72);
+        let mut result = vec![curve.points[0]]; //add the start point
+        curve.for_each_flattened_with_t(0.001, &mut |pos, _t| {
+            result.push(pos);
+        });
+
+        assert_eq!(result.len(), 223);
+    }
+}
diff --git a/epaint/src/color.rs b/epaint/src/color.rs
index 3f53ba23..2c506cb9 100644
--- a/epaint/src/color.rs
+++ b/epaint/src/color.rs
@@ -485,9 +485,9 @@ pub fn gamma_u8_from_linear_f32(l: f32) -> u8 {
     if l <= 0.0 {
         0
     } else if l <= 0.0031308 {
-        (3294.6 * l).round() as u8
+        fast_round(3294.6 * l)
     } else if l <= 1.0 {
-        (269.025 * l.powf(1.0 / 2.4) - 14.025).round() as u8
+        fast_round(269.025 * l.powf(1.0 / 2.4) - 14.025)
     } else {
         255
     }
@@ -497,7 +497,11 @@ pub fn gamma_u8_from_linear_f32(l: f32) -> u8 {
 /// Useful for alpha-channel.
 #[inline(always)]
 pub fn linear_u8_from_linear_f32(a: f32) -> u8 {
-    (a * 255.0).round() as u8 // rust does a saturating cast since 1.45
+    fast_round(a * 255.0)
+}
+
+fn fast_round(r: f32) -> u8 {
+    (r + 0.5).floor() as _ // rust does a saturating cast since 1.45
 }
 
 #[test]
diff --git a/epaint/src/image.rs b/epaint/src/image.rs
new file mode 100644
index 00000000..c261d924
--- /dev/null
+++ b/epaint/src/image.rs
@@ -0,0 +1,298 @@
+use crate::Color32;
+
+/// An image stored in RAM.
+///
+/// To load an image file, see [`ColorImage::from_rgba_unmultiplied`].
+///
+/// In order to paint the image on screen, you first need to convert it to
+///
+/// See also: [`ColorImage`], [`AlphaImage`].
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum ImageData {
+    /// RGBA image.
+    Color(ColorImage),
+    /// Used for the font texture.
+    Alpha(AlphaImage),
+}
+
+impl ImageData {
+    pub fn size(&self) -> [usize; 2] {
+        match self {
+            Self::Color(image) => image.size,
+            Self::Alpha(image) => image.size,
+        }
+    }
+
+    pub fn width(&self) -> usize {
+        self.size()[0]
+    }
+
+    pub fn height(&self) -> usize {
+        self.size()[1]
+    }
+
+    pub fn bytes_per_pixel(&self) -> usize {
+        match self {
+            Self::Color(_) => 4,
+            Self::Alpha(_) => 1,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A 2D RGBA color image in RAM.
+#[derive(Clone, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ColorImage {
+    /// width, height.
+    pub size: [usize; 2],
+    /// The pixels, row by row, from top to bottom.
+    pub pixels: Vec<Color32>,
+}
+
+impl ColorImage {
+    /// Create an image filled with the given color.
+    pub fn new(size: [usize; 2], color: Color32) -> Self {
+        Self {
+            size,
+            pixels: vec![color; size[0] * size[1]],
+        }
+    }
+
+    /// Create an `Image` from flat un-multiplied RGBA data.
+    ///
+    /// This is usually what you want to use after having loaded an image file.
+    ///
+    /// Panics if `size[0] * size[1] * 4 != rgba.len()`.
+    ///
+    /// ## Example using the [`image`](crates.io/crates/image) crate:
+    /// ``` ignore
+    /// fn load_image_from_path(path: &std::path::Path) -> Result<egui::ColorImage, image::ImageError> {
+    ///     let image = image::io::Reader::open(path)?.decode()?;
+    ///     let size = [image.width() as _, image.height() as _];
+    ///     let image_buffer = image.to_rgba8();
+    ///     let pixels = image_buffer.as_flat_samples();
+    ///     Ok(egui::ColorImage::from_rgba_unmultiplied(
+    ///         size,
+    ///         pixels.as_slice(),
+    ///     ))
+    /// }
+    ///
+    /// fn load_image_from_memory(image_data: &[u8]) -> Result<ColorImage, image::ImageError> {
+    ///     let image = image::load_from_memory(image_data)?;
+    ///     let size = [image.width() as _, image.height() as _];
+    ///     let image_buffer = image.to_rgba8();
+    ///     let pixels = image_buffer.as_flat_samples();
+    ///     Ok(ColorImage::from_rgba_unmultiplied(
+    ///         size,
+    ///         pixels.as_slice(),
+    ///     ))
+    /// }
+    /// ```
+    pub fn from_rgba_unmultiplied(size: [usize; 2], rgba: &[u8]) -> Self {
+        assert_eq!(size[0] * size[1] * 4, rgba.len());
+        let pixels = rgba
+            .chunks_exact(4)
+            .map(|p| Color32::from_rgba_unmultiplied(p[0], p[1], p[2], p[3]))
+            .collect();
+        Self { size, pixels }
+    }
+
+    /// An example color image, useful for tests.
+    pub fn example() -> Self {
+        let width = 128;
+        let height = 64;
+        let mut img = Self::new([width, height], Color32::TRANSPARENT);
+        for y in 0..height {
+            for x in 0..width {
+                let h = x as f32 / width as f32;
+                let s = 1.0;
+                let v = 1.0;
+                let a = y as f32 / height as f32;
+                img[(x, y)] = crate::color::Hsva { h, s, v, a }.into();
+            }
+        }
+        img
+    }
+
+    #[inline]
+    pub fn width(&self) -> usize {
+        self.size[0]
+    }
+
+    #[inline]
+    pub fn height(&self) -> usize {
+        self.size[1]
+    }
+}
+
+impl std::ops::Index<(usize, usize)> for ColorImage {
+    type Output = Color32;
+
+    #[inline]
+    fn index(&self, (x, y): (usize, usize)) -> &Color32 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &self.pixels[y * w + x]
+    }
+}
+
+impl std::ops::IndexMut<(usize, usize)> for ColorImage {
+    #[inline]
+    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Color32 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &mut self.pixels[y * w + x]
+    }
+}
+
+impl From<ColorImage> for ImageData {
+    #[inline(always)]
+    fn from(image: ColorImage) -> Self {
+        Self::Color(image)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// An 8-bit image, representing difference levels of transparent white.
+///
+/// Used for the font texture
+#[derive(Clone, Default, Eq, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct AlphaImage {
+    /// width, height
+    pub size: [usize; 2],
+    /// The alpha (linear space 0-255) of something white.
+    ///
+    /// One byte per pixel. Often you want to use [`Self::srgba_pixels`] instead.
+    pub pixels: Vec<u8>,
+}
+
+impl AlphaImage {
+    pub fn new(size: [usize; 2]) -> Self {
+        Self {
+            size,
+            pixels: vec![0; size[0] * size[1]],
+        }
+    }
+
+    #[inline]
+    pub fn width(&self) -> usize {
+        self.size[0]
+    }
+
+    #[inline]
+    pub fn height(&self) -> usize {
+        self.size[1]
+    }
+
+    /// Returns the textures as `sRGBA` premultiplied pixels, row by row, top to bottom.
+    ///
+    /// `gamma` should normally be set to 1.0.
+    /// If you are having problems with text looking skinny and pixelated, try
+    /// setting a lower gamma, e.g. `0.5`.
+    pub fn srgba_pixels(
+        &'_ self,
+        gamma: f32,
+    ) -> impl ExactSizeIterator<Item = super::Color32> + '_ {
+        let srgba_from_alpha_lut: Vec<Color32> = (0..=255)
+            .map(|a| {
+                let a = super::color::linear_f32_from_linear_u8(a).powf(gamma);
+                super::Rgba::from_white_alpha(a).into()
+            })
+            .collect();
+
+        self.pixels
+            .iter()
+            .map(move |&a| srgba_from_alpha_lut[a as usize])
+    }
+
+    /// Clone a sub-region as a new image
+    pub fn region(&self, [x, y]: [usize; 2], [w, h]: [usize; 2]) -> AlphaImage {
+        assert!(x + w <= self.width());
+        assert!(y + h <= self.height());
+
+        let mut pixels = Vec::with_capacity(w * h);
+        for y in y..y + h {
+            let offset = y * self.width() + x;
+            pixels.extend(&self.pixels[offset..(offset + w)]);
+        }
+        assert_eq!(pixels.len(), w * h);
+        AlphaImage {
+            size: [w, h],
+            pixels,
+        }
+    }
+}
+
+impl std::ops::Index<(usize, usize)> for AlphaImage {
+    type Output = u8;
+
+    #[inline]
+    fn index(&self, (x, y): (usize, usize)) -> &u8 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &self.pixels[y * w + x]
+    }
+}
+
+impl std::ops::IndexMut<(usize, usize)> for AlphaImage {
+    #[inline]
+    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut u8 {
+        let [w, h] = self.size;
+        assert!(x < w && y < h);
+        &mut self.pixels[y * w + x]
+    }
+}
+
+impl From<AlphaImage> for ImageData {
+    #[inline(always)]
+    fn from(image: AlphaImage) -> Self {
+        Self::Alpha(image)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// A change to an image.
+///
+/// Either a whole new image,
+/// or an update to a rectangular region of it.
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[must_use = "The painter must take care of this"]
+pub struct ImageDelta {
+    /// What to set the texture to.
+    pub image: ImageData,
+
+    /// If `None`, set the whole texture to [`Self::image`].
+    /// If `Some(pos)`, update a sub-region of an already allocated texture.
+    pub pos: Option<[usize; 2]>,
+}
+
+impl ImageDelta {
+    /// Update the whole texture.
+    pub fn full(image: impl Into<ImageData>) -> Self {
+        Self {
+            image: image.into(),
+            pos: None,
+        }
+    }
+
+    /// Update a sub-region of an existing texture.
+    pub fn partial(pos: [usize; 2], image: impl Into<ImageData>) -> Self {
+        Self {
+            image: image.into(),
+            pos: Some(pos),
+        }
+    }
+
+    /// Is this affecting the whole texture?
+    /// If `false`, this is a partial (sub-region) update.
+    pub fn is_whole(&self) -> bool {
+        self.pos.is_none()
+    }
+}
diff --git a/epaint/src/lib.rs b/epaint/src/lib.rs
index 3799cd4e..55e6b7b7 100644
--- a/epaint/src/lib.rs
+++ b/epaint/src/lib.rs
@@ -87,7 +87,9 @@
 #![allow(clippy::float_cmp)]
 #![allow(clippy::manual_range_contains)]
 
+mod bezier;
 pub mod color;
+pub mod image;
 mod mesh;
 pub mod mutex;
 mod shadow;
@@ -98,18 +100,24 @@ mod stroke;
 pub mod tessellator;
 pub mod text;
 mod texture_atlas;
+mod texture_handle;
+pub mod textures;
 pub mod util;
 
 pub use {
+    bezier::{CubicBezierShape, QuadraticBezierShape},
     color::{Color32, Rgba},
+    image::{AlphaImage, ColorImage, ImageData, ImageDelta},
     mesh::{Mesh, Mesh16, Vertex},
     shadow::Shadow,
-    shape::{CircleShape, PathShape, RectShape, Shape, TextShape},
+    shape::{CircleShape, PathShape, RectShape, Rounding, Shape, TextShape},
     stats::PaintStats,
     stroke::Stroke,
     tessellator::{tessellate_shapes, TessellationOptions, Tessellator},
-    text::{Fonts, Galley, TextStyle},
-    texture_atlas::{FontImage, TextureAtlas},
+    text::{FontFamily, FontId, Fonts, Galley},
+    texture_atlas::TextureAtlas,
+    texture_handle::TextureHandle,
+    textures::TextureManager,
 };
 
 pub use emath::{pos2, vec2, Pos2, Rect, Vec2};
@@ -124,21 +132,25 @@ pub use emath;
 pub const WHITE_UV: emath::Pos2 = emath::pos2(0.0, 0.0);
 
 /// What texture to use in a [`Mesh`] mesh.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+///
+/// If you don't want to use a texture, use `TextureId::Epaint(0)` and the [`WHITE_UV`] for uv-coord.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum TextureId {
-    /// The egui font texture.
-    /// If you don't want to use a texture, pick this and the [`WHITE_UV`] for uv-coord.
-    Egui,
+    /// Textures allocated using [`TextureManager`].
+    ///
+    /// The first texture (`TextureId::Epaint(0)`) is used for the font data.
+    Managed(u64),
 
     /// Your own texture, defined in any which way you want.
-    /// egui won't care. The backend renderer will presumably use this to look up what texture to use.
+    /// The backend renderer will presumably use this to look up what texture to use.
     User(u64),
 }
 
 impl Default for TextureId {
+    /// The epaint font texture.
     fn default() -> Self {
-        Self::Egui
+        Self::Managed(0)
     }
 }
 
diff --git a/epaint/src/mesh.rs b/epaint/src/mesh.rs
index 78f1a9fb..800e6120 100644
--- a/epaint/src/mesh.rs
+++ b/epaint/src/mesh.rs
@@ -105,7 +105,7 @@ impl Mesh {
 
     #[inline(always)]
     pub fn colored_vertex(&mut self, pos: Pos2, color: Color32) {
-        crate::epaint_assert!(self.texture_id == TextureId::Egui);
+        crate::epaint_assert!(self.texture_id == TextureId::default());
         self.vertices.push(Vertex {
             pos,
             uv: WHITE_UV,
@@ -168,7 +168,7 @@ impl Mesh {
     /// Uniformly colored rectangle.
     #[inline(always)]
     pub fn add_colored_rect(&mut self, rect: Rect, color: Color32) {
-        crate::epaint_assert!(self.texture_id == TextureId::Egui);
+        crate::epaint_assert!(self.texture_id == TextureId::default());
         self.add_rect_with_uv(rect, [WHITE_UV, WHITE_UV].into(), color);
     }
 
diff --git a/epaint/src/mutex.rs b/epaint/src/mutex.rs
index bd2cef4a..fa0e939e 100644
--- a/epaint/src/mutex.rs
+++ b/epaint/src/mutex.rs
@@ -114,10 +114,10 @@ mod mutex_impl {
 #[cfg(feature = "multi_threaded")]
 mod rw_lock_impl {
     /// The lock you get from [`RwLock::read`].
-    pub use parking_lot::RwLockReadGuard;
+    pub use parking_lot::MappedRwLockReadGuard as RwLockReadGuard;
 
     /// The lock you get from [`RwLock::write`].
-    pub use parking_lot::RwLockWriteGuard;
+    pub use parking_lot::MappedRwLockWriteGuard as RwLockWriteGuard;
 
     /// Provides interior mutability. Only thread-safe if the `multi_threaded` feature is enabled.
     #[derive(Default)]
@@ -131,16 +131,21 @@ mod rw_lock_impl {
 
         #[inline(always)]
         pub fn read(&self) -> RwLockReadGuard<'_, T> {
-            self.0.read()
+            parking_lot::RwLockReadGuard::map(self.0.read(), |v| v)
         }
 
         #[inline(always)]
         pub fn write(&self) -> RwLockWriteGuard<'_, T> {
-            self.0.write()
+            parking_lot::RwLockWriteGuard::map(self.0.write(), |v| v)
         }
     }
 }
 
+#[cfg(feature = "multi_threaded")]
+mod arc_impl {
+    pub use std::sync::Arc;
+}
+
 // ----------------------------------------------------------------------------
 
 #[cfg(not(feature = "multi_threaded"))]
@@ -201,8 +206,15 @@ mod rw_lock_impl {
     }
 }
 
+#[cfg(not(feature = "multi_threaded"))]
+mod arc_impl {
+    // pub use std::rc::Rc as Arc; // TODO(emilk): optimize single threaded code by using `Rc` instead of `Arc`.
+    pub use std::sync::Arc;
+}
+
 // ----------------------------------------------------------------------------
 
+pub use arc_impl::Arc;
 pub use mutex_impl::{Mutex, MutexGuard};
 pub use rw_lock_impl::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
diff --git a/epaint/src/shadow.rs b/epaint/src/shadow.rs
index 65cbb257..d8895fee 100644
--- a/epaint/src/shadow.rs
+++ b/epaint/src/shadow.rs
@@ -46,17 +46,23 @@ impl Shadow {
         }
     }
 
-    pub fn tessellate(&self, rect: emath::Rect, corner_radius: f32) -> Mesh {
+    pub fn tessellate(&self, rect: emath::Rect, rounding: impl Into<Rounding>) -> Mesh {
         // tessellator.clip_rect = clip_rect; // TODO: culling
 
         let Self { extrusion, color } = *self;
 
+        let rounding: Rounding = rounding.into();
+        let half_ext = 0.5 * extrusion;
+
+        let ext_rounding = Rounding {
+            nw: rounding.nw + half_ext,
+            ne: rounding.ne + half_ext,
+            sw: rounding.sw + half_ext,
+            se: rounding.se + half_ext,
+        };
+
         use crate::tessellator::*;
-        let rect = RectShape::filled(
-            rect.expand(0.5 * extrusion),
-            corner_radius + 0.5 * extrusion,
-            color,
-        );
+        let rect = RectShape::filled(rect.expand(half_ext), ext_rounding, color);
         let mut tessellator = Tessellator::from_options(TessellationOptions {
             aa_size: extrusion,
             anti_alias: true,
diff --git a/epaint/src/shape.rs b/epaint/src/shape.rs
index fa52260e..7ac5e828 100644
--- a/epaint/src/shape.rs
+++ b/epaint/src/shape.rs
@@ -1,7 +1,8 @@
 use crate::{
-    text::{Fonts, Galley, TextStyle},
+    text::{FontId, Fonts, Galley},
     Color32, Mesh, Stroke,
 };
+use crate::{CubicBezierShape, QuadraticBezierShape};
 use emath::*;
 
 /// A paint primitive such as a circle or a piece of text.
@@ -15,14 +16,19 @@ pub enum Shape {
     /// For performance reasons it is better to avoid it.
     Vec(Vec<Shape>),
     Circle(CircleShape),
+    /// A line between two points.
     LineSegment {
         points: [Pos2; 2],
         stroke: Stroke,
     },
+    /// A series of lines between points.
+    /// The path can have a stroke and/or fill (if closed).
     Path(PathShape),
     Rect(RectShape),
     Text(TextShape),
     Mesh(Mesh),
+    QuadraticBezier(QuadraticBezierShape),
+    CubicBezier(CubicBezierShape),
 }
 
 /// ## Constructors
@@ -108,13 +114,21 @@ impl Shape {
     }
 
     #[inline]
-    pub fn rect_filled(rect: Rect, corner_radius: f32, fill_color: impl Into<Color32>) -> Self {
-        Self::Rect(RectShape::filled(rect, corner_radius, fill_color))
+    pub fn rect_filled(
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+    ) -> Self {
+        Self::Rect(RectShape::filled(rect, rounding, fill_color))
     }
 
     #[inline]
-    pub fn rect_stroke(rect: Rect, corner_radius: f32, stroke: impl Into<Stroke>) -> Self {
-        Self::Rect(RectShape::stroke(rect, corner_radius, stroke))
+    pub fn rect_stroke(
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        stroke: impl Into<Stroke>,
+    ) -> Self {
+        Self::Rect(RectShape::stroke(rect, rounding, stroke))
     }
 
     #[allow(clippy::needless_pass_by_value)]
@@ -123,16 +137,16 @@ impl Shape {
         pos: Pos2,
         anchor: Align2,
         text: impl ToString,
-        text_style: TextStyle,
+        font_id: FontId,
         color: Color32,
     ) -> Self {
-        let galley = fonts.layout_no_wrap(text.to_string(), text_style, color);
+        let galley = fonts.layout_no_wrap(text.to_string(), font_id, color);
         let rect = anchor.anchor_rect(Rect::from_min_size(pos, galley.size()));
         Self::galley(rect.min, galley)
     }
 
     #[inline]
-    pub fn galley(pos: Pos2, galley: std::sync::Arc<Galley>) -> Self {
+    pub fn galley(pos: Pos2, galley: crate::mutex::Arc<Galley>) -> Self {
         TextShape::new(pos, galley).into()
     }
 
@@ -149,7 +163,7 @@ impl Shape {
         if let Shape::Mesh(mesh) = self {
             mesh.texture_id
         } else {
-            super::TextureId::Egui
+            super::TextureId::default()
         }
     }
 
@@ -184,6 +198,16 @@ impl Shape {
             Shape::Mesh(mesh) => {
                 mesh.translate(delta);
             }
+            Shape::QuadraticBezier(bezier_shape) => {
+                bezier_shape.points[0] += delta;
+                bezier_shape.points[1] += delta;
+                bezier_shape.points[2] += delta;
+            }
+            Shape::CubicBezier(cubie_curve) => {
+                for p in &mut cubie_curve.points {
+                    *p += delta;
+                }
+            }
         }
     }
 }
@@ -305,28 +329,32 @@ impl From<PathShape> for Shape {
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct RectShape {
     pub rect: Rect,
-    /// How rounded the corners are. Use `0.0` for no rounding.
-    pub corner_radius: f32,
+    /// How rounded the corners are. Use `Rounding::none()` for no rounding.
+    pub rounding: Rounding,
     pub fill: Color32,
     pub stroke: Stroke,
 }
 
 impl RectShape {
     #[inline]
-    pub fn filled(rect: Rect, corner_radius: f32, fill_color: impl Into<Color32>) -> Self {
+    pub fn filled(
+        rect: Rect,
+        rounding: impl Into<Rounding>,
+        fill_color: impl Into<Color32>,
+    ) -> Self {
         Self {
             rect,
-            corner_radius,
+            rounding: rounding.into(),
             fill: fill_color.into(),
             stroke: Default::default(),
         }
     }
 
     #[inline]
-    pub fn stroke(rect: Rect, corner_radius: f32, stroke: impl Into<Stroke>) -> Self {
+    pub fn stroke(rect: Rect, rounding: impl Into<Rounding>, stroke: impl Into<Stroke>) -> Self {
         Self {
             rect,
-            corner_radius,
+            rounding: rounding.into(),
             fill: Default::default(),
             stroke: stroke.into(),
         }
@@ -346,6 +374,67 @@ impl From<RectShape> for Shape {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+/// How rounded the corners of things should be
+pub struct Rounding {
+    /// Radius of the rounding of the North-West (left top) corner.
+    pub nw: f32,
+    /// Radius of the rounding of the North-East (right top) corner.
+    pub ne: f32,
+    /// Radius of the rounding of the South-West (left bottom) corner.
+    pub sw: f32,
+    /// Radius of the rounding of the South-East (right bottom) corner.
+    pub se: f32,
+}
+
+impl Default for Rounding {
+    #[inline]
+    fn default() -> Self {
+        Self::none()
+    }
+}
+
+impl From<f32> for Rounding {
+    #[inline]
+    fn from(radius: f32) -> Self {
+        Self {
+            nw: radius,
+            ne: radius,
+            sw: radius,
+            se: radius,
+        }
+    }
+}
+
+impl Rounding {
+    #[inline]
+    pub fn same(radius: f32) -> Self {
+        Self {
+            nw: radius,
+            ne: radius,
+            sw: radius,
+            se: radius,
+        }
+    }
+
+    #[inline]
+    pub fn none() -> Self {
+        Self {
+            nw: 0.0,
+            ne: 0.0,
+            sw: 0.0,
+            se: 0.0,
+        }
+    }
+
+    /// Do all corners have the same rounding?
+    #[inline]
+    pub fn is_same(&self) -> bool {
+        self.nw == self.ne && self.nw == self.sw && self.nw == self.se
+    }
+}
+
 // ----------------------------------------------------------------------------
 
 /// How to paint some text on screen.
@@ -355,7 +444,7 @@ pub struct TextShape {
     pub pos: Pos2,
 
     /// The layed out text, from [`Fonts::layout_job`].
-    pub galley: std::sync::Arc<Galley>,
+    pub galley: crate::mutex::Arc<Galley>,
 
     /// Add this underline to the whole text.
     /// You can also set an underline when creating the galley.
@@ -373,7 +462,7 @@ pub struct TextShape {
 
 impl TextShape {
     #[inline]
-    pub fn new(pos: Pos2, galley: std::sync::Arc<Galley>) -> Self {
+    pub fn new(pos: Pos2, galley: crate::mutex::Arc<Galley>) -> Self {
         Self {
             pos,
             galley,
diff --git a/epaint/src/shape_transform.rs b/epaint/src/shape_transform.rs
index b3ffc19d..c033a8ee 100644
--- a/epaint/src/shape_transform.rs
+++ b/epaint/src/shape_transform.rs
@@ -43,5 +43,13 @@ pub fn adjust_colors(shape: &mut Shape, adjust_color: &impl Fn(&mut Color32)) {
                 adjust_color(&mut v.color);
             }
         }
+        Shape::QuadraticBezier(quatratic) => {
+            adjust_color(&mut quatratic.fill);
+            adjust_color(&mut quatratic.stroke.color);
+        }
+        Shape::CubicBezier(bezier) => {
+            adjust_color(&mut bezier.fill);
+            adjust_color(&mut bezier.stroke.color);
+        }
     }
 }
diff --git a/epaint/src/stats.rs b/epaint/src/stats.rs
index ad7a0c88..322c0ddf 100644
--- a/epaint/src/stats.rs
+++ b/epaint/src/stats.rs
@@ -195,8 +195,12 @@ impl PaintStats {
                     self.add(shape);
                 }
             }
-            Shape::Noop | Shape::Circle { .. } | Shape::LineSegment { .. } | Shape::Rect { .. } => {
-            }
+            Shape::Noop
+            | Shape::Circle { .. }
+            | Shape::LineSegment { .. }
+            | Shape::Rect { .. }
+            | Shape::CubicBezier(_)
+            | Shape::QuadraticBezier(_) => {}
             Shape::Path(path_shape) => {
                 self.shape_path += AllocInfo::from_slice(&path_shape.points);
             }
diff --git a/epaint/src/tessellator.rs b/epaint/src/tessellator.rs
index c2301a88..2db85348 100644
--- a/epaint/src/tessellator.rs
+++ b/epaint/src/tessellator.rs
@@ -179,20 +179,20 @@ impl Path {
 
 pub mod path {
     //! Helpers for constructing paths
+    use crate::shape::Rounding;
+
     use super::*;
 
     /// overwrites existing points
-    pub fn rounded_rectangle(path: &mut Vec<Pos2>, rect: Rect, corner_radius: f32) {
+    pub fn rounded_rectangle(path: &mut Vec<Pos2>, rect: Rect, rounding: Rounding) {
         path.clear();
 
         let min = rect.min;
         let max = rect.max;
 
-        let cr = corner_radius
-            .min(rect.width() * 0.5)
-            .min(rect.height() * 0.5);
+        let r = clamp_radius(rounding, rect);
 
-        if cr <= 0.0 {
+        if r == Rounding::none() {
             let min = rect.min;
             let max = rect.max;
             path.reserve(4);
@@ -201,10 +201,10 @@ pub mod path {
             path.push(pos2(max.x, max.y));
             path.push(pos2(min.x, max.y));
         } else {
-            add_circle_quadrant(path, pos2(max.x - cr, max.y - cr), cr, 0.0);
-            add_circle_quadrant(path, pos2(min.x + cr, max.y - cr), cr, 1.0);
-            add_circle_quadrant(path, pos2(min.x + cr, min.y + cr), cr, 2.0);
-            add_circle_quadrant(path, pos2(max.x - cr, min.y + cr), cr, 3.0);
+            add_circle_quadrant(path, pos2(max.x - r.se, max.y - r.se), r.se, 0.0);
+            add_circle_quadrant(path, pos2(min.x + r.sw, max.y - r.sw), r.sw, 1.0);
+            add_circle_quadrant(path, pos2(min.x + r.nw, min.y + r.nw), r.nw, 2.0);
+            add_circle_quadrant(path, pos2(max.x - r.ne, min.y + r.ne), r.ne, 3.0);
         }
     }
 
@@ -242,6 +242,20 @@ pub mod path {
             path.push(center + radius * Vec2::angled(angle));
         }
     }
+
+    // Ensures the radius of each corner is within a valid range
+    fn clamp_radius(rounding: Rounding, rect: Rect) -> Rounding {
+        let half_width = rect.width() * 0.5;
+        let half_height = rect.height() * 0.5;
+        let max_cr = half_width.min(half_height);
+
+        Rounding {
+            nw: rounding.nw.at_most(max_cr).at_least(0.0),
+            ne: rounding.ne.at_most(max_cr).at_least(0.0),
+            sw: rounding.sw.at_most(max_cr).at_least(0.0),
+            se: rounding.se.at_most(max_cr).at_least(0.0),
+        }
+    }
 }
 
 // ----------------------------------------------------------------------------
@@ -286,6 +300,12 @@ pub struct TessellationOptions {
 
     /// If true, no clipping will be done.
     pub debug_ignore_clip_rects: bool,
+
+    /// The maximum distance between the original curve and the flattened curve.
+    pub bezier_tolerance: f32,
+
+    /// The default value will be 1.0e-5, it will be used during float compare.
+    pub epsilon: f32,
 }
 
 impl Default for TessellationOptions {
@@ -299,6 +319,8 @@ impl Default for TessellationOptions {
             debug_paint_text_rects: false,
             debug_paint_clip_rects: false,
             debug_ignore_clip_rects: false,
+            bezier_tolerance: 0.1,
+            epsilon: 1.0e-5,
         }
     }
 }
@@ -710,9 +732,93 @@ impl Tessellator {
                 }
                 self.tessellate_text(tex_size, text_shape, out);
             }
+            Shape::QuadraticBezier(quadratic_shape) => {
+                self.tessellate_quadratic_bezier(quadratic_shape, out);
+            }
+            Shape::CubicBezier(cubic_shape) => self.tessellate_cubic_bezier(cubic_shape, out),
         }
     }
 
+    pub(crate) fn tessellate_quadratic_bezier(
+        &mut self,
+        quadratic_shape: QuadraticBezierShape,
+        out: &mut Mesh,
+    ) {
+        let options = &self.options;
+        let clip_rect = self.clip_rect;
+
+        if options.coarse_tessellation_culling
+            && !quadratic_shape.bounding_rect().intersects(clip_rect)
+        {
+            return;
+        }
+
+        let points = quadratic_shape.flatten(Some(options.bezier_tolerance));
+
+        self.tessellate_bezier_complete(
+            &points,
+            quadratic_shape.fill,
+            quadratic_shape.closed,
+            quadratic_shape.stroke,
+            out,
+        );
+    }
+
+    pub(crate) fn tessellate_cubic_bezier(
+        &mut self,
+        cubic_shape: CubicBezierShape,
+        out: &mut Mesh,
+    ) {
+        let options = &self.options;
+        let clip_rect = self.clip_rect;
+        if options.coarse_tessellation_culling && !cubic_shape.bounding_rect().intersects(clip_rect)
+        {
+            return;
+        }
+
+        let points_vec =
+            cubic_shape.flatten_closed(Some(options.bezier_tolerance), Some(options.epsilon));
+
+        for points in points_vec {
+            self.tessellate_bezier_complete(
+                &points,
+                cubic_shape.fill,
+                cubic_shape.closed,
+                cubic_shape.stroke,
+                out,
+            );
+        }
+    }
+
+    fn tessellate_bezier_complete(
+        &mut self,
+        points: &[Pos2],
+        fill: Color32,
+        closed: bool,
+        stroke: Stroke,
+        out: &mut Mesh,
+    ) {
+        self.scratchpad_path.clear();
+        if closed {
+            self.scratchpad_path.add_line_loop(points);
+        } else {
+            self.scratchpad_path.add_open_points(points);
+        }
+        if fill != Color32::TRANSPARENT {
+            crate::epaint_assert!(
+                closed,
+                "You asked to fill a path that is not closed. That makes no sense."
+            );
+            self.scratchpad_path.fill(fill, &self.options, out);
+        }
+        let typ = if closed {
+            PathType::Closed
+        } else {
+            PathType::Open
+        };
+        self.scratchpad_path.stroke(typ, stroke, &self.options, out);
+    }
+
     pub(crate) fn tessellate_path(&mut self, path_shape: PathShape, out: &mut Mesh) {
         if path_shape.points.len() < 2 {
             return;
@@ -756,7 +862,7 @@ impl Tessellator {
     pub(crate) fn tessellate_rect(&mut self, rect: &RectShape, out: &mut Mesh) {
         let RectShape {
             mut rect,
-            corner_radius,
+            rounding,
             fill,
             stroke,
         } = *rect;
@@ -777,7 +883,7 @@ impl Tessellator {
 
         let path = &mut self.scratchpad_path;
         path.clear();
-        path::rounded_rectangle(&mut self.scratchpad_points, rect, corner_radius);
+        path::rounded_rectangle(&mut self.scratchpad_points, rect, rounding);
         path.add_line_loop(&self.scratchpad_points);
         path.fill(fill, &self.options, out);
         path.stroke_closed(stroke, &self.options, out);
diff --git a/epaint/src/text/font.rs b/epaint/src/text/font.rs
index 966a4f4a..1dca6030 100644
--- a/epaint/src/text/font.rs
+++ b/epaint/src/text/font.rs
@@ -1,12 +1,10 @@
 use crate::{
-    mutex::{Mutex, RwLock},
-    text::TextStyle,
+    mutex::{Arc, Mutex, RwLock},
     TextureAtlas,
 };
 use ahash::AHashMap;
 use emath::{vec2, Vec2};
 use std::collections::BTreeSet;
-use std::sync::Arc;
 
 // ----------------------------------------------------------------------------
 
@@ -60,7 +58,7 @@ impl Default for GlyphInfo {
 pub struct FontImpl {
     ab_glyph_font: ab_glyph::FontArc,
     /// Maximum character height
-    scale_in_pixels: f32,
+    scale_in_pixels: u32,
     height_in_points: f32,
     // move each character by this much (hack)
     y_offset: f32,
@@ -74,20 +72,13 @@ impl FontImpl {
         atlas: Arc<Mutex<TextureAtlas>>,
         pixels_per_point: f32,
         ab_glyph_font: ab_glyph::FontArc,
-        scale_in_points: f32,
+        scale_in_pixels: u32,
         y_offset: f32,
     ) -> FontImpl {
-        assert!(scale_in_points > 0.0);
+        assert!(scale_in_pixels > 0);
         assert!(pixels_per_point > 0.0);
 
-        let scale_in_pixels = pixels_per_point * scale_in_points;
-
-        // Round to an even number of physical pixels to get even kerning.
-        // See https://github.com/emilk/egui/issues/382
-        let scale_in_pixels = scale_in_pixels.round();
-        let scale_in_points = scale_in_pixels / pixels_per_point;
-
-        let height_in_points = scale_in_points;
+        let height_in_points = scale_in_pixels as f32 / pixels_per_point;
 
         // TODO: use v_metrics for line spacing ?
         // let v = rusttype_font.v_metrics(Scale::uniform(scale_in_pixels));
@@ -163,7 +154,7 @@ impl FontImpl {
                 &mut self.atlas.lock(),
                 &self.ab_glyph_font,
                 glyph_id,
-                self.scale_in_pixels,
+                self.scale_in_pixels as f32,
                 self.y_offset,
                 self.pixels_per_point,
             );
@@ -181,7 +172,7 @@ impl FontImpl {
     ) -> f32 {
         use ab_glyph::{Font as _, ScaleFont};
         self.ab_glyph_font
-            .as_scaled(self.scale_in_pixels)
+            .as_scaled(self.scale_in_pixels as f32)
             .kern(last_glyph_id, glyph_id)
             / self.pixels_per_point
     }
@@ -203,23 +194,21 @@ type FontIndex = usize;
 // TODO: rename?
 /// Wrapper over multiple `FontImpl` (e.g. a primary + fallbacks for emojis)
 pub struct Font {
-    text_style: TextStyle,
     fonts: Vec<Arc<FontImpl>>,
     /// Lazily calculated.
-    characters: RwLock<Option<std::collections::BTreeSet<char>>>,
+    characters: Option<std::collections::BTreeSet<char>>,
     replacement_glyph: (FontIndex, GlyphInfo),
     pixels_per_point: f32,
     row_height: f32,
-    glyph_info_cache: RwLock<AHashMap<char, (FontIndex, GlyphInfo)>>,
+    glyph_info_cache: AHashMap<char, (FontIndex, GlyphInfo)>,
 }
 
 impl Font {
-    pub fn new(text_style: TextStyle, fonts: Vec<Arc<FontImpl>>) -> Self {
+    pub fn new(fonts: Vec<Arc<FontImpl>>) -> Self {
         if fonts.is_empty() {
             return Self {
-                text_style,
                 fonts,
-                characters: RwLock::new(None),
+                characters: None,
                 replacement_glyph: Default::default(),
                 pixels_per_point: 1.0,
                 row_height: 0.0,
@@ -231,9 +220,8 @@ impl Font {
         let row_height = fonts[0].row_height();
 
         let mut slf = Self {
-            text_style,
             fonts,
-            characters: RwLock::new(None),
+            characters: None,
             replacement_glyph: Default::default(),
             pixels_per_point,
             row_height,
@@ -254,33 +242,29 @@ impl Font {
             });
         slf.replacement_glyph = replacement_glyph;
 
+        slf
+    }
+
+    pub fn preload_common_characters(&mut self) {
         // Preload the printable ASCII characters [32, 126] (which excludes control codes):
         const FIRST_ASCII: usize = 32; // 32 == space
         const LAST_ASCII: usize = 126;
         for c in (FIRST_ASCII..=LAST_ASCII).map(|c| c as u8 as char) {
-            slf.glyph_info(c);
+            self.glyph_info(c);
         }
-        slf.glyph_info('°');
-        slf.glyph_info(crate::text::PASSWORD_REPLACEMENT_CHAR); // password replacement character
-
-        slf
+        self.glyph_info('°');
+        self.glyph_info(crate::text::PASSWORD_REPLACEMENT_CHAR);
     }
 
     /// All supported characters
-    pub fn characters(&self) -> BTreeSet<char> {
-        if self.characters.read().is_none() {
+    pub fn characters(&mut self) -> &BTreeSet<char> {
+        self.characters.get_or_insert_with(|| {
             let mut characters = BTreeSet::new();
             for font in &self.fonts {
                 characters.extend(font.characters());
             }
-            self.characters.write().replace(characters);
-        }
-        self.characters.read().clone().unwrap()
-    }
-
-    #[inline(always)]
-    pub fn text_style(&self) -> TextStyle {
-        self.text_style
+            characters
+        })
     }
 
     #[inline(always)]
@@ -296,35 +280,30 @@ impl Font {
 
     pub fn uv_rect(&self, c: char) -> UvRect {
         self.glyph_info_cache
-            .read()
             .get(&c)
             .map(|gi| gi.1.uv_rect)
             .unwrap_or_default()
     }
 
     /// Width of this character in points.
-    pub fn glyph_width(&self, c: char) -> f32 {
+    pub fn glyph_width(&mut self, c: char) -> f32 {
         self.glyph_info(c).1.advance_width
     }
 
     /// `\n` will (intentionally) show up as the replacement character.
-    fn glyph_info(&self, c: char) -> (FontIndex, GlyphInfo) {
-        {
-            if let Some(font_index_glyph_info) = self.glyph_info_cache.read().get(&c) {
-                return *font_index_glyph_info;
-            }
+    fn glyph_info(&mut self, c: char) -> (FontIndex, GlyphInfo) {
+        if let Some(font_index_glyph_info) = self.glyph_info_cache.get(&c) {
+            return *font_index_glyph_info;
         }
 
         let font_index_glyph_info = self.glyph_info_no_cache_or_fallback(c);
         let font_index_glyph_info = font_index_glyph_info.unwrap_or(self.replacement_glyph);
-        self.glyph_info_cache
-            .write()
-            .insert(c, font_index_glyph_info);
+        self.glyph_info_cache.insert(c, font_index_glyph_info);
         font_index_glyph_info
     }
 
     #[inline]
-    pub(crate) fn glyph_info_and_font_impl(&self, c: char) -> (Option<&FontImpl>, GlyphInfo) {
+    pub(crate) fn glyph_info_and_font_impl(&mut self, c: char) -> (Option<&FontImpl>, GlyphInfo) {
         if self.fonts.is_empty() {
             return (None, self.replacement_glyph.1);
         }
@@ -333,12 +312,10 @@ impl Font {
         (Some(font_impl), glyph_info)
     }
 
-    fn glyph_info_no_cache_or_fallback(&self, c: char) -> Option<(FontIndex, GlyphInfo)> {
+    fn glyph_info_no_cache_or_fallback(&mut self, c: char) -> Option<(FontIndex, GlyphInfo)> {
         for (font_index, font_impl) in self.fonts.iter().enumerate() {
             if let Some(glyph_info) = font_impl.glyph_info(c) {
-                self.glyph_info_cache
-                    .write()
-                    .insert(c, (font_index, glyph_info));
+                self.glyph_info_cache.insert(c, (font_index, glyph_info));
                 return Some((font_index, glyph_info));
             }
         }
@@ -375,18 +352,16 @@ fn allocate_glyph(
         if glyph_width == 0 || glyph_height == 0 {
             UvRect::default()
         } else {
-            let glyph_pos = atlas.allocate((glyph_width, glyph_height));
-
-            let texture = atlas.image_mut();
+            let (glyph_pos, image) = atlas.allocate((glyph_width, glyph_height));
             glyph.draw(|x, y, v| {
                 if v > 0.0 {
                     let px = glyph_pos.0 + x as usize;
                     let py = glyph_pos.1 + y as usize;
-                    texture[(px, py)] = (v * 255.0).round() as u8;
+                    image[(px, py)] = fast_round(v * 255.0);
                 }
             });
 
-            let offset_in_pixels = vec2(bb.min.x as f32, scale_in_pixels as f32 + bb.min.y as f32);
+            let offset_in_pixels = vec2(bb.min.x as f32, scale_in_pixels + bb.min.y as f32);
             let offset = offset_in_pixels / pixels_per_point + y_offset * Vec2::Y;
             UvRect {
                 offset,
@@ -410,3 +385,7 @@ fn allocate_glyph(
         uv_rect,
     }
 }
+
+fn fast_round(r: f32) -> u8 {
+    (r + 0.5).floor() as _ // rust does a saturating cast since 1.45
+}
diff --git a/epaint/src/text/fonts.rs b/epaint/src/text/fonts.rs
index 2ea3841f..bd6a9e2b 100644
--- a/epaint/src/text/fonts.rs
+++ b/epaint/src/text/fonts.rs
@@ -1,63 +1,122 @@
-use std::{collections::BTreeMap, sync::Arc};
+use std::collections::BTreeMap;
 
 use crate::{
-    mutex::Mutex,
+    mutex::{Arc, Mutex, MutexGuard},
     text::{
         font::{Font, FontImpl},
         Galley, LayoutJob,
     },
-    FontImage, TextureAtlas,
+    TextureAtlas,
 };
+use emath::NumExt as _;
 
-// TODO: rename
-/// One of a few categories of styles of text, e.g. body, button or heading.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+// ----------------------------------------------------------------------------
+
+/// How to select a sized font.
+#[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
-pub enum TextStyle {
-    /// Used when small text is needed.
-    Small,
-    /// Normal labels. Easily readable, doesn't take up too much space.
-    Body,
-    /// Buttons. Maybe slightly bigger than `Body`.
-    Button,
-    /// Heading. Probably larger than `Body`.
-    Heading,
-    /// Same size as `Body`, but used when monospace is important (for aligning number, code snippets, etc).
-    Monospace,
+pub struct FontId {
+    /// Height in points.
+    pub size: f32,
+
+    /// What font family to use.
+    pub family: FontFamily,
+    // TODO: weight (bold), italics, …
 }
 
-impl TextStyle {
-    pub fn all() -> impl Iterator<Item = TextStyle> {
-        [
-            TextStyle::Small,
-            TextStyle::Body,
-            TextStyle::Button,
-            TextStyle::Heading,
-            TextStyle::Monospace,
-        ]
-        .iter()
-        .copied()
+impl Default for FontId {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            size: 14.0,
+            family: FontFamily::Proportional,
+        }
     }
 }
 
-/// Which style of font: [`Monospace`][`FontFamily::Monospace`] or [`Proportional`][`FontFamily::Proportional`].
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
-pub enum FontFamily {
-    /// A font where each character is the same width (`w` is the same width as `i`).
-    Monospace,
-    /// A font where some characters are wider than other (e.g. 'w' is wider than 'i').
-    Proportional,
+impl FontId {
+    #[inline]
+    pub fn new(size: f32, family: FontFamily) -> Self {
+        Self { size, family }
+    }
+
+    #[inline]
+    pub fn proportional(size: f32) -> Self {
+        Self::new(size, FontFamily::Proportional)
+    }
+
+    #[inline]
+    pub fn monospace(size: f32) -> Self {
+        Self::new(size, FontFamily::Monospace)
+    }
 }
 
+#[allow(clippy::derive_hash_xor_eq)]
+impl std::hash::Hash for FontId {
+    #[inline(always)]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let Self { size, family } = self;
+        crate::f32_hash(state, *size);
+        family.hash(state);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Font of unknown size.
+///
+/// Which style of font: [`Monospace`][`FontFamily::Monospace`], [`Proportional`][`FontFamily::Proportional`],
+/// or by user-chosen name.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum FontFamily {
+    /// A font where some characters are wider than other (e.g. 'w' is wider than 'i').
+    ///
+    /// Proportional fonts are easier to read and should be the preferred choice in most situations.
+    Proportional,
+
+    /// A font where each character is the same width (`w` is the same width as `i`).
+    ///
+    /// Useful for code snippets, or when you need to align numbers or text.
+    Monospace,
+
+    /// One of the names in [`FontDefinitions::families`].
+    ///
+    /// ```
+    /// # use epaint::FontFamily;
+    /// // User-chosen names:
+    /// FontFamily::Name("arial".into());
+    /// FontFamily::Name("serif".into());
+    /// ```
+    Name(Arc<str>),
+}
+
+impl Default for FontFamily {
+    #[inline]
+    fn default() -> Self {
+        FontFamily::Proportional
+    }
+}
+
+impl std::fmt::Display for FontFamily {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Monospace => "Monospace".fmt(f),
+            Self::Proportional => "Proportional".fmt(f),
+            Self::Name(name) => (*name).fmt(f),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
 /// A `.ttf` or `.otf` file and a font face index.
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct FontData {
     /// The content of a `.ttf` or `.otf` file.
     pub font: std::borrow::Cow<'static, [u8]>,
+
     /// Which font face in the file to use.
     /// When in doubt, use `0`.
     pub index: u32,
@@ -97,28 +156,12 @@ fn ab_glyph_font_from_font_data(name: &str, data: &FontData) -> ab_glyph::FontAr
 ///
 /// Often you would start with [`FontDefinitions::default()`] and then add/change the contents.
 ///
+/// This is how you install your own custom fonts:
 /// ```
-/// # use {epaint::text::{FontDefinitions, TextStyle, FontFamily}};
+/// # use {epaint::text::{FontDefinitions, FontFamily, FontData}};
 /// # struct FakeEguiCtx {};
 /// # impl FakeEguiCtx { fn set_fonts(&self, _: FontDefinitions) {} }
-/// # let ctx = FakeEguiCtx {};
-/// let mut fonts = FontDefinitions::default();
-///
-/// // Large button text:
-/// fonts.family_and_size.insert(
-///     TextStyle::Button,
-///     (FontFamily::Proportional, 32.0)
-/// );
-///
-/// ctx.set_fonts(fonts);
-/// ```
-///
-/// You can also install your own custom fonts:
-/// ```
-/// # use {epaint::text::{FontDefinitions, TextStyle, FontFamily, FontData}};
-/// # struct FakeEguiCtx {};
-/// # impl FakeEguiCtx { fn set_fonts(&self, _: FontDefinitions) {} }
-/// # let ctx = FakeEguiCtx {};
+/// # let egui_ctx = FakeEguiCtx {};
 /// let mut fonts = FontDefinitions::default();
 ///
 /// // Install my own font (maybe supporting non-latin characters):
@@ -126,14 +169,14 @@ fn ab_glyph_font_from_font_data(name: &str, data: &FontData) -> ab_glyph::FontAr
 ///    FontData::from_static(include_bytes!("../../fonts/Ubuntu-Light.ttf"))); // .ttf and .otf supported
 ///
 /// // Put my font first (highest priority):
-/// fonts.fonts_for_family.get_mut(&FontFamily::Proportional).unwrap()
+/// fonts.families.get_mut(&FontFamily::Proportional).unwrap()
 ///     .insert(0, "my_font".to_owned());
 ///
 /// // Put my font as last fallback for monospace:
-/// fonts.fonts_for_family.get_mut(&FontFamily::Monospace).unwrap()
+/// fonts.families.get_mut(&FontFamily::Monospace).unwrap()
 ///     .push("my_font".to_owned());
 ///
-/// ctx.set_fonts(fonts);
+/// egui_ctx.set_fonts(fonts);
 /// ```
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -150,10 +193,8 @@ pub struct FontDefinitions {
     /// When looking for a character glyph `epaint` will start with
     /// the first font and then move to the second, and so on.
     /// So the first font is the primary, and then comes a list of fallbacks in order of priority.
-    pub fonts_for_family: BTreeMap<FontFamily, Vec<String>>,
-
-    /// The [`FontFamily`] and size you want to use for a specific [`TextStyle`].
-    pub family_and_size: BTreeMap<TextStyle, (FontFamily, f32)>,
+    // TODO: per font size-modifier.
+    pub families: BTreeMap<FontFamily, Vec<String>>,
 }
 
 impl Default for FontDefinitions {
@@ -161,7 +202,7 @@ impl Default for FontDefinitions {
         #[allow(unused)]
         let mut font_data: BTreeMap<String, FontData> = BTreeMap::new();
 
-        let mut fonts_for_family = BTreeMap::new();
+        let mut families = BTreeMap::new();
 
         #[cfg(feature = "default_fonts")]
         {
@@ -185,7 +226,7 @@ impl Default for FontDefinitions {
                 FontData::from_static(include_bytes!("../../fonts/emoji-icon-font.ttf")),
             );
 
-            fonts_for_family.insert(
+            families.insert(
                 FontFamily::Monospace,
                 vec![
                     "Hack".to_owned(),
@@ -194,7 +235,7 @@ impl Default for FontDefinitions {
                     "emoji-icon-font".to_owned(),
                 ],
             );
-            fonts_for_family.insert(
+            families.insert(
                 FontFamily::Proportional,
                 vec![
                     "Ubuntu-Light".to_owned(),
@@ -206,148 +247,149 @@ impl Default for FontDefinitions {
 
         #[cfg(not(feature = "default_fonts"))]
         {
-            fonts_for_family.insert(FontFamily::Monospace, vec![]);
-            fonts_for_family.insert(FontFamily::Proportional, vec![]);
+            families.insert(FontFamily::Monospace, vec![]);
+            families.insert(FontFamily::Proportional, vec![]);
         }
 
-        let mut family_and_size = BTreeMap::new();
-        family_and_size.insert(TextStyle::Small, (FontFamily::Proportional, 10.0));
-        family_and_size.insert(TextStyle::Body, (FontFamily::Proportional, 14.0));
-        family_and_size.insert(TextStyle::Button, (FontFamily::Proportional, 14.0));
-        family_and_size.insert(TextStyle::Heading, (FontFamily::Proportional, 20.0));
-        family_and_size.insert(TextStyle::Monospace, (FontFamily::Monospace, 14.0));
-
         Self {
             font_data,
-            fonts_for_family,
-            family_and_size,
+            families,
         }
     }
 }
 
+// ----------------------------------------------------------------------------
+
 /// The collection of fonts used by `epaint`.
 ///
 /// Required in order to paint text.
-pub struct Fonts {
-    pixels_per_point: f32,
-    definitions: FontDefinitions,
-    fonts: BTreeMap<TextStyle, Font>,
-    atlas: Arc<Mutex<TextureAtlas>>,
-
-    /// Copy of the font image in the texture atlas.
-    /// This is so we can return a reference to it (the texture atlas is behind a lock).
-    buffered_font_image: Mutex<Arc<FontImage>>,
-
-    galley_cache: Mutex<GalleyCache>,
-}
+/// Create one and reuse. Cheap to clone.
+///
+/// You need to call [`Self::begin_frame`] and [`Self::font_image_delta`] once every frame.
+///
+/// Wrapper for `Arc<Mutex<FontsAndCache>>`.
+pub struct Fonts(Arc<Mutex<FontsAndCache>>);
 
 impl Fonts {
     /// Create a new [`Fonts`] for text layout.
-    /// This call is expensive, so only create on [`Fonts`] and then reuse it.
-    pub fn new(pixels_per_point: f32, definitions: FontDefinitions) -> Self {
-        assert!(
-            0.0 < pixels_per_point && pixels_per_point < 100.0,
-            "pixels_per_point out of range: {}",
-            pixels_per_point
-        );
-
-        // We want an atlas big enough to be able to include all the Emojis in the `TextStyle::Heading`,
-        // so we can show the Emoji picker demo window.
-        let mut atlas = TextureAtlas::new(2048, 64);
-
-        {
-            // Make the top left pixel fully white:
-            let pos = atlas.allocate((1, 1));
-            assert_eq!(pos, (0, 0));
-            atlas.image_mut()[pos] = 255;
-        }
-
-        let atlas = Arc::new(Mutex::new(atlas));
-
-        let mut font_impl_cache = FontImplCache::new(atlas.clone(), pixels_per_point, &definitions);
-
-        let fonts = definitions
-            .family_and_size
-            .iter()
-            .map(|(&text_style, &(family, scale_in_points))| {
-                let fonts = &definitions.fonts_for_family.get(&family);
-                let fonts = fonts.unwrap_or_else(|| {
-                    panic!("FontFamily::{:?} is not bound to any fonts", family)
-                });
-                let fonts: Vec<Arc<FontImpl>> = fonts
-                    .iter()
-                    .map(|font_name| font_impl_cache.font_impl(font_name, scale_in_points))
-                    .collect();
-
-                (text_style, Font::new(text_style, fonts))
-            })
-            .collect();
-
-        {
-            let mut atlas = atlas.lock();
-            let texture = atlas.image_mut();
-            // Make sure we seed the texture version with something unique based on the default characters:
-            texture.version = crate::util::hash(&texture.pixels);
-        }
-
-        Self {
-            pixels_per_point,
-            definitions,
-            fonts,
-            atlas,
-            buffered_font_image: Default::default(), //atlas.lock().texture().clone();
+    /// This call is expensive, so only create one [`Fonts`] and then reuse it.
+    ///
+    /// * `pixels_per_point`: how many physical pixels per logical "point".
+    /// * `max_texture_side`: largest supported texture size (one side).
+    pub fn new(
+        pixels_per_point: f32,
+        max_texture_side: usize,
+        definitions: FontDefinitions,
+    ) -> Self {
+        let fonts_and_cache = FontsAndCache {
+            fonts: FontsImpl::new(pixels_per_point, max_texture_side, definitions),
             galley_cache: Default::default(),
-        }
+        };
+        Self(Arc::new(Mutex::new(fonts_and_cache)))
     }
 
-    #[inline(always)]
+    /// Call at the start of each frame with the latest known
+    /// `pixels_per_point` and `max_texture_side`.
+    ///
+    /// Call after painting the previous frame, but before using [`Fonts`] for the new frame.
+    ///
+    /// This function will react to changes in `pixels_per_point` and `max_texture_side`,
+    /// as well as notice when the font atlas is getting full, and handle that.
+    pub fn begin_frame(&self, pixels_per_point: f32, max_texture_side: usize) {
+        let mut fonts_and_cache = self.0.lock();
+
+        let pixels_per_point_changed =
+            (fonts_and_cache.fonts.pixels_per_point - pixels_per_point).abs() > 1e-3;
+        let max_texture_side_changed = fonts_and_cache.fonts.max_texture_side != max_texture_side;
+        let font_atlas_almost_full = fonts_and_cache.fonts.atlas.lock().fill_ratio() > 0.8;
+        let needs_recreate =
+            pixels_per_point_changed || max_texture_side_changed || font_atlas_almost_full;
+
+        if needs_recreate {
+            let definitions = fonts_and_cache.fonts.definitions.clone();
+
+            *fonts_and_cache = FontsAndCache {
+                fonts: FontsImpl::new(pixels_per_point, max_texture_side, definitions),
+                galley_cache: Default::default(),
+            };
+        }
+
+        fonts_and_cache.galley_cache.flush_cache();
+    }
+
+    /// Call at the end of each frame (before painting) to get the change to the font texture since last call.
+    pub fn font_image_delta(&self) -> Option<crate::ImageDelta> {
+        self.lock().fonts.atlas.lock().take_delta()
+    }
+
+    /// Access the underlying [`FontsAndCache`].
+    #[doc(hidden)]
+    #[inline]
+    pub fn lock(&self) -> MutexGuard<'_, FontsAndCache> {
+        self.0.lock()
+    }
+
+    #[inline]
     pub fn pixels_per_point(&self) -> f32 {
-        self.pixels_per_point
+        self.lock().fonts.pixels_per_point
     }
 
-    pub fn definitions(&self) -> &FontDefinitions {
-        &self.definitions
+    #[inline]
+    pub fn max_texture_side(&self) -> usize {
+        self.lock().fonts.max_texture_side
     }
 
-    #[inline(always)]
-    pub fn round_to_pixel(&self, point: f32) -> f32 {
-        (point * self.pixels_per_point).round() / self.pixels_per_point
-    }
-
-    #[inline(always)]
-    pub fn floor_to_pixel(&self, point: f32) -> f32 {
-        (point * self.pixels_per_point).floor() / self.pixels_per_point
-    }
-
-    /// Call each frame to get the latest available font texture data.
-    pub fn font_image(&self) -> Arc<FontImage> {
-        let atlas = self.atlas.lock();
-        let mut buffered_texture = self.buffered_font_image.lock();
-        if buffered_texture.version != atlas.image().version {
-            *buffered_texture = Arc::new(atlas.image().clone());
-        }
-
-        buffered_texture.clone()
+    /// Current size of the font image.
+    /// Pass this to [`crate::Tessellator`].
+    pub fn font_image_size(&self) -> [usize; 2] {
+        self.lock().fonts.atlas.lock().size()
     }
 
     /// Width of this character in points.
-    pub fn glyph_width(&self, text_style: TextStyle, c: char) -> f32 {
-        self.fonts[&text_style].glyph_width(c)
+    #[inline]
+    pub fn glyph_width(&self, font_id: &FontId, c: char) -> f32 {
+        self.lock().fonts.glyph_width(font_id, c)
     }
 
-    /// Height of one row of text. In points
-    pub fn row_height(&self, text_style: TextStyle) -> f32 {
-        self.fonts[&text_style].row_height()
+    /// Height of one row of text in points
+    #[inline]
+    pub fn row_height(&self, font_id: &FontId) -> f32 {
+        self.lock().fonts.row_height(font_id)
+    }
+
+    /// List of all known font families.
+    pub fn families(&self) -> Vec<FontFamily> {
+        self.lock()
+            .fonts
+            .definitions
+            .families
+            .keys()
+            .cloned()
+            .collect()
     }
 
     /// Layout some text.
+    ///
     /// This is the most advanced layout function.
     /// See also [`Self::layout`], [`Self::layout_no_wrap`] and
     /// [`Self::layout_delayed_color`].
     ///
     /// The implementation uses memoization so repeated calls are cheap.
+    #[inline]
     pub fn layout_job(&self, job: LayoutJob) -> Arc<Galley> {
-        self.galley_cache.lock().layout(self, job)
+        self.lock().layout_job(job)
+    }
+
+    pub fn num_galleys_in_cache(&self) -> usize {
+        self.lock().galley_cache.num_galleys_in_cache()
+    }
+
+    /// How full is the font atlas?
+    ///
+    /// This increases as new fonts and/or glyphs are used,
+    /// but can also decrease in a call to [`Self::begin_frame`].
+    pub fn font_atlas_fill_ratio(&self) -> f32 {
+        self.lock().fonts.atlas.lock().fill_ratio()
     }
 
     /// Will wrap text at the given width and line break at `\n`.
@@ -356,11 +398,11 @@ impl Fonts {
     pub fn layout(
         &self,
         text: String,
-        text_style: TextStyle,
+        font_id: FontId,
         color: crate::Color32,
         wrap_width: f32,
     ) -> Arc<Galley> {
-        let job = LayoutJob::simple(text, text_style, color, wrap_width);
+        let job = LayoutJob::simple(text, font_id, color, wrap_width);
         self.layout_job(job)
     }
 
@@ -370,10 +412,10 @@ impl Fonts {
     pub fn layout_no_wrap(
         &self,
         text: String,
-        text_style: TextStyle,
+        font_id: FontId,
         color: crate::Color32,
     ) -> Arc<Galley> {
-        let job = LayoutJob::simple(text, text_style, color, f32::INFINITY);
+        let job = LayoutJob::simple(text, font_id, color, f32::INFINITY);
         self.layout_job(job)
     }
 
@@ -383,33 +425,125 @@ impl Fonts {
     pub fn layout_delayed_color(
         &self,
         text: String,
-        text_style: TextStyle,
+        font_id: FontId,
         wrap_width: f32,
     ) -> Arc<Galley> {
         self.layout_job(LayoutJob::simple(
             text,
-            text_style,
+            font_id,
             crate::Color32::TEMPORARY_COLOR,
             wrap_width,
         ))
     }
+}
 
-    pub fn num_galleys_in_cache(&self) -> usize {
-        self.galley_cache.lock().num_galleys_in_cache()
-    }
+// ----------------------------------------------------------------------------
 
-    /// Must be called once per frame to clear the [`Galley`] cache.
-    pub fn end_frame(&self) {
-        self.galley_cache.lock().end_frame();
+pub struct FontsAndCache {
+    pub fonts: FontsImpl,
+    galley_cache: GalleyCache,
+}
+
+impl FontsAndCache {
+    fn layout_job(&mut self, job: LayoutJob) -> Arc<Galley> {
+        self.galley_cache.layout(&mut self.fonts, job)
     }
 }
 
-impl std::ops::Index<TextStyle> for Fonts {
-    type Output = Font;
+// ----------------------------------------------------------------------------
+
+/// The collection of fonts used by `epaint`.
+///
+/// Required in order to paint text.
+pub struct FontsImpl {
+    pixels_per_point: f32,
+    max_texture_side: usize,
+    definitions: FontDefinitions,
+    atlas: Arc<Mutex<TextureAtlas>>,
+    font_impl_cache: FontImplCache,
+    sized_family: ahash::AHashMap<(u32, FontFamily), Font>,
+}
+
+impl FontsImpl {
+    /// Create a new [`FontsImpl`] for text layout.
+    /// This call is expensive, so only create one [`FontsImpl`] and then reuse it.
+    pub fn new(
+        pixels_per_point: f32,
+        max_texture_side: usize,
+        definitions: FontDefinitions,
+    ) -> Self {
+        assert!(
+            0.0 < pixels_per_point && pixels_per_point < 100.0,
+            "pixels_per_point out of range: {}",
+            pixels_per_point
+        );
+
+        let texture_width = max_texture_side.at_most(8 * 1024);
+        let initial_height = 64;
+        let mut atlas = TextureAtlas::new([texture_width, initial_height]);
+
+        {
+            // Make the top left pixel fully white:
+            let (pos, image) = atlas.allocate((1, 1));
+            assert_eq!(pos, (0, 0));
+            image[pos] = 255;
+        }
+
+        let atlas = Arc::new(Mutex::new(atlas));
+
+        let font_impl_cache =
+            FontImplCache::new(atlas.clone(), pixels_per_point, &definitions.font_data);
+
+        Self {
+            pixels_per_point,
+            max_texture_side,
+            definitions,
+            atlas,
+            font_impl_cache,
+            sized_family: Default::default(),
+        }
+    }
 
     #[inline(always)]
-    fn index(&self, text_style: TextStyle) -> &Font {
-        &self.fonts[&text_style]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.pixels_per_point
+    }
+
+    #[inline]
+    pub fn definitions(&self) -> &FontDefinitions {
+        &self.definitions
+    }
+
+    /// Get the right font implementation from size and [`FontFamily`].
+    pub fn font(&mut self, font_id: &FontId) -> &mut Font {
+        let FontId { size, family } = font_id;
+        let scale_in_pixels = self.font_impl_cache.scale_as_pixels(*size);
+
+        self.sized_family
+            .entry((scale_in_pixels, family.clone()))
+            .or_insert_with(|| {
+                let fonts = &self.definitions.families.get(family);
+                let fonts = fonts.unwrap_or_else(|| {
+                    panic!("FontFamily::{:?} is not bound to any fonts", family)
+                });
+
+                let fonts: Vec<Arc<FontImpl>> = fonts
+                    .iter()
+                    .map(|font_name| self.font_impl_cache.font_impl(scale_in_pixels, font_name))
+                    .collect();
+
+                Font::new(fonts)
+            })
+    }
+
+    /// Width of this character in points.
+    fn glyph_width(&mut self, font_id: &FontId, c: char) -> f32 {
+        self.font(font_id).glyph_width(c)
+    }
+
+    /// Height of one row of text. In points
+    fn row_height(&mut self, font_id: &FontId) -> f32 {
+        self.font(font_id).row_height()
     }
 }
 
@@ -429,7 +563,7 @@ struct GalleyCache {
 }
 
 impl GalleyCache {
-    fn layout(&mut self, fonts: &Fonts, job: LayoutJob) -> Arc<Galley> {
+    fn layout(&mut self, fonts: &mut FontsImpl, job: LayoutJob) -> Arc<Galley> {
         let hash = crate::util::hash(&job); // TODO: even faster hasher?
 
         match self.cache.entry(hash) {
@@ -455,7 +589,7 @@ impl GalleyCache {
     }
 
     /// Must be called once per frame to clear the [`Galley`] cache.
-    pub fn end_frame(&mut self) {
+    pub fn flush_cache(&mut self) {
         let current_generation = self.generation;
         self.cache.retain(|_key, cached| {
             cached.last_used == current_generation // only keep those that were used this frame
@@ -471,19 +605,17 @@ struct FontImplCache {
     pixels_per_point: f32,
     ab_glyph_fonts: BTreeMap<String, ab_glyph::FontArc>,
 
-    /// Map font names and size to the cached `FontImpl`.
-    /// Can't have f32 in a HashMap or BTreeMap, so let's do a linear search
-    cache: Vec<(String, f32, Arc<FontImpl>)>,
+    /// Map font pixel sizes and names to the cached `FontImpl`.
+    cache: ahash::AHashMap<(u32, String), Arc<FontImpl>>,
 }
 
 impl FontImplCache {
     pub fn new(
         atlas: Arc<Mutex<TextureAtlas>>,
         pixels_per_point: f32,
-        definitions: &super::FontDefinitions,
+        font_data: &BTreeMap<String, FontData>,
     ) -> Self {
-        let ab_glyph_fonts = definitions
-            .font_data
+        let ab_glyph_fonts = font_data
             .iter()
             .map(|(name, font_data)| (name.clone(), ab_glyph_font_from_font_data(name, font_data)))
             .collect();
@@ -496,42 +628,47 @@ impl FontImplCache {
         }
     }
 
-    pub fn ab_glyph_font(&self, font_name: &str) -> ab_glyph::FontArc {
-        self.ab_glyph_fonts
-            .get(font_name)
-            .unwrap_or_else(|| panic!("No font data found for {:?}", font_name))
-            .clone()
+    #[inline]
+    pub fn scale_as_pixels(&self, scale_in_points: f32) -> u32 {
+        let scale_in_pixels = self.pixels_per_point * scale_in_points;
+
+        // Round to an even number of physical pixels to get even kerning.
+        // See https://github.com/emilk/egui/issues/382
+        scale_in_pixels.round() as u32
     }
 
-    pub fn font_impl(&mut self, font_name: &str, scale_in_points: f32) -> Arc<FontImpl> {
-        for entry in &self.cache {
-            if (entry.0.as_str(), entry.1) == (font_name, scale_in_points) {
-                return entry.2.clone();
-            }
-        }
+    pub fn font_impl(&mut self, scale_in_pixels: u32, font_name: &str) -> Arc<FontImpl> {
+        let scale_in_pixels = if font_name == "emoji-icon-font" {
+            (scale_in_pixels as f32 * 0.8).round() as u32 // TODO: remove font scale HACK!
+        } else {
+            scale_in_pixels
+        };
 
         let y_offset = if font_name == "emoji-icon-font" {
-            scale_in_points * 0.235 // TODO: remove font alignment hack
+            let scale_in_points = scale_in_pixels as f32 / self.pixels_per_point;
+            scale_in_points * 0.29375 // TODO: remove font alignment hack
         } else {
             0.0
         };
         let y_offset = y_offset - 3.0; // Tweaked to make text look centered in buttons and text edit fields
 
-        let scale_in_points = if font_name == "emoji-icon-font" {
-            scale_in_points * 0.8 // TODO: remove HACK!
-        } else {
-            scale_in_points
-        };
-
-        let font_impl = Arc::new(FontImpl::new(
-            self.atlas.clone(),
-            self.pixels_per_point,
-            self.ab_glyph_font(font_name),
-            scale_in_points,
-            y_offset,
-        ));
         self.cache
-            .push((font_name.to_owned(), scale_in_points, font_impl.clone()));
-        font_impl
+            .entry((scale_in_pixels, font_name.to_owned()))
+            .or_insert_with(|| {
+                let ab_glyph_font = self
+                    .ab_glyph_fonts
+                    .get(font_name)
+                    .unwrap_or_else(|| panic!("No font data found for {:?}", font_name))
+                    .clone();
+
+                Arc::new(FontImpl::new(
+                    self.atlas.clone(),
+                    self.pixels_per_point,
+                    ab_glyph_font,
+                    scale_in_pixels,
+                    y_offset,
+                ))
+            })
+            .clone()
     }
 }
diff --git a/epaint/src/text/mod.rs b/epaint/src/text/mod.rs
index ee2b5c07..32d4070a 100644
--- a/epaint/src/text/mod.rs
+++ b/epaint/src/text/mod.rs
@@ -10,7 +10,7 @@ mod text_layout_types;
 pub const TAB_SIZE: usize = 4;
 
 pub use {
-    fonts::{FontData, FontDefinitions, FontFamily, Fonts, TextStyle},
+    fonts::{FontData, FontDefinitions, FontFamily, FontId, Fonts, FontsImpl},
     text_layout::layout,
     text_layout_types::*,
 };
diff --git a/epaint/src/text/text_layout.rs b/epaint/src/text/text_layout.rs
index 7483f4e9..a70127c7 100644
--- a/epaint/src/text/text_layout.rs
+++ b/epaint/src/text/text_layout.rs
@@ -1,10 +1,41 @@
 use std::ops::RangeInclusive;
-use std::sync::Arc;
 
-use super::{Fonts, Galley, Glyph, LayoutJob, LayoutSection, Row, RowVisuals};
-use crate::{Color32, Mesh, Stroke, Vertex};
+use super::{FontsImpl, Galley, Glyph, LayoutJob, LayoutSection, Row, RowVisuals};
+use crate::{mutex::Arc, Color32, Mesh, Stroke, Vertex};
 use emath::*;
 
+// ----------------------------------------------------------------------------
+
+/// Represents GUI scale and convenience methods for rounding to pixels.
+#[derive(Clone, Copy)]
+struct PointScale {
+    pub pixels_per_point: f32,
+}
+
+impl PointScale {
+    #[inline(always)]
+    pub fn new(pixels_per_point: f32) -> Self {
+        Self { pixels_per_point }
+    }
+
+    #[inline(always)]
+    pub fn pixels_per_point(&self) -> f32 {
+        self.pixels_per_point
+    }
+
+    #[inline(always)]
+    pub fn round_to_pixel(&self, point: f32) -> f32 {
+        (point * self.pixels_per_point).round() / self.pixels_per_point
+    }
+
+    #[inline(always)]
+    pub fn floor_to_pixel(&self, point: f32) -> f32 {
+        (point * self.pixels_per_point).floor() / self.pixels_per_point
+    }
+}
+
+// ----------------------------------------------------------------------------
+
 /// Temporary storage before line-wrapping.
 #[derive(Default, Clone)]
 struct Paragraph {
@@ -17,14 +48,16 @@ struct Paragraph {
 
 /// Layout text into a [`Galley`].
 ///
-/// In most cases you should use [`Fonts::layout_job`] instead
+/// In most cases you should use [`crate::Fonts::layout_job`] instead
 /// since that memoizes the input, making subsequent layouting of the same text much faster.
-pub fn layout(fonts: &Fonts, job: Arc<LayoutJob>) -> Galley {
+pub fn layout(fonts: &mut FontsImpl, job: Arc<LayoutJob>) -> Galley {
     let mut paragraphs = vec![Paragraph::default()];
     for (section_index, section) in job.sections.iter().enumerate() {
         layout_section(fonts, &job, section_index as u32, section, &mut paragraphs);
     }
 
+    let point_scale = PointScale::new(fonts.pixels_per_point());
+
     let mut rows = rows_from_paragraphs(paragraphs, job.wrap_width);
 
     let justify = job.justify && job.wrap_width.is_finite();
@@ -34,15 +67,15 @@ pub fn layout(fonts: &Fonts, job: Arc<LayoutJob>) -> Galley {
         for (i, row) in rows.iter_mut().enumerate() {
             let is_last_row = i + 1 == num_rows;
             let justify_row = justify && !row.ends_with_newline && !is_last_row;
-            halign_and_jusitfy_row(fonts, row, job.halign, job.wrap_width, justify_row);
+            halign_and_jusitfy_row(point_scale, row, job.halign, job.wrap_width, justify_row);
         }
     }
 
-    galley_from_rows(fonts, job, rows)
+    galley_from_rows(point_scale, job, rows)
 }
 
 fn layout_section(
-    fonts: &Fonts,
+    fonts: &mut FontsImpl,
     job: &LayoutJob,
     section_index: u32,
     section: &LayoutSection,
@@ -53,7 +86,7 @@ fn layout_section(
         byte_range,
         format,
     } = section;
-    let font = &fonts[format.style];
+    let font = fonts.font(&format.font_id);
     let font_height = font.row_height();
 
     let mut paragraph = out_paragraphs.last_mut().unwrap();
@@ -214,7 +247,7 @@ fn line_break(paragraph: &Paragraph, wrap_width: f32, out_rows: &mut Vec<Row>) {
 }
 
 fn halign_and_jusitfy_row(
-    fonts: &Fonts,
+    point_scale: PointScale,
     row: &mut Row,
     halign: Align,
     wrap_width: f32,
@@ -279,7 +312,7 @@ fn halign_and_jusitfy_row(
         // Add an integral number of pixels between each glyph,
         // and add the balance to the spaces:
 
-        extra_x_per_glyph = fonts.floor_to_pixel(extra_x_per_glyph);
+        extra_x_per_glyph = point_scale.floor_to_pixel(extra_x_per_glyph);
 
         extra_x_per_space = (target_width
             - original_width
@@ -291,7 +324,7 @@ fn halign_and_jusitfy_row(
 
     for glyph in &mut row.glyphs {
         glyph.pos.x += translate_x;
-        glyph.pos.x = fonts.round_to_pixel(glyph.pos.x);
+        glyph.pos.x = point_scale.round_to_pixel(glyph.pos.x);
         translate_x += extra_x_per_glyph;
         if glyph.chr.is_whitespace() {
             translate_x += extra_x_per_space;
@@ -304,7 +337,7 @@ fn halign_and_jusitfy_row(
 }
 
 /// Calculate the Y positions and tessellate the text.
-fn galley_from_rows(fonts: &Fonts, job: Arc<LayoutJob>, mut rows: Vec<Row>) -> Galley {
+fn galley_from_rows(point_scale: PointScale, job: Arc<LayoutJob>, mut rows: Vec<Row>) -> Galley {
     let mut first_row_min_height = job.first_row_min_height;
     let mut cursor_y = 0.0;
     let mut min_x: f32 = 0.0;
@@ -315,13 +348,13 @@ fn galley_from_rows(fonts: &Fonts, job: Arc<LayoutJob>, mut rows: Vec<Row>) -> G
         for glyph in &row.glyphs {
             row_height = row_height.max(glyph.size.y);
         }
-        row_height = fonts.round_to_pixel(row_height);
+        row_height = point_scale.round_to_pixel(row_height);
 
         // Now positions each glyph:
         for glyph in &mut row.glyphs {
             let format = &job.sections[glyph.section_index as usize].format;
             glyph.pos.y = cursor_y + format.valign.to_factor() * (row_height - glyph.size.y);
-            glyph.pos.y = fonts.round_to_pixel(glyph.pos.y);
+            glyph.pos.y = point_scale.round_to_pixel(glyph.pos.y);
         }
 
         row.rect.min.y = cursor_y;
@@ -330,7 +363,7 @@ fn galley_from_rows(fonts: &Fonts, job: Arc<LayoutJob>, mut rows: Vec<Row>) -> G
         min_x = min_x.min(row.rect.min.x);
         max_x = max_x.max(row.rect.max.x);
         cursor_y += row_height;
-        cursor_y = fonts.round_to_pixel(cursor_y);
+        cursor_y = point_scale.round_to_pixel(cursor_y);
     }
 
     let format_summary = format_summary(&job);
@@ -340,7 +373,7 @@ fn galley_from_rows(fonts: &Fonts, job: Arc<LayoutJob>, mut rows: Vec<Row>) -> G
     let mut num_indices = 0;
 
     for row in &mut rows {
-        row.visuals = tessellate_row(fonts, &job, &format_summary, row);
+        row.visuals = tessellate_row(point_scale, &job, &format_summary, row);
         mesh_bounds = mesh_bounds.union(row.visuals.mesh_bounds);
         num_vertices += row.visuals.mesh.vertices.len();
         num_indices += row.visuals.mesh.indices.len();
@@ -376,7 +409,7 @@ fn format_summary(job: &LayoutJob) -> FormatSummary {
 }
 
 fn tessellate_row(
-    fonts: &Fonts,
+    point_scale: PointScale,
     job: &LayoutJob,
     format_summary: &FormatSummary,
     row: &mut Row,
@@ -395,11 +428,11 @@ fn tessellate_row(
     }
 
     let glyph_vertex_start = mesh.vertices.len();
-    tessellate_glyphs(fonts, job, row, &mut mesh);
+    tessellate_glyphs(point_scale, job, row, &mut mesh);
     let glyph_vertex_end = mesh.vertices.len();
 
     if format_summary.any_underline {
-        add_row_hline(fonts, row, &mut mesh, |glyph| {
+        add_row_hline(point_scale, row, &mut mesh, |glyph| {
             let format = &job.sections[glyph.section_index as usize].format;
             let stroke = format.underline;
             let y = glyph.logical_rect().bottom();
@@ -408,7 +441,7 @@ fn tessellate_row(
     }
 
     if format_summary.any_strikethrough {
-        add_row_hline(fonts, row, &mut mesh, |glyph| {
+        add_row_hline(point_scale, row, &mut mesh, |glyph| {
             let format = &job.sections[glyph.section_index as usize].format;
             let stroke = format.strikethrough;
             let y = glyph.logical_rect().center().y;
@@ -470,13 +503,13 @@ fn add_row_backgrounds(job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
     end_run(run_start.take(), last_rect.right());
 }
 
-fn tessellate_glyphs(fonts: &Fonts, job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
+fn tessellate_glyphs(point_scale: PointScale, job: &LayoutJob, row: &Row, mesh: &mut Mesh) {
     for glyph in &row.glyphs {
         let uv_rect = glyph.uv_rect;
         if !uv_rect.is_nothing() {
             let mut left_top = glyph.pos + uv_rect.offset;
-            left_top.x = fonts.round_to_pixel(left_top.x);
-            left_top.y = fonts.round_to_pixel(left_top.y);
+            left_top.x = point_scale.round_to_pixel(left_top.x);
+            left_top.y = point_scale.round_to_pixel(left_top.y);
 
             let rect = Rect::from_min_max(left_top, left_top + uv_rect.size);
             let uv = Rect::from_min_max(
@@ -524,14 +557,14 @@ fn tessellate_glyphs(fonts: &Fonts, job: &LayoutJob, row: &Row, mesh: &mut Mesh)
 
 /// Add a horizontal line over a row of glyphs with a stroke and y decided by a callback.
 fn add_row_hline(
-    fonts: &Fonts,
+    point_scale: PointScale,
     row: &Row,
     mesh: &mut Mesh,
     stroke_and_y: impl Fn(&Glyph) -> (Stroke, f32),
 ) {
     let mut end_line = |start: Option<(Stroke, Pos2)>, stop_x: f32| {
         if let Some((stroke, start)) = start {
-            add_hline(fonts, [start, pos2(stop_x, start.y)], stroke, mesh);
+            add_hline(point_scale, [start, pos2(stop_x, start.y)], stroke, mesh);
         }
     };
 
@@ -560,14 +593,14 @@ fn add_row_hline(
     end_line(line_start.take(), last_right_x);
 }
 
-fn add_hline(fonts: &Fonts, [start, stop]: [Pos2; 2], stroke: Stroke, mesh: &mut Mesh) {
+fn add_hline(point_scale: PointScale, [start, stop]: [Pos2; 2], stroke: Stroke, mesh: &mut Mesh) {
     let antialiased = true;
 
     if antialiased {
         let mut path = crate::tessellator::Path::default(); // TODO: reuse this to avoid re-allocations.
         path.add_line_segment([start, stop]);
         let options = crate::tessellator::TessellationOptions::from_pixels_per_point(
-            fonts.pixels_per_point(),
+            point_scale.pixels_per_point(),
         );
         path.stroke_open(stroke, &options, mesh);
     } else {
@@ -575,12 +608,12 @@ fn add_hline(fonts: &Fonts, [start, stop]: [Pos2; 2], stroke: Stroke, mesh: &mut
 
         assert_eq!(start.y, stop.y);
 
-        let min_y = fonts.round_to_pixel(start.y - 0.5 * stroke.width);
-        let max_y = fonts.round_to_pixel(min_y + stroke.width);
+        let min_y = point_scale.round_to_pixel(start.y - 0.5 * stroke.width);
+        let max_y = point_scale.round_to_pixel(min_y + stroke.width);
 
         let rect = Rect::from_min_max(
-            pos2(fonts.round_to_pixel(start.x), min_y),
-            pos2(fonts.round_to_pixel(stop.x), max_y),
+            pos2(point_scale.round_to_pixel(start.x), min_y),
+            pos2(point_scale.round_to_pixel(stop.x), max_y),
         );
 
         mesh.add_colored_rect(rect, stroke.color);
diff --git a/epaint/src/text/text_layout_types.rs b/epaint/src/text/text_layout_types.rs
index 415e26c4..0b608df0 100644
--- a/epaint/src/text/text_layout_types.rs
+++ b/epaint/src/text/text_layout_types.rs
@@ -1,10 +1,9 @@
 #![allow(clippy::derive_hash_xor_eq)] // We need to impl Hash for f32, but we don't implement Eq, which is fine
 
 use std::ops::Range;
-use std::sync::Arc;
 
 use super::{cursor::*, font::UvRect};
-use crate::{Color32, Mesh, Stroke, TextStyle};
+use crate::{mutex::Arc, Color32, FontId, Mesh, Stroke};
 use emath::*;
 
 /// Describes the task of laying out text.
@@ -15,14 +14,14 @@ use emath::*;
 ///
 /// ## Example:
 /// ```
-/// use epaint::{Color32, text::{LayoutJob, TextFormat}, TextStyle};
+/// use epaint::{Color32, text::{LayoutJob, TextFormat}, FontFamily, FontId};
 ///
 /// let mut job = LayoutJob::default();
 /// job.append(
 ///     "Hello ",
 ///     0.0,
 ///     TextFormat {
-///         style: TextStyle::Body,
+///         font_id: FontId::new(14.0, FontFamily::Proportional),
 ///         color: Color32::WHITE,
 ///         ..Default::default()
 ///     },
@@ -31,7 +30,7 @@ use emath::*;
 ///     "World!",
 ///     0.0,
 ///     TextFormat {
-///         style: TextStyle::Monospace,
+///         font_id: FontId::new(14.0, FontFamily::Monospace),
 ///         color: Color32::BLACK,
 ///         ..Default::default()
 ///     },
@@ -91,12 +90,12 @@ impl Default for LayoutJob {
 impl LayoutJob {
     /// Break on `\n` and at the given wrap width.
     #[inline]
-    pub fn simple(text: String, text_style: TextStyle, color: Color32, wrap_width: f32) -> Self {
+    pub fn simple(text: String, font_id: FontId, color: Color32, wrap_width: f32) -> Self {
         Self {
             sections: vec![LayoutSection {
                 leading_space: 0.0,
                 byte_range: 0..text.len(),
-                format: TextFormat::simple(text_style, color),
+                format: TextFormat::simple(font_id, color),
             }],
             text,
             wrap_width,
@@ -107,12 +106,12 @@ impl LayoutJob {
 
     /// Does not break on `\n`, but shows the replacement character instead.
     #[inline]
-    pub fn simple_singleline(text: String, text_style: TextStyle, color: Color32) -> Self {
+    pub fn simple_singleline(text: String, font_id: FontId, color: Color32) -> Self {
         Self {
             sections: vec![LayoutSection {
                 leading_space: 0.0,
                 byte_range: 0..text.len(),
-                format: TextFormat::simple(text_style, color),
+                format: TextFormat::simple(font_id, color),
             }],
             text,
             wrap_width: f32::INFINITY,
@@ -157,7 +156,7 @@ impl LayoutJob {
     pub fn font_height(&self, fonts: &crate::Fonts) -> f32 {
         let mut max_height = 0.0_f32;
         for section in &self.sections {
-            max_height = max_height.max(fonts.row_height(section.format.style));
+            max_height = max_height.max(fonts.row_height(&section.format.font_id));
         }
         max_height
     }
@@ -214,10 +213,10 @@ impl std::hash::Hash for LayoutSection {
 
 // ----------------------------------------------------------------------------
 
-#[derive(Copy, Clone, Debug, Hash, PartialEq)]
+#[derive(Clone, Debug, Hash, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct TextFormat {
-    pub style: TextStyle,
+    pub font_id: FontId,
     /// Text color
     pub color: Color32,
     pub background: Color32,
@@ -234,7 +233,7 @@ impl Default for TextFormat {
     #[inline]
     fn default() -> Self {
         Self {
-            style: TextStyle::Body,
+            font_id: FontId::default(),
             color: Color32::GRAY,
             background: Color32::TRANSPARENT,
             italics: false,
@@ -247,9 +246,9 @@ impl Default for TextFormat {
 
 impl TextFormat {
     #[inline]
-    pub fn simple(style: TextStyle, color: Color32) -> Self {
+    pub fn simple(font_id: FontId, color: Color32) -> Self {
         Self {
-            style,
+            font_id,
             color,
             ..Default::default()
         }
diff --git a/epaint/src/texture_atlas.rs b/epaint/src/texture_atlas.rs
index a79501aa..c31625f3 100644
--- a/epaint/src/texture_atlas.rs
+++ b/epaint/src/texture_atlas.rs
@@ -1,110 +1,109 @@
-/// An 8-bit texture containing font data.
-#[derive(Clone, Default)]
-pub struct FontImage {
-    /// e.g. a hash of the data. Use this to detect changes!
-    /// If the texture changes, this too will change.
-    pub version: u64,
-    pub width: usize,
-    pub height: usize,
-    /// The alpha (linear space 0-255) of something white.
-    ///
-    /// One byte per pixel. Often you want to use [`Self::srgba_pixels`] instead.
-    pub pixels: Vec<u8>,
+use crate::{AlphaImage, ImageDelta};
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+struct Rectu {
+    /// inclusive
+    min_x: usize,
+    /// inclusive
+    min_y: usize,
+    /// exclusive
+    max_x: usize,
+    /// exclusive
+    max_y: usize,
 }
 
-impl FontImage {
-    pub fn size(&self) -> [usize; 2] {
-        [self.width, self.height]
-    }
-
-    /// Returns the textures as `sRGBA` premultiplied pixels, row by row, top to bottom.
-    ///
-    /// `gamma` should normally be set to 1.0.
-    /// If you are having problems with egui text looking skinny and pixelated, try
-    /// setting a lower gamma, e.g. `0.5`.
-    pub fn srgba_pixels(&'_ self, gamma: f32) -> impl Iterator<Item = super::Color32> + '_ {
-        use super::Color32;
-
-        let srgba_from_luminance_lut: Vec<Color32> = (0..=255)
-            .map(|a| {
-                let a = super::color::linear_f32_from_linear_u8(a).powf(gamma);
-                super::Rgba::from_white_alpha(a).into()
-            })
-            .collect();
-        self.pixels
-            .iter()
-            .map(move |&l| srgba_from_luminance_lut[l as usize])
-    }
-}
-
-impl std::ops::Index<(usize, usize)> for FontImage {
-    type Output = u8;
-
-    #[inline]
-    fn index(&self, (x, y): (usize, usize)) -> &u8 {
-        assert!(x < self.width);
-        assert!(y < self.height);
-        &self.pixels[y * self.width + x]
-    }
-}
-
-impl std::ops::IndexMut<(usize, usize)> for FontImage {
-    #[inline]
-    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut u8 {
-        assert!(x < self.width);
-        assert!(y < self.height);
-        &mut self.pixels[y * self.width + x]
-    }
+impl Rectu {
+    const NOTHING: Self = Self {
+        min_x: usize::MAX,
+        min_y: usize::MAX,
+        max_x: 0,
+        max_y: 0,
+    };
+    const EVERYTHING: Self = Self {
+        min_x: 0,
+        min_y: 0,
+        max_x: usize::MAX,
+        max_y: usize::MAX,
+    };
 }
 
 /// Contains font data in an atlas, where each character occupied a small rectangle.
 ///
 /// More characters can be added, possibly expanding the texture.
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct TextureAtlas {
-    image: FontImage,
+    image: AlphaImage,
+    /// What part of the image that is dirty
+    dirty: Rectu,
 
     /// Used for when allocating new rectangles.
     cursor: (usize, usize),
     row_height: usize,
+
+    /// Set when someone requested more space than was available.
+    overflowed: bool,
 }
 
 impl TextureAtlas {
-    pub fn new(width: usize, height: usize) -> Self {
+    pub fn new(size: [usize; 2]) -> Self {
+        assert!(size[0] >= 1024, "Tiny texture atlas");
         Self {
-            image: FontImage {
-                version: 0,
-                width,
-                height,
-                pixels: vec![0; width * height],
-            },
-            ..Default::default()
+            image: AlphaImage::new(size),
+            dirty: Rectu::EVERYTHING,
+            cursor: (0, 0),
+            row_height: 0,
+            overflowed: false,
         }
     }
 
-    pub fn image(&self) -> &FontImage {
-        &self.image
+    pub fn size(&self) -> [usize; 2] {
+        self.image.size
     }
 
-    pub fn image_mut(&mut self) -> &mut FontImage {
-        self.image.version += 1;
-        &mut self.image
+    fn max_height(&self) -> usize {
+        // the initial width is likely the max texture side size
+        self.image.width()
     }
 
-    /// Returns the coordinates of where the rect ended up.
-    pub fn allocate(&mut self, (w, h): (usize, usize)) -> (usize, usize) {
+    /// When this get high, it might be time to clear and start over!
+    pub fn fill_ratio(&self) -> f32 {
+        if self.overflowed {
+            1.0
+        } else {
+            (self.cursor.1 + self.row_height) as f32 / self.max_height() as f32
+        }
+    }
+
+    /// Call to get the change to the image since last call.
+    pub fn take_delta(&mut self) -> Option<ImageDelta> {
+        let dirty = std::mem::replace(&mut self.dirty, Rectu::NOTHING);
+        if dirty == Rectu::NOTHING {
+            None
+        } else if dirty == Rectu::EVERYTHING {
+            Some(ImageDelta::full(self.image.clone()))
+        } else {
+            let pos = [dirty.min_x, dirty.min_y];
+            let size = [dirty.max_x - dirty.min_x, dirty.max_y - dirty.min_y];
+            let region = self.image.region(pos, size);
+            Some(ImageDelta::partial(pos, region))
+        }
+    }
+
+    /// Returns the coordinates of where the rect ended up,
+    /// and invalidates the region.
+    pub fn allocate(&mut self, (w, h): (usize, usize)) -> ((usize, usize), &mut AlphaImage) {
         /// On some low-precision GPUs (my old iPad) characters get muddled up
         /// if we don't add some empty pixels between the characters.
         /// On modern high-precision GPUs this is not needed.
         const PADDING: usize = 1;
 
         assert!(
-            w <= self.image.width,
+            w <= self.image.width(),
             "Tried to allocate a {} wide glyph in a {} wide texture atlas",
             w,
-            self.image.width
+            self.image.width()
         );
-        if self.cursor.0 + w > self.image.width {
+        if self.cursor.0 + w > self.image.width() {
             // New row:
             self.cursor.0 = 0;
             self.cursor.1 += self.row_height + PADDING;
@@ -112,19 +111,42 @@ impl TextureAtlas {
         }
 
         self.row_height = self.row_height.max(h);
-        while self.cursor.1 + self.row_height >= self.image.height {
-            self.image.height *= 2;
-        }
 
-        if self.image.width * self.image.height > self.image.pixels.len() {
-            self.image
-                .pixels
-                .resize(self.image.width * self.image.height, 0);
+        let required_height = self.cursor.1 + self.row_height;
+
+        if required_height > self.max_height() {
+            // This is a bad place to be - we need to start reusing space :/
+
+            #[cfg(feature = "tracing")]
+            tracing::wan!("epaint texture atlas overflowed!");
+
+            self.cursor = (0, self.image.height() / 3); // Restart a bit down - the top of the atlas has too many important things in it
+            self.overflowed = true; // this will signal the user that we need to recreate the texture atlas next frame.
+        } else if resize_to_min_height(&mut self.image, required_height) {
+            self.dirty = Rectu::EVERYTHING;
         }
 
         let pos = self.cursor;
         self.cursor.0 += w + PADDING;
-        self.image.version += 1;
-        (pos.0 as usize, pos.1 as usize)
+
+        self.dirty.min_x = self.dirty.min_x.min(pos.0);
+        self.dirty.min_y = self.dirty.min_y.min(pos.1);
+        self.dirty.max_x = self.dirty.max_x.max(pos.0 + w);
+        self.dirty.max_y = self.dirty.max_y.max(pos.1 + h);
+
+        (pos, &mut self.image)
+    }
+}
+
+fn resize_to_min_height(image: &mut AlphaImage, required_height: usize) -> bool {
+    while required_height >= image.height() {
+        image.size[1] *= 2; // double the height
+    }
+
+    if image.width() * image.height() > image.pixels.len() {
+        image.pixels.resize(image.width() * image.height(), 0);
+        true
+    } else {
+        false
     }
 }
diff --git a/epaint/src/texture_handle.rs b/epaint/src/texture_handle.rs
new file mode 100644
index 00000000..fd10de26
--- /dev/null
+++ b/epaint/src/texture_handle.rs
@@ -0,0 +1,116 @@
+use crate::{
+    emath::NumExt,
+    mutex::{Arc, RwLock},
+    ImageData, ImageDelta, TextureId, TextureManager,
+};
+
+/// Used to paint images.
+///
+/// An _image_ is pixels stored in RAM, and represented using [`ImageData`].
+/// Before you can paint it however, you need to convert it to a _texture_.
+///
+/// If you are using egui, use `egui::Context::load_texture`.
+///
+/// The [`TextureHandle`] can be cloned cheaply.
+/// When the last [`TextureHandle`] for specific texture is dropped, the texture is freed.
+///
+/// See also [`TextureManager`].
+#[must_use]
+pub struct TextureHandle {
+    tex_mngr: Arc<RwLock<TextureManager>>,
+    id: TextureId,
+}
+
+impl Drop for TextureHandle {
+    fn drop(&mut self) {
+        self.tex_mngr.write().free(self.id);
+    }
+}
+
+impl Clone for TextureHandle {
+    fn clone(&self) -> Self {
+        self.tex_mngr.write().retain(self.id);
+        Self {
+            tex_mngr: self.tex_mngr.clone(),
+            id: self.id,
+        }
+    }
+}
+
+impl PartialEq for TextureHandle {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl Eq for TextureHandle {}
+
+impl std::hash::Hash for TextureHandle {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
+impl TextureHandle {
+    /// If you are using egui, use `egui::Context::load_texture` instead.
+    pub fn new(tex_mngr: Arc<RwLock<TextureManager>>, id: TextureId) -> Self {
+        Self { tex_mngr, id }
+    }
+
+    #[inline]
+    pub fn id(&self) -> TextureId {
+        self.id
+    }
+
+    /// Assign a new image to an existing texture.
+    pub fn set(&mut self, image: impl Into<ImageData>) {
+        self.tex_mngr
+            .write()
+            .set(self.id, ImageDelta::full(image.into()));
+    }
+
+    /// Assign a new image to a subregion of the whole texture.
+    pub fn set_partial(&mut self, pos: [usize; 2], image: impl Into<ImageData>) {
+        self.tex_mngr
+            .write()
+            .set(self.id, ImageDelta::partial(pos, image.into()));
+    }
+
+    /// width x height
+    pub fn size(&self) -> [usize; 2] {
+        self.tex_mngr.read().meta(self.id).unwrap().size
+    }
+
+    /// width x height
+    pub fn size_vec2(&self) -> crate::Vec2 {
+        let [w, h] = self.size();
+        crate::Vec2::new(w as f32, h as f32)
+    }
+
+    /// width / height
+    pub fn aspect_ratio(&self) -> f32 {
+        let [w, h] = self.size();
+        w as f32 / h.at_least(1) as f32
+    }
+
+    /// Debug-name.
+    pub fn name(&self) -> String {
+        self.tex_mngr.read().meta(self.id).unwrap().name.clone()
+    }
+}
+
+impl From<&TextureHandle> for TextureId {
+    #[inline(always)]
+    fn from(handle: &TextureHandle) -> Self {
+        handle.id()
+    }
+}
+
+impl From<&mut TextureHandle> for TextureId {
+    #[inline(always)]
+    fn from(handle: &mut TextureHandle) -> Self {
+        handle.id()
+    }
+}
diff --git a/epaint/src/textures.rs b/epaint/src/textures.rs
new file mode 100644
index 00000000..a67382f0
--- /dev/null
+++ b/epaint/src/textures.rs
@@ -0,0 +1,164 @@
+use crate::{ImageData, ImageDelta, TextureId};
+use ahash::AHashMap;
+
+// ----------------------------------------------------------------------------
+
+/// Low-level manager for allocating textures.
+///
+/// Communicates with the painting subsystem using [`Self::take_delta`].
+#[derive(Default)]
+pub struct TextureManager {
+    /// We allocate texture id:s linearly.
+    next_id: u64,
+    /// Information about currently allocated textures.
+    metas: AHashMap<TextureId, TextureMeta>,
+    delta: TexturesDelta,
+}
+
+impl TextureManager {
+    /// Allocate a new texture.
+    ///
+    /// The given name can be useful for later debugging.
+    ///
+    /// The returned [`TextureId`] will be [`TextureId::Managed`], with an index
+    /// starting from zero and increasing with each call to [`Self::alloc`].
+    ///
+    /// The first texture you allocate will be `TextureId::Managed(0) == TexureId::default()` and
+    /// MUST have a white pixel at (0,0) ([`crate::WHITE_UV`]).
+    ///
+    /// The texture is given a retain-count of `1`, requiring one call to [`Self::free`] to free it.
+    pub fn alloc(&mut self, name: String, image: ImageData) -> TextureId {
+        let id = TextureId::Managed(self.next_id);
+        self.next_id += 1;
+
+        self.metas.entry(id).or_insert_with(|| TextureMeta {
+            name,
+            size: image.size(),
+            bytes_per_pixel: image.bytes_per_pixel(),
+            retain_count: 1,
+        });
+
+        self.delta.set.insert(id, ImageDelta::full(image));
+        id
+    }
+
+    /// Assign a new image to an existing texture,
+    /// or update a region of it.
+    pub fn set(&mut self, id: TextureId, delta: ImageDelta) {
+        if let Some(meta) = self.metas.get_mut(&id) {
+            if delta.is_whole() {
+                meta.size = delta.image.size();
+                meta.bytes_per_pixel = delta.image.bytes_per_pixel();
+            }
+            self.delta.set.insert(id, delta);
+        } else {
+            crate::epaint_assert!(
+                false,
+                "Tried setting texture {:?} which is not allocated",
+                id
+            );
+        }
+    }
+
+    /// Free an existing texture.
+    pub fn free(&mut self, id: TextureId) {
+        if let std::collections::hash_map::Entry::Occupied(mut entry) = self.metas.entry(id) {
+            let meta = entry.get_mut();
+            meta.retain_count -= 1;
+            if meta.retain_count == 0 {
+                entry.remove();
+                self.delta.free.push(id);
+            }
+        } else {
+            crate::epaint_assert!(
+                false,
+                "Tried freeing texture {:?} which is not allocated",
+                id
+            );
+        }
+    }
+
+    /// Increase the retain-count of the given texture.
+    ///
+    /// For each time you call [`Self::retain`] you must call [`Self::free`] on additional time.
+    pub fn retain(&mut self, id: TextureId) {
+        if let Some(meta) = self.metas.get_mut(&id) {
+            meta.retain_count += 1;
+        } else {
+            crate::epaint_assert!(
+                false,
+                "Tried retaining texture {:?} which is not allocated",
+                id
+            );
+        }
+    }
+
+    /// Take and reset changes since last frame.
+    ///
+    /// These should be applied to the painting subsystem each frame.
+    pub fn take_delta(&mut self) -> TexturesDelta {
+        std::mem::take(&mut self.delta)
+    }
+
+    /// Get meta-data about a specific texture.
+    pub fn meta(&self, id: TextureId) -> Option<&TextureMeta> {
+        self.metas.get(&id)
+    }
+
+    /// Get meta-data about all allocated textures in some arbitrary order.
+    pub fn allocated(&self) -> impl ExactSizeIterator<Item = (&TextureId, &TextureMeta)> {
+        self.metas.iter()
+    }
+
+    /// Total number of allocated textures.
+    pub fn num_allocated(&self) -> usize {
+        self.metas.len()
+    }
+}
+
+/// Meta-data about an allocated texture.
+#[derive(Clone, Debug, PartialEq)]
+pub struct TextureMeta {
+    /// A human-readable name useful for debugging.
+    pub name: String,
+
+    /// width x height
+    pub size: [usize; 2],
+
+    /// 4 or 1
+    pub bytes_per_pixel: usize,
+
+    /// Free when this reaches zero.
+    pub retain_count: usize,
+}
+
+impl TextureMeta {
+    /// Size in bytes.
+    /// width x height x [`Self::bytes_per_pixel`].
+    pub fn bytes_used(&self) -> usize {
+        self.size[0] * self.size[1] * self.bytes_per_pixel
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// What has been allocated and freed during the last period.
+///
+/// These are commands given to the integration painter.
+#[derive(Clone, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[must_use = "The painter must take care of this"]
+pub struct TexturesDelta {
+    /// New or changed textures. Apply before painting.
+    pub set: AHashMap<TextureId, ImageDelta>,
+
+    /// Texture to free after painting.
+    pub free: Vec<TextureId>,
+}
+
+impl TexturesDelta {
+    pub fn append(&mut self, mut newer: TexturesDelta) {
+        self.set.extend(newer.set.into_iter());
+        self.free.append(&mut newer.free);
+    }
+}
diff --git a/epi/Cargo.toml b/epi/Cargo.toml
index 74fe92f4..a57ebe6e 100644
--- a/epi/Cargo.toml
+++ b/epi/Cargo.toml
@@ -23,14 +23,19 @@ all-features = true
 
 [lib]
 
+
+[features]
+default = []
+# Enable the file_storage module for storing data to disk.
+file_storage = ["directories-next", "ron", "serde"]
+# Persist native window options and egui memory
+persistence = ["ron", "serde", "egui/persistence"]
+
+
 [dependencies]
 egui = { version = "0.16.0", path = "../egui", default-features = false, features = ["single_threaded"] }
+tracing = "0.1"
 
 directories-next = { version = "2", optional = true }
 ron = { version = "0.7", optional = true }
 serde = { version = "1", optional = true }
-
-[features]
-default = []
-file_storage = ["directories-next", "ron", "serde"]
-persistence = ["ron", "serde"]
diff --git a/epi/src/file_storage.rs b/epi/src/file_storage.rs
index 9b0c0c52..140c6ceb 100644
--- a/epi/src/file_storage.rs
+++ b/epi/src/file_storage.rs
@@ -29,16 +29,17 @@ impl FileStorage {
         if let Some(proj_dirs) = directories_next::ProjectDirs::from("", "", app_name) {
             let data_dir = proj_dirs.data_dir().to_path_buf();
             if let Err(err) = std::fs::create_dir_all(&data_dir) {
-                eprintln!(
+                tracing::warn!(
                     "Saving disabled: Failed to create app path at {:?}: {}",
-                    data_dir, err
+                    data_dir,
+                    err
                 );
                 None
             } else {
                 Some(Self::from_ron_filepath(data_dir.join("app.ron")))
             }
         } else {
-            eprintln!("Saving disabled: Failed to find path to data_dir.");
+            tracing::warn!("Saving disabled: Failed to find path to data_dir.");
             None
         }
     }
@@ -79,7 +80,7 @@ where
             match ron::de::from_reader(reader) {
                 Ok(value) => Some(value),
                 Err(err) => {
-                    eprintln!("ERROR: Failed to parse RON: {}", err);
+                    tracing::warn!("Failed to parse RON: {}", err);
                     None
                 }
             }
diff --git a/epi/src/lib.rs b/epi/src/lib.rs
index b780b2eb..7d646cfd 100644
--- a/epi/src/lib.rs
+++ b/epi/src/lib.rs
@@ -106,11 +106,11 @@ pub trait App {
     ///
     /// Put your widgets into a [`egui::SidePanel`], [`egui::TopBottomPanel`], [`egui::CentralPanel`], [`egui::Window`] or [`egui::Area`].
     ///
-    /// The given [`egui::CtxRef`] is only valid for the duration of this call.
-    /// The [`Frame`] however can be cloned and saved.
+    /// The [`egui::Context`] and [`Frame`] can be cloned and saved if you like.
     ///
-    /// To force a repaint, call either [`egui::Context::request_repaint`] or [`Frame::request_repaint`].
-    fn update(&mut self, ctx: &egui::CtxRef, frame: &Frame);
+    /// To force a repaint, call either [`egui::Context::request_repaint`] during the call to `update`,
+    /// or call [`Frame::request_repaint`] at any time (e.g. from another thread).
+    fn update(&mut self, ctx: &egui::Context, frame: &Frame);
 
     /// Called once before the first frame.
     ///
@@ -118,18 +118,7 @@ pub trait App {
     /// [`egui::Context::set_visuals`] etc.
     ///
     /// Also allows you to restore state, if there is a storage (required the "persistence" feature).
-    fn setup(&mut self, _ctx: &egui::CtxRef, _frame: &Frame, _storage: Option<&dyn Storage>) {}
-
-    /// If `true` a warm-up call to [`Self::update`] will be issued where
-    /// `ctx.memory().everything_is_visible()` will be set to `true`.
-    ///
-    /// This will help pre-caching all text, preventing stutter when
-    /// opening a window containing new glyphs.
-    ///
-    /// In this warm-up call, all painted shapes will be ignored.
-    fn warm_up_enabled(&self) -> bool {
-        false
-    }
+    fn setup(&mut self, _ctx: &egui::Context, _frame: &Frame, _storage: Option<&dyn Storage>) {}
 
     /// Called on shutdown, and perhaps at regular intervals. Allows you to save state.
     ///
@@ -144,7 +133,20 @@ pub trait App {
     /// where `APPNAME` is what is returned by [`Self::name()`].
     fn save(&mut self, _storage: &mut dyn Storage) {}
 
-    /// Called once on shutdown (before or after [`Self::save`])
+    /// Called before an exit that can be aborted.
+    /// By returning `false` the exit will be aborted. To continue the exit return `true`.
+    ///
+    /// A scenario where this method will be run is after pressing the close button on a native
+    /// window, which allows you to ask the user whether they want to do something before exiting.
+    /// See the example `eframe/examples/confirm_exit.rs` for practical usage.
+    ///
+    /// It will _not_ be called on the web or when the window is forcefully closed.
+    fn on_exit_event(&mut self) -> bool {
+        true
+    }
+
+    /// Called once on shutdown (before or after [`Self::save`]). If you need to abort an exit use
+    /// [`Self::on_exit_event`]
     fn on_exit(&mut self) {}
 
     // ---------
@@ -179,17 +181,29 @@ pub trait App {
         egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).into()
     }
 
-    /// Controls wether or not the native window position and size will be
+    /// Controls whether or not the native window position and size will be
     /// persisted (only if the "persistence" feature is enabled).
     fn persist_native_window(&self) -> bool {
         true
     }
 
-    /// Controls wether or not the egui memory (window positions etc) will be
+    /// Controls whether or not the egui memory (window positions etc) will be
     /// persisted (only if the "persistence" feature is enabled).
     fn persist_egui_memory(&self) -> bool {
         true
     }
+
+    /// If `true` a warm-up call to [`Self::update`] will be issued where
+    /// `ctx.memory().everything_is_visible()` will be set to `true`.
+    ///
+    /// This can help pre-caching resources loaded by different parts of the UI, preventing stutter later on.
+    ///
+    /// In this warm-up call, all painted shapes will be ignored.
+    ///
+    /// The default is `false`, and it is unlikely you will want to change this.
+    fn warm_up_enabled(&self) -> bool {
+        false
+    }
 }
 
 /// Options controlling the behavior of a native window.
@@ -216,9 +230,18 @@ pub struct NativeOptions {
     /// The application icon, e.g. in the Windows task bar etc.
     pub icon_data: Option<IconData>,
 
-    /// The initial size of the native window in points (logical pixels).
+    /// The initial (inner) position of the native window in points (logical pixels).
+    pub initial_window_pos: Option<egui::Pos2>,
+
+    /// The initial inner size of the native window in points (logical pixels).
     pub initial_window_size: Option<egui::Vec2>,
 
+    /// The minimum inner window size
+    pub min_window_size: Option<egui::Vec2>,
+
+    /// The maximum inner window size
+    pub max_window_size: Option<egui::Vec2>,
+
     /// Should the app window be resizable?
     pub resizable: bool,
 
@@ -236,7 +259,10 @@ impl Default for NativeOptions {
             decorated: true,
             drag_and_drop_support: false,
             icon_data: None,
+            initial_window_pos: None,
             initial_window_size: None,
+            min_window_size: None,
+            max_window_size: None,
             resizable: true,
             transparent: false,
         }
@@ -272,7 +298,7 @@ impl Frame {
         Self(Arc::new(Mutex::new(frame_data)))
     }
 
-    /// Convenience to access the underlying `backend::FrameData`.
+    /// Access the underlying [`backend::FrameData`].
     #[doc(hidden)]
     #[inline]
     pub fn lock(&self) -> std::sync::MutexGuard<'_, backend::FrameData> {
@@ -328,31 +354,7 @@ impl Frame {
 
     /// for integrations only: call once per frame
     pub fn take_app_output(&self) -> crate::backend::AppOutput {
-        let mut lock = self.lock();
-        let next_id = lock.output.tex_allocation_data.next_id;
-        let app_output = std::mem::take(&mut lock.output);
-        lock.output.tex_allocation_data.next_id = next_id;
-        app_output
-    }
-
-    /// Allocate a texture. Free it again with [`Self::free_texture`].
-    pub fn alloc_texture(&self, image: Image) -> egui::TextureId {
-        self.lock().output.tex_allocation_data.alloc(image)
-    }
-
-    /// Free a texture that has been previously allocated with [`Self::alloc_texture`]. Idempotent.
-    pub fn free_texture(&self, id: egui::TextureId) {
-        self.lock().output.tex_allocation_data.free(id);
-    }
-}
-
-impl TextureAllocator for Frame {
-    fn alloc(&self, image: Image) -> egui::TextureId {
-        self.lock().output.tex_allocation_data.alloc(image)
-    }
-
-    fn free(&self, id: egui::TextureId) {
-        self.lock().output.tex_allocation_data.free(id);
+        std::mem::take(&mut self.lock().output)
     }
 }
 
@@ -386,41 +388,6 @@ pub struct IntegrationInfo {
     pub native_pixels_per_point: Option<f32>,
 }
 
-/// How to allocate textures (images) to use in [`egui`].
-pub trait TextureAllocator {
-    /// Allocate a new user texture.
-    ///
-    /// There is no way to change a texture.
-    /// Instead allocate a new texture and free the previous one with [`Self::free`].
-    fn alloc(&self, image: Image) -> egui::TextureId;
-
-    /// Free the given texture.
-    fn free(&self, id: egui::TextureId);
-}
-
-/// A 2D color image in RAM.
-#[derive(Clone, Default)]
-pub struct Image {
-    /// width, height
-    pub size: [usize; 2],
-    /// The pixels, row by row, from top to bottom.
-    pub pixels: Vec<egui::Color32>,
-}
-
-impl Image {
-    /// Create an `Image` from flat RGBA data.
-    /// Panics unless `size[0] * size[1] * 4 == rgba.len()`.
-    /// This is usually what you want to use after having loaded an image.
-    pub fn from_rgba_unmultiplied(size: [usize; 2], rgba: &[u8]) -> Self {
-        assert_eq!(size[0] * size[1] * 4, rgba.len());
-        let pixels = rgba
-            .chunks_exact(4)
-            .map(|p| egui::Color32::from_rgba_unmultiplied(p[0], p[1], p[2], p[3]))
-            .collect();
-        Self { size, pixels }
-    }
-}
-
 /// Abstraction for platform dependent texture reference
 pub trait NativeTexture {
     /// The native texture type.
@@ -482,8 +449,6 @@ pub const APP_KEY: &str = "app";
 
 /// You only need to look here if you are writing a backend for `epi`.
 pub mod backend {
-    use std::collections::HashMap;
-
     use super::*;
 
     /// How to signal the [`egui`] integration that a repaint is required.
@@ -498,49 +463,14 @@ pub mod backend {
     pub struct FrameData {
         /// Information about the integration.
         pub info: IntegrationInfo,
+
         /// Where the app can issue commands back to the integration.
         pub output: AppOutput,
+
         /// If you need to request a repaint from another thread, clone this and send it to that other thread.
         pub repaint_signal: std::sync::Arc<dyn RepaintSignal>,
     }
 
-    /// The data needed in order to allocate and free textures/images.
-    #[derive(Default)]
-    #[must_use]
-    pub struct TexAllocationData {
-        /// We allocate texture id linearly.
-        pub(crate) next_id: u64,
-        /// New creations this frame
-        pub creations: HashMap<u64, Image>,
-        /// destructions this frame.
-        pub destructions: Vec<u64>,
-    }
-
-    impl TexAllocationData {
-        /// Should only be used by integrations
-        pub fn take(&mut self) -> Self {
-            let next_id = self.next_id;
-            let ret = std::mem::take(self);
-            self.next_id = next_id;
-            ret
-        }
-
-        /// Allocate a new texture.
-        pub fn alloc(&mut self, image: Image) -> egui::TextureId {
-            let id = self.next_id;
-            self.next_id += 1;
-            self.creations.insert(id, image);
-            egui::TextureId::User(id)
-        }
-
-        /// Free an existing texture.
-        pub fn free(&mut self, id: egui::TextureId) {
-            if let egui::TextureId::User(id) = id {
-                self.destructions.push(id);
-            }
-        }
-    }
-
     /// Action that can be taken by the user app.
     #[derive(Default)]
     #[must_use]
@@ -560,8 +490,5 @@ pub mod backend {
 
         /// Set to true to drag window while primary mouse button is down.
         pub drag_window: bool,
-
-        /// A way to allocate textures (on integrations that support it).
-        pub tex_allocation_data: TexAllocationData,
     }
 }
diff --git a/sh/build_demo_web.sh b/sh/build_demo_web.sh
index cbbd88e0..27de09de 100755
--- a/sh/build_demo_web.sh
+++ b/sh/build_demo_web.sh
@@ -42,13 +42,14 @@ rm -f docs/${CRATE_NAME}_bg.wasm
 echo "Building rust…"
 BUILD=release
 
-cargo build \
-  -p ${CRATE_NAME} \
-  --release \
-  --lib \
-  --target wasm32-unknown-unknown \
-  --no-default-features \
-  --features ${FEATURES}
+(cd $CRATE_NAME &&
+  cargo build \
+    --release \
+    --lib \
+    --target wasm32-unknown-unknown \
+    --no-default-features \
+    --features ${FEATURES}
+)
 
 # Get the output directory (in the workspace it is in another location)
 TARGET=`cargo metadata --format-version=1 | jq --raw-output .target_directory`
diff --git a/sh/check.sh b/sh/check.sh
index a8225b6c..afcc1db2 100755
--- a/sh/check.sh
+++ b/sh/check.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env sh
 script_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
 cd "$script_path/.."
 set -eux
@@ -7,16 +7,17 @@ set -eux
 # Basically does what the CI does.
 
 cargo check --workspace --all-targets
-cargo test --workspace --doc
 cargo check --workspace --all-targets --all-features
 cargo check -p egui_demo_app --lib --target wasm32-unknown-unknown
 cargo check -p egui_demo_app --lib --target wasm32-unknown-unknown --all-features
 cargo clippy --workspace --all-targets --all-features --  -D warnings -W clippy::all
 cargo test --workspace --all-targets --all-features
+cargo test --workspace --doc # slow - checks all doc-tests
 cargo fmt --all -- --check
 
 cargo doc -p emath -p epaint -p egui -p eframe -p epi -p egui_web -p egui-winit -p egui_glium -p egui_glow --lib --no-deps --all-features
 cargo doc -p egui_web --target wasm32-unknown-unknown --lib --no-deps --all-features
+cargo doc --document-private-items --no-deps --all-features
 
 (cd emath && cargo check --no-default-features)
 (cd epaint && cargo check --no-default-features --features "single_threaded")
@@ -26,11 +27,26 @@ cargo doc -p egui_web --target wasm32-unknown-unknown --lib --no-deps --all-feat
 (cd egui && cargo check --no-default-features --features "multi_threaded,serialize")
 (cd eframe && cargo check --no-default-features --features "egui_glow")
 (cd epi && cargo check --no-default-features)
+(cd egui_demo_lib && cargo check --no-default-features)
 # (cd egui_web && cargo check --no-default-features) # we need to pick webgl or glow backend
 # (cd egui-winit && cargo check --no-default-features) # we don't pick singlethreaded or multithreaded
 (cd egui_glium && cargo check --no-default-features)
 (cd egui_glow && cargo check --no-default-features)
 
+
+(cd eframe && cargo check --all-features)
+(cd egui && cargo check --all-features)
+(cd egui_glium && cargo check --all-features)
+(cd egui_glow && cargo check --all-features)
+(cd egui_web && cargo check --all-features)
+# (cd egui-winit && cargo check --all-features) can't do, beacause of https://github.com/rust-lang/cargo/issues/8832
+(cd emath && cargo check --all-features)
+(cd epaint && cargo check --all-features)
+(cd epi && cargo check --all-features)
+
+# cargo install cargo-deny
+# cargo deny check
+
 # ------------------------------------------------------------
 #
 
@@ -38,7 +54,8 @@ cargo doc -p egui_web --target wasm32-unknown-unknown --lib --no-deps --all-feat
 # cargo bloat --release --bin demo_glium -n 200 | rg egui
 
 # what compiles slowly?
-# cargo clean; cargo +nightly build -p egui -Z timings
+# https://fasterthanli.me/articles/why-is-my-rust-build-so-slow
+# (cd egui_demo_app && cargo clean && RUSTC_BOOTSTRAP=1 cargo build --release --quiet -Z timings)
 
 # what compiles slowly?
 # cargo llvm-lines --lib -p egui | head -20