Draw the glyph atlas as an array texture and images with their own bind groups

The renderer bound every texture through one `binding_array<texture_2d<f32>>` indexed per primitive. That needs `VK_EXT_descriptor_indexing`, which a real share of Android GPUs do not have, so the shape did not run there at all. Split the two things being bound, since they want opposite treatment: - Glyph atlas pages become layers of one `texture_2d_array`. A glyph primitive carries a layer rather than a view/sampler index pair, and a layer index is an ordinary sampling operand -- no extension. Growing the atlas recreates the array with headroom and copies the old layers across GPU-side. - A standalone image gets its own texture and its own bind group, and draws in its own call. It no longer needs a per-instance entry in `PrimitiveData` at all: the bind group has already picked the texture. `Primitives` therefore keeps images in a list of their own, with `PrimitiveChange::is_image` saying which list a renumbering belongs to -- the two have independent index spaces, so `(layer, inst_idx)` alone would collide between them. Verified on this machine's real GPU (Venus onto an RX 7900 XT, confirmed by the loaded ICD rather than assumed): the `tabs` example renders byte-identical screenshots before and after, both for a text-and-rect tab and for one holding a standalone image.
Move text layout and rendering to Parley (#10 )
2026-09-13 03:58:12 -04:00 · 2026-09-13 03:39:23 -04:00
24 changed files with 2141 additions and 996 deletions
@@ -118,7 +118,7 @@ dependencies = [
 "clipboard-win",
 "image",
 "log",
- "objc2 0.6.3",
+ "objc2 0.6.4",
 "objc2-app-kit 0.3.2",
 "objc2-core-foundation",
 "objc2-core-graphics",
@@ -138,7 +138,7 @@ checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -318,7 +318,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -510,39 +510,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "core_maths"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
-dependencies = [
- "libm",
-]
-
-[[package]]
-name = "cosmic-text"
-version = "0.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cadaea21e24c49c0c82116f2b465ae6a49d63c90e428b0f8d9ae1f638ac91f"
-dependencies = [
- "bitflags 2.10.0",
- "fontdb",
- "harfrust",
- "linebender_resource_handle",
- "log",
- "rangemap",
- "rustc-hash",
- "self_cell",
- "skrifa 0.39.0",
- "smol_str",
- "swash",
- "sys-locale",
- "unicode-bidi",
- "unicode-linebreak",
- "unicode-script",
- "unicode-segmentation",
-]
-
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -602,7 +569,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
 dependencies = [
 "bitflags 2.10.0",
- "objc2 0.6.3",
+ "objc2 0.6.4",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
 ]

 [[package]]
@@ -658,7 +636,7 @@ checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -715,7 +693,7 @@ checksum = "a0aca10fb742cb43f9e7bb8467c91aa9bcb8e3ffbc6a6f7389bb93ffc920577d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -771,26 +749,34 @@ dependencies = [
 ]

 [[package]]
-name = "fontconfig-parser"
-version = "0.5.8"
+name = "font-types"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbc773e24e02d4ddd8395fd30dc147524273a83e54e0f312d986ea30de5f5646"
+checksum = "e64eb721ca85a34323425f4041adc5d82704d3782d5f8f03793bc012419dce23"
 dependencies = [
- "roxmltree",
+ "bytemuck",
 ]

 [[package]]
-name = "fontdb"
-version = "0.23.0"
+name = "fontique"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "457e789b3d1202543297a350643cf459f836cade38934e7a4cf6a39e7cde2905"
+checksum = "6688bc1294fe7117d788937b6c53480169b29c566954af490830d4c09da9516a"
 dependencies = [
- "fontconfig-parser",
- "log",
+ "hashbrown 0.17.1",
+ "linebender_resource_handle",
 "memmap2",
- "slotmap",
- "tinyvec",
- "ttf-parser",
+ "objc2 0.6.4",
+ "objc2-core-foundation",
+ "objc2-core-text",
+ "objc2-foundation 0.3.2",
+ "parlance",
+ "read-fonts 0.41.0",
+ "roxmltree",
+ "smallvec",
+ "windows",
+ "windows-core",
+ "yeslogic-fontconfig-sys",
 ]

 [[package]]
@@ -811,7 +797,7 @@ checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -941,14 +927,13 @@ dependencies = [

 [[package]]
 name = "harfrust"
-version = "0.4.1"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0caaee032384c10dd597af4579c67dee16650d862a9ccbe1233ff1a379abc07"
+checksum = "c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9"
 dependencies = [
 "bitflags 2.10.0",
 "bytemuck",
- "core_maths",
- "read-fonts 0.36.0",
+ "read-fonts 0.41.0",
 "smallvec",
 ]

@@ -972,6 +957,15 @@ dependencies = [
 "foldhash 0.2.0",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "foldhash 0.2.0",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -984,6 +978,134 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"

+[[package]]
+name = "icu_collections"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "serde",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_fallback"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"
+dependencies = [
+ "icu_locale_core",
+ "icu_locale_fallback_data",
+ "icu_provider",
+ "potential_utf",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_fallback_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"
+
+[[package]]
+name = "icu_normalizer"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
+
+[[package]]
+name = "icu_properties"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
+
+[[package]]
+name = "icu_provider"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "serde",
+ "stable_deref_trait",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_segmenter"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db"
+dependencies = [
+ "icu_collections",
+ "icu_locale_fallback",
+ "icu_provider",
+ "icu_segmenter_data",
+ "potential_utf",
+ "smallvec",
+ "utf8_iter",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_segmenter_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"
+
 [[package]]
 name = "image"
 version = "0.25.9"
@@ -1042,7 +1164,7 @@ checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -1050,13 +1172,12 @@ name = "iris"
 version = "0.1.0"
 dependencies = [
 "arboard",
- "cosmic-text",
 "image",
 "iris-core",
 "iris-macro",
+ "parley",
 "pollster",
 "tokio",
- "unicode-segmentation",
 "wgpu",
 "winit",
 ]
@@ -1066,9 +1187,11 @@ name = "iris-core"
 version = "0.1.0"
 dependencies = [
 "bytemuck",
- "cosmic-text",
 "fxhash",
 "image",
+ "log",
+ "parley",
+ "swash",
 "wgpu",
 ]

@@ -1078,7 +1201,7 @@ version = "0.1.0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -1216,6 +1339,12 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"

+[[package]]
+name = "litemap"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
+
 [[package]]
 name = "litrs"
 version = "1.0.0"
@@ -1273,9 +1402,9 @@ checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"

 [[package]]
 name = "memmap2"
-version = "0.9.9"
+version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
+checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0"
 dependencies = [
 "libc",
 ]
@@ -1410,7 +1539,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -1462,7 +1591,7 @@ dependencies = [
 "proc-macro-crate",
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -1492,9 +1621,9 @@ dependencies = [

 [[package]]
 name = "objc2"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7c2599ce0ec54857b29ce62166b0ed9b4f6f1a70ccc9a71165b6154caca8c05"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
 dependencies = [
 "objc2-encode",
 ]
@@ -1522,7 +1651,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
 dependencies = [
 "bitflags 2.10.0",
- "objc2 0.6.3",
+ "objc2 0.6.4",
 "objc2-core-graphics",
 "objc2-foundation 0.3.2",
 ]
@@ -1571,7 +1700,7 @@ checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
 "bitflags 2.10.0",
 "dispatch2",
- "objc2 0.6.3",
+ "objc2 0.6.4",
 ]

 [[package]]
@@ -1582,7 +1711,7 @@ checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
 dependencies = [
 "bitflags 2.10.0",
 "dispatch2",
- "objc2 0.6.3",
+ "objc2 0.6.4",
 "objc2-core-foundation",
 "objc2-io-surface",
 ]
@@ -1611,6 +1740,16 @@ dependencies = [
 "objc2-foundation 0.2.2",
 ]

+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.10.0",
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "objc2-encode"
 version = "4.1.0"
@@ -1637,7 +1776,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
 dependencies = [
 "bitflags 2.10.0",
- "objc2 0.6.3",
+ "objc2 0.6.4",
 "objc2-core-foundation",
 ]

@@ -1648,7 +1787,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
 dependencies = [
 "bitflags 2.10.0",
- "objc2 0.6.3",
+ "objc2 0.6.4",
 "objc2-core-foundation",
 ]

@@ -1746,9 +1885,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"

 [[package]]
 name = "orbclient"
@@ -1811,6 +1950,39 @@ dependencies = [
 "windows-link",
 ]

+[[package]]
+name = "parlance"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b6937eda350acc1a5d05872c3cbf99fe78619c269096e2be3d4a350058639d5"
+
+[[package]]
+name = "parley"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22d2ff88bd3f7d68d1d9b09c7e6209f9a8e8c05088295140a2bcf2e9b17038c5"
+dependencies = [
+ "fontique",
+ "harfrust",
+ "hashbrown 0.17.1",
+ "icu_normalizer",
+ "icu_properties",
+ "icu_segmenter",
+ "linebender_resource_handle",
+ "parlance",
+ "parley_data",
+ "skrifa 0.44.0",
+]
+
+[[package]]
+name = "parley_data"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1567535334d6ba2d3cde19221ba9a7bd0fabb3cbd99046ddfb10ae061cfcc889"
+dependencies = [
+ "icu_properties",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -1857,7 +2029,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -1920,6 +2092,17 @@ dependencies = [
 "portable-atomic",
 ]

+[[package]]
+name = "potential_utf"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
+dependencies = [
+ "serde_core",
+ "writeable",
+ "zerovec",
+]
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1969,7 +2152,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52717f9a02b6965224f95ca2a81e2e0c5c43baacd28ca057577988930b6c3d5b"
 dependencies = [
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -2007,9 +2190,9 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.42"
+version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
 dependencies = [
 "proc-macro2",
 ]
@@ -2055,12 +2238,6 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde"

-[[package]]
-name = "rangemap"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "973443cf09a9c8656b574a866ab68dfa19f0867d0340648c7d2f6a71b8a8ea68"
-
 [[package]]
 name = "rav1e"
 version = "0.8.1"
@@ -2137,16 +2314,6 @@ dependencies = [
 "crossbeam-utils",
 ]

-[[package]]
-name = "read-fonts"
-version = "0.35.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717cf23b488adf64b9d711329542ba34de147df262370221940dfabc2c91358"
-dependencies = [
- "bytemuck",
- "font-types",
-]
-
 [[package]]
 name = "read-fonts"
 version = "0.36.0"
@@ -2154,8 +2321,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5eaa2941a4c05443ee3a7b26ab076a553c343ad5995230cc2b1d3e993bdc6345"
 dependencies = [
 "bytemuck",
- "core_maths",
- "font-types",
+ "font-types 0.10.1",
+]
+
+[[package]]
+name = "read-fonts"
+version = "0.41.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
+dependencies = [
+ "bytemuck",
+ "font-types 0.12.4",
+ "once_cell",
 ]

 [[package]]
@@ -2199,9 +2376,12 @@ checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce"

 [[package]]
 name = "roxmltree"
-version = "0.20.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
+checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb"
+dependencies = [
+ "memchr",
+]

 [[package]]
 name = "rustc-hash"
@@ -2275,12 +2455,6 @@ dependencies = [
 "tiny-skia",
 ]

-[[package]]
-name = "self_cell"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b12e76d157a900eb52e81bc6e9f3069344290341720e9178cde2407113ac8d89"
-
 [[package]]
 name = "serde"
 version = "1.0.228"
@@ -2308,7 +2482,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -2332,16 +2506,6 @@ dependencies = [
 "quote",
 ]

-[[package]]
-name = "skrifa"
-version = "0.37.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c31071dedf532758ecf3fed987cdb4bd9509f900e026ab684b4ecb81ea49841"
-dependencies = [
- "bytemuck",
- "read-fonts 0.35.0",
-]
-
 [[package]]
 name = "skrifa"
 version = "0.39.0"
@@ -2352,6 +2516,16 @@ dependencies = [
 "read-fonts 0.36.0",
 ]

+[[package]]
+name = "skrifa"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68"
+dependencies = [
+ "bytemuck",
+ "read-fonts 0.41.0",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.11"
@@ -2436,11 +2610,11 @@ checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"

 [[package]]
 name = "swash"
-version = "0.2.6"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47846491253e976bdd07d0f9cc24b7daf24720d11309302ccbbc6e6b6e53550a"
+checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e"
 dependencies = [
- "skrifa 0.37.0",
+ "skrifa 0.39.0",
 "yazi",
 "zeno",
 ]
@@ -2457,12 +2631,25 @@ dependencies = [
 ]

 [[package]]
-name = "sys-locale"
-version = "0.3.2"
+name = "syn"
+version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
 dependencies = [
- "libc",
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -2500,7 +2687,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -2511,7 +2698,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -2554,20 +2741,16 @@ dependencies = [
 ]

 [[package]]
-name = "tinyvec"
-version = "1.10.0"
+name = "tinystr"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
 dependencies = [
- "tinyvec_macros",
+ "displaydoc",
+ "serde_core",
+ "zerovec",
 ]

-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
 [[package]]
 name = "tokio"
 version = "1.49.0"
@@ -2639,15 +2822,6 @@ name = "ttf-parser"
 version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
-dependencies = [
- "core_maths",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"

 [[package]]
 name = "unicode-ident"
@@ -2655,18 +2829,6 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"

-[[package]]
-name = "unicode-linebreak"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
-
-[[package]]
-name = "unicode-script"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee"
-
 [[package]]
 name = "unicode-segmentation"
 version = "1.12.0"
@@ -2679,6 +2841,12 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"

+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "v_frame"
 version = "0.3.9"
@@ -2760,7 +2928,7 @@ dependencies = [
 "bumpalo",
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 "wasm-bindgen-shared",
 ]

@@ -3120,7 +3288,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -3131,7 +3299,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
 ]

 [[package]]
@@ -3493,6 +3661,12 @@ dependencies = [
 "wayland-protocols-wlr",
 ]

+[[package]]
+name = "writeable"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
+
 [[package]]
 name = "x11-dl"
 version = "2.21.0"
@@ -3568,6 +3742,40 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5"

+[[package]]
+name = "yeslogic-fontconfig-sys"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d8b8abf912b9a29ff112e1671c97c33636903d13a69712037190e6805af4f76"
+dependencies = [
+ "dlib",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.113",
+ "synstructure",
+]
+
 [[package]]
 name = "zeno"
 version = "0.3.3"
@@ -3591,7 +3799,63 @@ checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn",
+ "syn 2.0.113",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.113",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
+dependencies = [
+ "serde",
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
 ]

 [[package]]
@@ -8,8 +8,7 @@ edition.workspace = true
 [dependencies]
 iris-core = { workspace = true }
 iris-macro = { workspace = true }
-cosmic-text = { workspace = true }
-unicode-segmentation = { workspace = true }
+parley = { workspace = true }
 winit = { workspace = true }
 arboard = { workspace = true, features = ["wayland-data-control"] }
 pollster = { workspace = true }
@@ -33,9 +32,10 @@ winit = "0.30.12"
 wgpu = "28.0.0"
 bytemuck = "1.23.1"
 image = "0.25.6"
-cosmic-text = "0.16.0"
-unicode-segmentation = "1.12.0"
+parley = "0.11.1"
+swash = "0.2.10"
 fxhash = "0.2.1"
+log = "0.4.29"
 arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }
@@ -1,19 +1,6 @@
 images
    settings (sampler)
-
-text
-    figure out ways to speed up / what costs the most
-    resizing (per frame) is really slow (assuming painter isn't griefing)
-    j is weird / fix x offset
-
-masks r just made to bare minimum work
-
-scaling
-    could be just a simple scaling factor that multiplies abs
-    and need to ensure text uses raw abs and not scaled abs
-    naming? (pt, px)
-    want to keep (drawn) regions using px? or should I add another field to UiScalar/Vec
-    field could be best solution so redrawing stuff isn't needed & you can specify both as user
+    consider typed TextureHandle<T> variants for distinct texture uses

 WidgetRef<W> or smth instead of Id
    enum that's either an Id or an actual concrete instance of W
@@ -24,17 +11,6 @@ WidgetRef<W> or smth instead of Id
    maybe introduce InnerWidget trait to allow for editors to expose & modify inner type
    maybe could also store a parent widget and keep using InnerWidget trait? unsure if possible

-really weird limitation:
-    I don't think you can currently remove an element from a parent and put it in a child of the same parent
-    because it removes the unused children after the entire parent redraw
-    but the child gets drawn during that, so it will think the child is still active !!!
-    or something like that idk, maybe I need a special enum for parent that includes a undecided state where it may or may not get redrawn by the parent
-    or just do ref counting and ensure all drawn things == 1 afterwards (seems like best way)
-    ok so I'm removing the limit for now
-
-don't forget I'm streaming
-
-tags
 vecs for each widget type?

 POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??
@@ -7,5 +7,7 @@ edition.workspace = true
 wgpu = { workspace = true }
 bytemuck ={ workspace = true }
 image = { workspace = true }
-cosmic-text = { workspace = true }
+parley = { workspace = true }
+swash = { workspace = true }
 fxhash = { workspace = true }
+log = { workspace = true }
@@ -5,7 +5,6 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
 #![feature(const_destruct)]
-#![feature(portable_simd)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(coerce_unsized)]
@@ -10,6 +10,12 @@ pub struct Color<T> {
    pub a: T,
 }

+impl<T: ColorNum> Default for Color<T> {
+    fn default() -> Self {
+        Self::BLACK
+    }
+}
+
 impl<T: ColorNum> Color<T> {
    pub const BLACK: Self = Self::rgb(T::MIN, T::MIN, T::MIN);
    pub const WHITE: Self = Self::rgb(T::MAX, T::MAX, T::MAX);
@@ -1,6 +1,7 @@
 use std::ops::{Index, IndexMut};

 use crate::{
+    UiRegion, WidgetId,
    render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives},
    util::to_mut,
 };
@@ -131,6 +132,17 @@ impl PrimitiveLayers {
    pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
        self[h.layer].free(h)
    }
+
+    pub fn write_image(
+        &mut self,
+        layer: LayerId,
+        id: WidgetId,
+        texture_idx: u32,
+        region: UiRegion,
+        mask_idx: MaskIdx,
+    ) -> PrimitiveHandle {
+        self[layer].write_image(layer, id, texture_idx, region, mask_idx)
+    }
 }

 impl<T: Default> Default for Layers<T> {
@@ -1,60 +1,67 @@
-use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2};
-use cosmic_text::{
-    Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
-    SwashContent,
+use crate::{
+    Align, GlyphAtlas, GlyphEntry, GlyphKey, PlacedGlyph, RegionAlign, Textures, UiColor,
+    util::Vec2,
+};
+use parley::{
+    Alignment, AlignmentOptions, FontContext, FontFamily, FontFamilyName, GenericFamily, Layout,
+    LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty,
+};
+use std::hash::{DefaultHasher, Hash, Hasher};
+use swash::{
+    FontRef,
+    scale::{Render, ScaleContext, Source, StrikeWith},
+    zeno::{Format, Vector},
 };
-use image::{DynamicImage, GenericImageView, RgbaImage};
-use std::simd::{Simd, num::SimdUint};
-
-/// TODO: properly wrap this
-pub mod text_lib {
-    pub use cosmic_text::*;
-}

 pub struct TextData {
-    pub font_system: FontSystem,
-    pub swash_cache: SwashCache,
-    glyph_cache: Vec<(Placement, CacheKey, Color)>,
+    pub font_ctx: FontContext,
+    pub layout_ctx: LayoutContext<UiColor>,
+    scale_ctx: ScaleContext,
+    pub atlas: GlyphAtlas,
 }

 impl Default for TextData {
    fn default() -> Self {
        Self {
-            font_system: FontSystem::new(),
-            swash_cache: SwashCache::new(),
-            glyph_cache: Default::default(),
+            font_ctx: FontContext::new(),
+            layout_ctx: LayoutContext::new(),
+            scale_ctx: ScaleContext::new(),
+            atlas: GlyphAtlas::default(),
        }
    }
 }

-#[derive(Clone, Copy)]
+#[derive(Clone, PartialEq)]
+pub enum Family {
+    SansSerif,
+    Serif,
+    Monospace,
+    Named(String),
+}
+
+impl Family {
+    fn family(&self) -> FontFamily<'_> {
+        let name = match self {
+            Self::SansSerif => FontFamilyName::Generic(GenericFamily::SansSerif),
+            Self::Serif => FontFamilyName::Generic(GenericFamily::Serif),
+            Self::Monospace => FontFamilyName::Generic(GenericFamily::Monospace),
+            Self::Named(name) => FontFamilyName::Named(name.as_str().into()),
+        };
+        FontFamily::Single(name)
+    }
+}
+
+#[derive(Clone, PartialEq)]
 pub struct TextAttrs {
    pub color: UiColor,
    pub font_size: f32,
    pub line_height: f32,
-    pub family: Family<'static>,
+    pub family: Family,
    pub wrap: bool,
-    /// inner alignment of text region (within where it's drawn)
    pub align: RegionAlign,
 }

-impl TextAttrs {
-    pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option<f32>) {
-        buf.set_metrics_and_size(
-            font_system,
-            Metrics::new(self.font_size, self.line_height),
-            width,
-            None,
-        );
-        let attrs = Attrs::new().family(self.family);
-        let list = AttrsList::new(&attrs);
-        for line in &mut buf.lines {
-            line.set_attrs_list(list.clone());
-        }
-    }
-}
-
-pub type TextBuffer = Buffer;
+pub const LINE_HEIGHT_MULT: f32 = 1.1;

 impl Default for TextAttrs {
    fn default() -> Self {
@@ -70,122 +77,215 @@ impl Default for TextAttrs {
    }
 }

-pub const LINE_HEIGHT_MULT: f32 = 1.1;
+/// Keeps text and its corresponding layout from getting out of sync.
+pub struct TextBuffer {
+    text: String,
+    layout: Layout<UiColor>,
+    layout_key: Option<LayoutKey>,
+}
+
+#[derive(PartialEq)]
+struct LayoutKey {
+    attrs: TextAttrs,
+    max_width: Option<f32>,
+}
+
+impl TextBuffer {
+    pub fn new(text: impl Into<String>) -> Self {
+        Self {
+            text: text.into(),
+            layout: Layout::new(),
+            layout_key: None,
+        }
+    }
+
+    pub fn new_empty() -> Self {
+        Self::new("")
+    }
+
+    pub fn text(&self) -> &str {
+        &self.text
+    }
+
+    pub fn layout(&self) -> &Layout<UiColor> {
+        &self.layout
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.text.is_empty()
+    }
+
+    pub fn set_text(&mut self, text: impl Into<String>) {
+        let text = text.into();
+        if text != self.text {
+            self.text = text;
+            self.layout_key = None;
+        }
+    }
+
+    /// Invalidates the layout and returns the underlying string for editing.
+    pub fn edit(&mut self) -> &mut String {
+        self.layout_key = None;
+        &mut self.text
+    }
+
+    pub fn size(&self) -> Vec2 {
+        Vec2::new(self.layout.width(), self.layout.height())
+    }
+
+    pub fn shape(&mut self, data: &mut TextData, attrs: &TextAttrs, width: Option<f32>) {
+        let layout_key = LayoutKey {
+            attrs: attrs.clone(),
+            max_width: width,
+        };
+        if self.layout_key.as_ref() == Some(&layout_key) {
+            return;
+        }
+        let mut builder = data
+            .layout_ctx
+            .ranged_builder(&mut data.font_ctx, &self.text, 1.0, true);
+        builder.push_default(StyleProperty::FontFamily(attrs.family.family()));
+        builder.push_default(StyleProperty::FontSize(attrs.font_size));
+        builder.push_default(StyleProperty::LineHeight(LineHeight::Absolute(
+            attrs.line_height,
+        )));
+        builder.push_default(StyleProperty::Brush(attrs.color));
+        builder.build_into(&mut self.layout, &self.text);
+        self.layout.break_all_lines(width);
+        self.layout
+            .align(Alignment::Start, AlignmentOptions::default());
+        self.layout_key = Some(layout_key);
+    }
+}

 impl TextData {
-    pub fn draw(
+    pub fn place(&mut self, buffer: &TextBuffer, textures: &mut Textures) -> Vec<PlacedGlyph> {
+        let mut placed = Vec::new();
+        for line in buffer.layout.lines() {
+            for item in line.items() {
+                let PositionedLayoutItem::GlyphRun(run) = item else {
+                    continue;
+                };
+                let font = run.run().font();
+                let font_size = run.run().font_size();
+                let coords = run.run().normalized_coords();
+                let Some(font_ref) = FontRef::from_index(font.data.as_ref(), font.index as usize)
+                else {
+                    continue;
+                };
+                let coords_hash = hash_coords(coords);
+                let font_id = font.data.id();
+
+                for glyph in run.positioned_glyphs() {
+                    let subpixel = ((glyph.x.fract() * 4.0).round() as i32).rem_euclid(4) as u8;
+                    let key = GlyphKey {
+                        font: font_id,
+                        glyph: glyph.id,
+                        size: glyph_size_key(font_size),
+                        subpixel,
+                        coords: coords_hash,
+                    };
+                    let Some(entry) = self.glyph_entry(
+                        GlyphRaster {
+                            key,
+                            font: font_ref,
+                            font_size,
+                            coords,
+                            subpixel,
+                            glyph_id: glyph.id,
+                        },
+                        textures,
+                    ) else {
+                        continue;
+                    };
+                    placed.push(PlacedGlyph {
+                        entry,
+                        offset: Vec2::new(
+                            glyph.x.floor() + entry.left as f32,
+                            glyph.y.floor() - entry.top as f32,
+                        ),
+                    });
+                }
+            }
+        }
+        placed
+    }
+
+    fn glyph_entry(
+        &mut self,
+        glyph: GlyphRaster<'_>,
+        textures: &mut Textures,
+    ) -> Option<GlyphEntry> {
+        if let Some(entry) = self.atlas.get(&glyph.key) {
+            return entry;
+        }
+
+        let mut scaler = self
+            .scale_ctx
+            .builder(glyph.font)
+            .size(glyph.font_size)
+            .hint(true)
+            .normalized_coords(glyph.coords)
+            .build();
+        let image = Render::new(&[
+            Source::ColorOutline(0),
+            Source::ColorBitmap(StrikeWith::BestFit),
+            Source::Outline,
+        ])
+        .format(Format::Alpha)
+        .offset(Vector::new(glyph.subpixel as f32 / 4.0, 0.0))
+        .render(&mut scaler, glyph.glyph_id as u16);
+
+        if let Some(image) = image {
+            self.atlas.insert(glyph.key, &image, textures)
+        } else {
+            self.atlas.insert_empty(glyph.key);
+            None
+        }
+    }
+}
+
+struct GlyphRaster<'a> {
+    key: GlyphKey,
+    font: FontRef<'a>,
+    font_size: f32,
+    coords: &'a [i16],
+    subpixel: u8,
+    glyph_id: u32,
+}
+
+fn hash_coords(coords: &[i16]) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    coords.hash(&mut hasher);
+    hasher.finish()
+}
+
+const GLYPH_SIZE_STEPS_PER_PIXEL: f32 = 16.0;
+
+fn glyph_size_key(font_size: f32) -> u32 {
+    (font_size * GLYPH_SIZE_STEPS_PER_PIXEL).round() as u32
+}
+
+pub struct RenderedText {
+    pub glyphs: Vec<PlacedGlyph>,
+    pub size: Vec2,
+    pub color: UiColor,
+}
+
+impl TextData {
+    pub fn render(
        &mut self,
        buffer: &mut TextBuffer,
        attrs: &TextAttrs,
+        width: Option<f32>,
        textures: &mut Textures,
    ) -> RenderedText {
-        // TODO: either this or the layout stuff (or both) is super slow,
-        // should probably do texture packing and things if possible.
-        // very visible if you add just a couple of wrapping texts and resize window
-        // should also be timed to figure out exactly what points need to be sped up
-        // let mut pixels = HashMap::<_, [u8; 4]>::default();
-        let mut min_x = 0;
-        let mut min_y = 0;
-        let mut max_x = 0;
-        let mut max_y = 0;
-        let text_color = {
-            let c = attrs.color;
-            cosmic_text::Color::rgba(c.r, c.g, c.b, c.a)
-        };
-        let mut max_width = 0.0f32;
-        let mut height = 0.0;
-
-        for run in buffer.layout_runs() {
-            for glyph in run.glyphs.iter() {
-                let physical_glyph = glyph.physical((0., 0.), 1.0);
-
-                let glyph_color = match glyph.color_opt {
-                    Some(some) => some,
-                    None => text_color,
-                };
-
-                if let Some(img) = self
-                    .swash_cache
-                    .get_image(&mut self.font_system, physical_glyph.cache_key)
-                {
-                    let mut pos = img.placement;
-                    pos.left += physical_glyph.x;
-                    pos.top = physical_glyph.y + run.line_y as i32 - pos.top;
-                    min_x = min_x.min(pos.left);
-                    min_y = min_y.min(pos.top);
-                    max_x = max_x.max(pos.left + pos.width as i32);
-                    max_y = max_y.max(pos.top + pos.height as i32);
-                    self.glyph_cache
-                        .push((pos, physical_glyph.cache_key, glyph_color));
-                }
-            }
-            max_width = max_width.max(run.line_w);
-            height += run.line_height;
-        }
-        let img_width = (max_x - min_x + 1) as u32;
-        let img_height = (max_y - min_y + 1) as u32;
-        let mut image = RgbaImage::new(img_width, img_height);
-
-        for (pos, key, color) in self.glyph_cache.drain(..) {
-            let img = self
-                .swash_cache
-                .get_image(&mut self.font_system, key)
-                .as_ref()
-                .unwrap();
-            let mut merge = |i, color: [u8; 4]| {
-                let i = i as i32;
-                let x = (i % pos.width as i32 + pos.left - min_x) as u32;
-                let y = (i / pos.width as i32 + pos.top - min_y) as u32;
-                let pixel = &mut image[(x, y)].0;
-                // TODO: no clue if proper alpha blending should be done
-                *pixel = Simd::from(color).saturating_add(Simd::from(*pixel)).into();
-            };
-
-            match img.content {
-                SwashContent::Mask => {
-                    for (i, a) in img.data.iter().enumerate() {
-                        let mut color = color.as_rgba();
-                        color[3] = ((color[3] as u32 * *a as u32) / u8::MAX as u32) as u8;
-                        merge(i, color);
-                    }
-                }
-                SwashContent::SubpixelMask => todo!("subpixel mask text rendering"),
-                SwashContent::Color => {
-                    let (colors, _) = img.data.as_chunks::<4>();
-                    for (i, color) in colors.iter().enumerate() {
-                        merge(i, *color);
-                    }
-                }
-            }
-        }
-
-        let max_dim = 8192;
-        if image.width() > max_dim || image.height() > max_dim {
-            let width = image.width().min(max_dim);
-            let height = image.height().min(max_dim);
-            eprintln!(
-                "WARNING: image of size {:?} cropped to {:?} (texture too big)",
-                image.dimensions(),
-                (width, height)
-            );
-            image = image.view(0, 0, width, height).to_image();
-        }
-
+        buffer.shape(self, attrs, width);
+        let glyphs = self.place(buffer, textures);
        RenderedText {
-            handle: textures.add(image),
-            top_left_offset: Vec2::new(min_x as f32, min_y as f32),
-            size: Vec2::new(max_width, height),
+            glyphs,
+            size: buffer.size(),
+            color: attrs.color,
        }
    }
 }
-
-#[derive(Clone)]
-pub struct RenderedText {
-    pub handle: TextureHandle,
-    pub top_left_offset: Vec2,
-    pub size: Vec2,
-}
-
-pub trait HasTextures {
-    fn add_texture(&mut self, image: DynamicImage) -> TextureHandle;
-}
@@ -1,19 +1,32 @@
-use crate::{
-    render::TexturePrimitive,
-    util::{RefCounter, Vec2},
-};
+use crate::util::{RefCounter, Vec2};
 use image::{DynamicImage, GenericImageView};
 use std::{
    ops::Index,
    sync::mpsc::{Receiver, Sender, channel},
 };

+/// Which of the two things a texture slot holds. The two are drawn very
+/// differently: a page is a layer of one shared array texture and never gets
+/// its own bind group; a standalone image is the opposite, one texture and
+/// one bind group, never a layer.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TextureKind {
+    Image,
+    /// The array-texture layer this page was assigned. Chosen synchronously
+    /// by `Textures::add_page` rather than by the renderer, because glyph
+    /// insertion needs it in the same call, before any GPU sync happens.
+    Page {
+        layer: u32,
+    },
+}
+
 #[derive(Debug, Clone)]
 pub struct TextureHandle {
-    inner: TexturePrimitive,
+    slot: u32,
+    kind: TextureKind,
    size: Vec2,
    counter: RefCounter,
-    send: Sender<u32>,
+    send: Sender<(TextureKind, u32)>,
 }

 /// a texture manager for a ui
@@ -21,22 +34,39 @@ pub struct TextureHandle {
 pub struct Textures {
    free: Vec<u32>,
    images: Vec<Option<DynamicImage>>,
+    /// Next layer to hand out to an atlas page. Pages are never freed (no
+    /// atlas eviction), so this only grows and `free` never holds one.
+    next_page_layer: u32,
    updates: Vec<Update>,
-    send: Sender<u32>,
-    recv: Receiver<u32>,
+    send: Sender<(TextureKind, u32)>,
+    recv: Receiver<(TextureKind, u32)>,
 }

 pub enum TextureUpdate<'a> {
-    Push(&'a DynamicImage),
-    Set(u32, &'a DynamicImage),
+    Push(TextureKind, &'a DynamicImage),
+    Set(TextureKind, u32, &'a DynamicImage),
+    /// Overwrite a rectangle of an existing texture, rather than replacing it.
+    /// The glyph atlas grows a glyph at a time, and re-uploading a whole atlas
+    /// per glyph is megabytes of copy for a few hundred bytes of change.
+    /// Only ever issued against a page -- a standalone image is never patched.
+    Patch(u32, PatchRect, &'a DynamicImage),
    Free(u32),
-    PushFree,
+    PushFree(TextureKind),
    SetFree,
 }

+#[derive(Debug, Clone, Copy)]
+pub struct PatchRect {
+    pub x: u32,
+    pub y: u32,
+    pub width: u32,
+    pub height: u32,
+}
+
 enum Update {
-    Push(u32),
-    Set(u32),
+    Push(TextureKind, u32),
+    Set(TextureKind, u32),
+    Patch(u32, PatchRect),
    Free(u32),
 }

@@ -46,58 +76,97 @@ impl Textures {
        Self {
            free: Vec::new(),
            images: Vec::new(),
+            next_page_layer: 0,
            updates: Vec::new(),
            send,
            recv,
        }
    }
+
    pub fn add(&mut self, image: impl Into<DynamicImage>) -> TextureHandle {
        let image = image.into();
        let size = image.dimensions().into();
-        let view_idx = self.push(image);
-        // 0 == default in renderer; TODO: actually create samplers here
-        let sampler_idx = 0;
+        let kind = TextureKind::Image;
+        let slot = self.push(kind, image);
        TextureHandle {
-            inner: TexturePrimitive {
-                view_idx,
-                sampler_idx,
-            },
+            slot,
+            kind,
            size,
            counter: RefCounter::new(),
            send: self.send.clone(),
        }
    }

-    fn push(&mut self, image: DynamicImage) -> u32 {
+    /// Adds a page of the shared glyph atlas array. Only `atlas.rs` should
+    /// call this -- everything else wants `add`.
+    pub fn add_page(&mut self, image: impl Into<DynamicImage>) -> TextureHandle {
+        let image = image.into();
+        let size = image.dimensions().into();
+        let layer = self.next_page_layer;
+        self.next_page_layer += 1;
+        let kind = TextureKind::Page { layer };
+        let slot = self.push(kind, image);
+        TextureHandle {
+            slot,
+            kind,
+            size,
+            counter: RefCounter::new(),
+            send: self.send.clone(),
+        }
+    }
+
+    fn push(&mut self, kind: TextureKind, image: DynamicImage) -> u32 {
        if let Some(i) = self.free.pop() {
            self.images[i as usize] = Some(image);
-            self.updates.push(Update::Set(i));
+            self.updates.push(Update::Set(kind, i));
            i
        } else {
            let i = self.images.len() as u32;
            self.images.push(Some(image));
-            self.updates.push(Update::Push(i));
+            self.updates.push(Update::Push(kind, i));
            i
        }
    }

+    pub fn image_mut(&mut self, handle: &TextureHandle) -> &mut DynamicImage {
+        self.images[handle.slot as usize]
+            .as_mut()
+            .expect("texture was freed while still held")
+    }
+
+    /// Queue an upload of just `rect`, after writing it with `image_mut`.
+    pub fn patch(&mut self, handle: &TextureHandle, rect: PatchRect) {
+        self.updates.push(Update::Patch(handle.slot, rect));
+    }
+
    pub fn free(&mut self) {
-        for idx in self.recv.try_iter() {
+        for (kind, idx) in self.recv.try_iter() {
            self.images[idx as usize] = None;
            self.updates.push(Update::Free(idx));
+            // A page's slot is never reclaimed: `GlyphAtlas` never drops the
+            // handles it holds, and there is no eviction path for a hole in
+            // the middle of the array's layers. So `free` holds ordinary
+            // image slots only, and a page's layer would need a free list of
+            // its own were that to change.
+            if kind == TextureKind::Image {
                self.free.push(idx);
            }
        }
+    }

    pub fn updates(&mut self) -> impl Iterator<Item = TextureUpdate<'_>> {
        self.updates.drain(..).map(|u| match u {
-            Update::Push(i) => self.images[i as usize]
+            Update::Push(kind, i) => self.images[i as usize]
                .as_ref()
-                .map(TextureUpdate::Push)
-                .unwrap_or(TextureUpdate::PushFree),
-            Update::Set(i) => self.images[i as usize]
+                .map(|img| TextureUpdate::Push(kind, img))
+                .unwrap_or(TextureUpdate::PushFree(kind)),
+            Update::Set(kind, i) => self.images[i as usize]
                .as_ref()
-                .map(|img| TextureUpdate::Set(i, img))
+                .map(|img| TextureUpdate::Set(kind, i, img))
+                .unwrap_or(TextureUpdate::SetFree),
+            Update::Patch(i, rect) => self.images[i as usize]
+                .as_ref()
+                .map(|img| TextureUpdate::Patch(i, rect, img))
                .unwrap_or(TextureUpdate::SetFree),
            Update::Free(i) => TextureUpdate::Free(i),
        })
@@ -105,18 +174,36 @@ impl Textures {
 }

 impl TextureHandle {
-    pub fn primitive(&self) -> TexturePrimitive {
-        self.inner
-    }
    pub fn size(&self) -> Vec2 {
        self.size
    }
+
+    /// The bind-group index this handle draws with. Only valid for a
+    /// standalone image; an atlas page has no bind group of its own -- it
+    /// samples the shared array via `layer()` instead. Getting this wrong is
+    /// a caller bug (the wrong kind of handle reached the wrong draw path),
+    /// not a recoverable condition, so it panics rather than drawing garbage.
+    pub fn image_index(&self) -> u32 {
+        match self.kind {
+            TextureKind::Image => self.slot,
+            TextureKind::Page { .. } => panic!("image_index() called on an atlas page handle"),
+        }
+    }
+
+    /// The layer this page occupies in the shared atlas array texture.
+    /// Only valid for a page handle; see `image_index`'s note.
+    pub fn layer(&self) -> u32 {
+        match self.kind {
+            TextureKind::Page { layer } => layer,
+            TextureKind::Image => panic!("layer() called on a standalone image handle"),
+        }
+    }
 }

 impl Drop for TextureHandle {
    fn drop(&mut self) {
        if self.counter.drop() {
-            let _ = self.send.send(self.inner.view_idx);
+            let _ = self.send.send((self.kind, self.slot));
        }
    }
 }
@@ -125,7 +212,7 @@ impl Index<&TextureHandle> for Textures {
    type Output = DynamicImage;

    fn index(&self, index: &TextureHandle) -> &Self::Output {
-        self.images[index.inner.view_idx as usize].as_ref().unwrap()
+        self.images[index.slot as usize].as_ref().unwrap()
    }
 }

@@ -0,0 +1,236 @@
+use crate::{
+    PatchRect, TextureHandle, Textures,
+    util::{HashMap, Vec2},
+};
+use image::RgbaImage;
+use swash::scale::image::{Content, Image};
+
+/// Side of one atlas page, in pixels. 1024 is 4 MB at RGBA8 -- enough for a
+/// few thousand glyphs at UI sizes, and small enough that a page nobody fills
+/// is not a big waste. Also the fixed width/height of every layer of the
+/// shared array texture in `render::texture` -- `pub(crate)` so that module
+/// can size it without a second constant to keep in sync.
+pub(crate) const PAGE: u32 = 1024;
+
+/// Transparent margin kept around every glyph, so that sampling one cannot
+/// pick up its neighbour along a shared edge.
+const PAD: u32 = 1;
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GlyphKey {
+    pub font: u64,
+    pub glyph: u32,
+    /// Font size in 1/16 px, so sizes that round to the same pixels share a
+    /// raster instead of filling the atlas with near-duplicates.
+    pub size: u32,
+    /// Horizontal subpixel phase, in 1/4 px.
+    pub subpixel: u8,
+    /// Hash of the variation coordinates; a variable font at two weights is two
+    /// different sets of pixels from one glyph id.
+    pub coords: u64,
+}
+
+#[derive(Clone, Copy)]
+pub struct GlyphEntry {
+    pub uv_min: Vec2,
+    pub uv_max: Vec2,
+    /// Offset from the glyph's pen position to the top-left of its pixels.
+    pub left: i32,
+    pub top: i32,
+    pub width: u32,
+    pub height: u32,
+    pub is_colored: bool,
+    /// The atlas array layer this glyph's page occupies.
+    pub layer: u32,
+}
+
+impl GlyphEntry {
+    const IS_COLORED: u32 = 1;
+
+    pub(crate) fn flags(&self) -> u32 {
+        if self.is_colored { Self::IS_COLORED } else { 0 }
+    }
+}
+
+struct Page {
+    handle: TextureHandle,
+    x: u32,
+    y: u32,
+    shelf_height: u32,
+}
+
+#[derive(Default)]
+pub struct GlyphAtlas {
+    pages: Vec<Page>,
+    /// `None` for a glyph that rasterised to nothing -- a space, say. Cached
+    /// too, so it is not re-rasterised on every layout.
+    entries: HashMap<GlyphKey, Option<GlyphEntry>>,
+}
+
+impl GlyphAtlas {
+    pub fn get(&self, key: &GlyphKey) -> Option<Option<GlyphEntry>> {
+        self.entries.get(key).copied()
+    }
+
+    pub fn insert(
+        &mut self,
+        key: GlyphKey,
+        image: &Image,
+        textures: &mut Textures,
+    ) -> Option<GlyphEntry> {
+        let w = image.placement.width;
+        let h = image.placement.height;
+        if w == 0 || h == 0 {
+            log::warn!(
+                "glyph {} in font {} rasterized at {w}x{h}; skipping it",
+                key.glyph,
+                key.font,
+            );
+            self.entries.insert(key, None);
+            return None;
+        }
+        if w > PAGE - PAD * 2 || h > PAGE - PAD * 2 {
+            log::warn!(
+                "glyph {} in font {} rasterized at {w}x{h}, too large for the {PAGE}x{PAGE} atlas; skipping it",
+                key.glyph,
+                key.font,
+            );
+            self.entries.insert(key, None);
+            return None;
+        }
+
+        let (page_idx, x, y) = self.allocate(w, h, textures);
+        let page = &self.pages[page_idx];
+
+        let img = textures.image_mut(&page.handle);
+        let rgba = img.as_mut_rgba8().expect("atlas page is rgba8");
+        write_glyph(rgba, image, x, y);
+
+        let handle = page.handle.clone();
+        let rect = PatchRect {
+            x,
+            y,
+            width: w,
+            height: h,
+        };
+        textures.patch(&handle, rect);
+
+        let page = &self.pages[page_idx];
+        let scale = 1.0 / PAGE as f32;
+        let entry = GlyphEntry {
+            uv_min: Vec2::new(x as f32 * scale, y as f32 * scale),
+            uv_max: Vec2::new((x + w) as f32 * scale, (y + h) as f32 * scale),
+            left: image.placement.left,
+            top: image.placement.top,
+            width: w,
+            height: h,
+            is_colored: matches!(image.content, Content::Color),
+            layer: page.handle.layer(),
+        };
+        self.entries.insert(key, Some(entry));
+        Some(entry)
+    }
+
+    fn allocate(&mut self, w: u32, h: u32, textures: &mut Textures) -> (usize, u32, u32) {
+        if let Some((i, (x, y))) = self
+            .pages
+            .iter_mut()
+            .enumerate()
+            .find_map(|(i, page)| page.allocate(w, h).map(|position| (i, position)))
+        {
+            return (i, x, y);
+        }
+
+        let handle = textures.add_page(RgbaImage::new(PAGE, PAGE));
+        self.pages.push(Page {
+            handle,
+            x: PAD + w + PAD,
+            y: PAD,
+            shelf_height: h + PAD,
+        });
+        (self.pages.len() - 1, PAD, PAD)
+    }
+
+    pub fn insert_empty(&mut self, key: GlyphKey) {
+        self.entries.insert(key, None);
+    }
+
+    pub fn page_count(&self) -> usize {
+        self.pages.len()
+    }
+
+    pub fn glyph_count(&self) -> usize {
+        self.entries.len()
+    }
+}
+
+impl Page {
+    fn allocate(&mut self, w: u32, h: u32) -> Option<(u32, u32)> {
+        let need_w = w + PAD;
+        let need_h = h + PAD;
+        if self.x + need_w > PAGE {
+            if need_w + PAD > PAGE || self.y + self.shelf_height + need_h > PAGE {
+                return None;
+            }
+            self.y += self.shelf_height;
+            self.x = PAD;
+            self.shelf_height = 0;
+        } else if self.y + need_h > PAGE {
+            return None;
+        }
+
+        let position = (self.x, self.y);
+        self.x += need_w;
+        self.shelf_height = self.shelf_height.max(need_h);
+        Some(position)
+    }
+}
+
+/// Mask glyphs keep coverage in alpha so their raster can be tinted at draw time.
+fn write_glyph(page: &mut RgbaImage, image: &Image, x: u32, y: u32) {
+    let width = image.placement.width as usize;
+    let height = image.placement.height as usize;
+    let page_stride = page.width() as usize * 4;
+    let x = x as usize * 4;
+    let y = y as usize;
+    let page = page.as_mut();
+
+    for row in 0..height {
+        let start = (y + row) * page_stride + x;
+        let target = &mut page[start..start + width * 4];
+        match image.content {
+            Content::Color => {
+                let start = row * width * 4;
+                target.copy_from_slice(&image.data[start..start + width * 4]);
+            }
+            Content::Mask => {
+                let start = row * width;
+                for (target, &alpha) in target
+                    .as_chunks_mut::<4>()
+                    .0
+                    .iter_mut()
+                    .zip(&image.data[start..start + width])
+                {
+                    target.copy_from_slice(&[255, 255, 255, alpha]);
+                }
+            }
+            Content::SubpixelMask => {
+                let start = row * width * 4;
+                for (target, source) in target
+                    .as_chunks_mut::<4>()
+                    .0
+                    .iter_mut()
+                    .zip(image.data[start..start + width * 4].as_chunks::<4>().0)
+                {
+                    target.copy_from_slice(&[255, 255, 255, source[1]]);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct PlacedGlyph {
+    pub entry: GlyphEntry,
+    pub offset: Vec2,
+}
@@ -1,5 +1,3 @@
-use std::num::NonZero;
-
 use crate::{
    UiData, UiRenderState,
    render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
@@ -11,11 +9,13 @@ use wgpu::{
    *,
 };

+mod atlas;
 mod data;
 mod primitive;
 mod texture;
 mod util;

+pub use atlas::*;
 pub use data::{Mask, MaskIdx};
 pub use primitive::*;

@@ -40,22 +40,45 @@ struct RenderLayer {
    instance: ArrBuf<PrimitiveInstance>,
    primitives: PrimitiveBuffers,
    primitive_group: BindGroup,
+    /// A standalone image's instances, kept apart from `instance` because
+    /// each one draws with its own bind group -- see `UiRenderNode::draw`.
+    image_instance: ArrBuf<PrimitiveInstance>,
+    /// The texture slot each entry of `image_instance` draws with, in the
+    /// same order, refreshed alongside it. Not stored in the vertex buffer
+    /// itself because it names a bind group, not shader data.
+    image_tex_indices: Vec<u32>,
 }

 impl UiRenderNode {
    pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) {
        pass.set_pipeline(&self.pipeline);
        pass.set_bind_group(0, &self.uniform_group, &[]);
-        pass.set_bind_group(2, &self.rsc_group, &[]);
        for i in &self.active {
            let layer = &self.layers[i];
-            if layer.instance.len() == 0 {
+            if layer.instance.len() == 0 && layer.image_instance.len() == 0 {
                continue;
            }
            pass.set_bind_group(1, &layer.primitive_group, &[]);
+            if layer.instance.len() > 0 {
+                pass.set_bind_group(2, &self.rsc_group, &[]);
                pass.set_vertex_buffer(0, layer.instance.buffer.slice(..));
                pass.draw(0..4, 0..layer.instance.len() as u32);
            }
+            // Images draw after this layer's rects and glyphs, one draw call
+            // each with its own bind group. That draws every image "on top"
+            // within the layer, which loses nothing that currently exists:
+            // `Primitives::apply_free` frees with `swap_remove`, so a layer's
+            // draw order was already undefined before images had their own
+            // list -- nothing before this relied on interleaving a rect
+            // between two images at a particular position.
+            if layer.image_instance.len() > 0 {
+                pass.set_vertex_buffer(0, layer.image_instance.buffer.slice(..));
+                for (k, &tex_idx) in layer.image_tex_indices.iter().enumerate() {
+                    pass.set_bind_group(2, self.textures.image_bind_group(tex_idx), &[]);
+                    pass.draw(0..4, k as u32..k as u32 + 1);
+                }
+            }
+        }
    }

    pub fn update(
@@ -71,7 +94,15 @@ impl UiRenderNode {
            for change in primitives.apply_free() {
                if let Some(inst) = ui_render.active.get_mut(&change.id) {
                    for h in &mut inst.primitives {
-                        if h.layer == i && h.inst_idx == change.old {
+                        // `is_image` disambiguates: `instances` and `images`
+                        // are separate lists with independent indices, so
+                        // without it a rect's renumbering could be applied to
+                        // an image handle that happened to share the same
+                        // (layer, inst_idx).
+                        if h.layer == i
+                            && h.inst_idx == change.old
+                            && (h.binding == IMAGE_BINDING) == change.is_image
+                        {
                            h.inst_idx = change.new;
                            break;
                        }
@@ -90,6 +121,12 @@ impl UiRenderNode {
                    ),
                    primitives,
                    primitive_group,
+                    image_instance: ArrBuf::new(
+                        device,
+                        BufferUsages::VERTEX | BufferUsages::COPY_DST,
+                        "image instance",
+                    ),
+                    image_tex_indices: Vec::new(),
                }
            });
            if primitives.updated {
@@ -102,17 +139,30 @@ impl UiRenderNode {
                    &self.primitive_layout,
                    rlayer.primitives.buffers(),
                );
+                rlayer
+                    .image_instance
+                    .update(device, queue, primitives.image_instances());
+                rlayer.image_tex_indices = primitives
+                    .image_instances()
+                    .iter()
+                    .map(|inst| inst.idx)
+                    .collect();
                primitives.updated = false;
            }
        }
-        let mut changed = false;
-        changed |= self.textures.update(&mut ui.textures);
-        if ui.masks.changed {
+        let masks_resized = if ui.masks.changed {
            ui.masks.changed = false;
-            self.masks.update(device, queue, &ui.masks[..]);
-            changed = true;
-        }
-        if changed {
+            self.masks.update(device, queue, &ui.masks[..])
+        } else {
+            false
+        };
+        let rebuild_main = self.textures.update(
+            &mut ui.textures,
+            &self.rsc_layout,
+            &self.masks,
+            masks_resized,
+        );
+        if rebuild_main {
            self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks);
        }
    }
@@ -126,12 +176,7 @@ impl UiRenderNode {
        queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice));
    }

-    pub fn new(
-        device: &Device,
-        queue: &Queue,
-        config: &SurfaceConfiguration,
-        limits: UiLimits,
-    ) -> Self {
+    pub fn new(device: &Device, queue: &Queue, config: &SurfaceConfiguration) -> Self {
        let shader = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("UI Shape Shader"),
            source: ShaderSource::Wgsl(SHAPE_SHADER.into()),
@@ -164,9 +209,8 @@ impl UiRenderNode {
        let uniform_group = Self::bind_group_0(device, &uniform_layout, &window_buffer);

        let primitive_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &core::array::from_fn::<_, { PrimitiveBuffers::LEN }, _>(|i| {
-                BindGroupLayoutEntry {
-                    binding: i as u32,
+            entries: &PrimitiveBuffers::BINDINGS.map(|binding| BindGroupLayoutEntry {
+                binding,
                visibility: ShaderStages::FRAGMENT,
                ty: BindingType::Buffer {
                    ty: BufferBindingType::Storage { read_only: true },
@@ -174,7 +218,6 @@ impl UiRenderNode {
                    min_binding_size: None,
                },
                count: None,
-                }
            }),
            label: Some("primitive"),
        });
@@ -186,7 +229,7 @@ impl UiRenderNode {
            "ui masks",
        );

-        let rsc_layout = Self::rsc_layout(device, &limits);
+        let rsc_layout = Self::rsc_layout(device);
        let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks);

        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
@@ -276,7 +319,12 @@ impl UiRenderNode {
        })
    }

-    fn rsc_layout(device: &Device, limits: &UiLimits) -> BindGroupLayout {
+    /// Group 2: the shared atlas array, one standalone-image slot (a null
+    /// view for the main draw, a real one for each image's own bind group --
+    /// see `GpuTextures`), one sampler and the masks buffer. No `count` on
+    /// any entry: this needs nothing beyond plain Vulkan 1.0 / GLES
+    /// sampling, unlike the `binding_array` layout it replaced.
+    fn rsc_layout(device: &Device) -> BindGroupLayout {
        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            entries: &[
                BindGroupLayoutEntry {
@@ -284,20 +332,30 @@ impl UiRenderNode {
                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Texture {
                        sample_type: TextureSampleType::Float { filterable: false },
-                        view_dimension: TextureViewDimension::D2,
+                        view_dimension: TextureViewDimension::D2Array,
                        multisampled: false,
                    },
-                    count: Some(NonZero::new(limits.max_textures).unwrap()),
+                    count: None,
                },
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
-                    count: Some(NonZero::new(limits.max_samplers).unwrap()),
+                    ty: BindingType::Texture {
+                        sample_type: TextureSampleType::Float { filterable: false },
+                        view_dimension: TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
                },
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
+                    count: None,
+                },
+                BindGroupLayoutEntry {
+                    binding: 3,
+                    visibility: ShaderStages::FRAGMENT,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
@@ -310,6 +368,8 @@ impl UiRenderNode {
        })
    }

+    /// The main group: rects and glyphs never sample the image slot, so it
+    /// gets a 1x1 null view rather than any live standalone image's.
    fn rsc_group(
        device: &Device,
        layout: &BindGroupLayout,
@@ -321,14 +381,18 @@ impl UiRenderNode {
            entries: &[
                BindGroupEntry {
                    binding: 0,
-                    resource: BindingResource::TextureViewArray(&tex_manager.views()),
+                    resource: BindingResource::TextureView(tex_manager.array_view()),
                },
                BindGroupEntry {
                    binding: 1,
-                    resource: BindingResource::SamplerArray(&tex_manager.samplers()),
+                    resource: BindingResource::TextureView(tex_manager.null_view()),
                },
                BindGroupEntry {
                    binding: 2,
+                    resource: BindingResource::Sampler(tex_manager.sampler()),
+                },
+                BindGroupEntry {
+                    binding: 3,
                    resource: masks.buffer.as_entire_binding(),
                },
            ],
@@ -340,26 +404,3 @@ impl UiRenderNode {
        self.textures.view_count()
    }
 }
-
-pub struct UiLimits {
-    max_textures: u32,
-    max_samplers: u32,
-}
-
-impl Default for UiLimits {
-    fn default() -> Self {
-        Self {
-            max_textures: 100000,
-            max_samplers: 1000,
-        }
-    }
-}
-
-impl UiLimits {
-    pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 {
-        self.max_textures + self.max_samplers
-    }
-    pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 {
-        self.max_samplers
-    }
-}
@@ -6,6 +6,7 @@ use crate::{
        ArrBuf,
        data::{MaskIdx, PrimitiveInstance},
    },
+    util::Vec2,
 };
 use bytemuck::Pod;
 use wgpu::*;
@@ -15,6 +16,17 @@ pub struct Primitives {
    assoc: Vec<WidgetId>,
    data: PrimitiveData,
    free: Vec<usize>,
+
+    /// Standalone images, kept apart from `instances` because each one draws
+    /// with its own bind group rather than sharing the layer's one instanced
+    /// draw. `idx` on each `PrimitiveInstance` here is the texture's slot in
+    /// `Textures`/`GpuTextures`, not an index into `data`: a bind group has
+    /// already picked the texture, so there is nothing left to look up
+    /// per-instance and no per-image entry in `data` at all.
+    images: Vec<PrimitiveInstance>,
+    image_assoc: Vec<WidgetId>,
+    image_free: Vec<usize>,
+
    pub updated: bool,
 }

@@ -25,11 +37,21 @@ impl Default for Primitives {
            assoc: Default::default(),
            data: Default::default(),
            free: Vec::new(),
+            images: Default::default(),
+            image_assoc: Default::default(),
+            image_free: Vec::new(),
            updated: true,
        }
    }
 }

+/// The `binding` tag `Painter` writes on an image instance. Distinct from any
+/// `Primitive::BINDING` because images have no `PrimitiveData` entry to key
+/// one from -- a bind group already selects the texture -- so this only ever
+/// has to match the shader's `TEXTURE` constant and flag "this instance lives
+/// in `Primitives::images`, not `Primitives::instances`" to the code below.
+pub const IMAGE_BINDING: u32 = 1;
+
 pub trait Primitive: Pod {
    const BINDING: u32;
    fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self>;
@@ -54,6 +76,14 @@ macro_rules! primitives {

        impl PrimitiveBuffers {
            pub const LEN: usize = primitives!(@count $($name)*);
+            /// The group-1 binding number each primitive's storage buffer
+            /// sits at, in declaration order. Not `0..LEN`: a primitive's
+            /// `BINDING` also tags its instances for the shader's dispatch
+            /// switch, and a removed primitive (as `TEXTURE` was, once
+            /// images stopped needing a per-instance storage entry) can
+            /// leave a gap, so the pipeline layout has to ask for these
+            /// exact numbers rather than assuming they are contiguous.
+            pub const BINDINGS: [u32; Self::LEN] = [$(<$ty>::BINDING,)*];
            pub fn buffers(&self) -> [(u32, &Buffer); Self::LEN] {
                [
                    $((<$ty>::BINDING, &self.$name.buffer),)*
@@ -137,27 +167,104 @@ impl Primitives {
        PrimitiveHandle::new::<P>(layer, inst_i, i)
    }

-    /// returns (old index, new index)
-    pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
-        self.free.sort_by(|a, b| b.cmp(a));
-        self.free.drain(..).filter_map(|i| {
-            self.instances.swap_remove(i);
-            self.assoc.swap_remove(i);
-            if i == self.instances.len() {
+    /// Writes an image instance directly -- there is no `Primitive` impl for
+    /// it to go through `write`, since it has nowhere in `PrimitiveData` to
+    /// put a per-instance entry. `texture_idx` is the slot the bind group at
+    /// draw time is chosen from, carried in the otherwise-unused `idx` field.
+    pub fn write_image(
+        &mut self,
+        layer: usize,
+        id: WidgetId,
+        texture_idx: u32,
+        region: UiRegion,
+        mask_idx: MaskIdx,
+    ) -> PrimitiveHandle {
+        self.updated = true;
+        let inst = PrimitiveInstance {
+            region,
+            idx: texture_idx,
+            mask_idx,
+            binding: IMAGE_BINDING,
+        };
+        let inst_i = if let Some(i) = self.image_free.pop() {
+            self.images[i] = inst;
+            self.image_assoc[i] = id;
+            i
+        } else {
+            let i = self.images.len();
+            self.images.push(inst);
+            self.image_assoc.push(id);
+            i
+        };
+        PrimitiveHandle {
+            layer,
+            inst_idx: inst_i,
+            data_idx: 0,
+            binding: IMAGE_BINDING,
+        }
+    }
+
+    pub fn image_instances(&self) -> &Vec<PrimitiveInstance> {
+        &self.images
+    }
+
+    /// returns (old index, new index) for both lists this layer keeps --
+    /// `PrimitiveChange::is_image` says which, since the two have separate
+    /// index spaces and `old`/`new` alone would collide between them.
+    ///
+    /// Both lists free with `swap_remove`, so a layer's draw order was
+    /// already undefined before images existed: nothing here may assume one
+    /// primitive stays adjacent to another once anything in the layer has
+    /// been freed.
+    pub fn apply_free(&mut self) -> Vec<PrimitiveChange> {
+        let mut changes =
+            Self::apply_free_list(&mut self.free, &mut self.instances, &mut self.assoc, false);
+        changes.extend(Self::apply_free_list(
+            &mut self.image_free,
+            &mut self.images,
+            &mut self.image_assoc,
+            true,
+        ));
+        changes
+    }
+
+    fn apply_free_list(
+        free: &mut Vec<usize>,
+        instances: &mut Vec<PrimitiveInstance>,
+        assoc: &mut Vec<WidgetId>,
+        is_image: bool,
+    ) -> Vec<PrimitiveChange> {
+        free.sort_by(|a, b| b.cmp(a));
+        free.drain(..)
+            .filter_map(|i| {
+                instances.swap_remove(i);
+                assoc.swap_remove(i);
+                if i == instances.len() {
                    return None;
                }
-            let id = self.assoc[i];
-            let old = self.instances.len();
-            Some(PrimitiveChange { id, old, new: i })
+                let id = assoc[i];
+                let old = instances.len();
+                Some(PrimitiveChange {
+                    id,
+                    is_image,
+                    old,
+                    new: i,
                })
+            })
+            .collect()
    }

    pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
        self.updated = true;
+        if h.binding == IMAGE_BINDING {
+            self.image_free.push(h.inst_idx);
+            self.images[h.inst_idx].mask_idx
+        } else {
            self.data.free(h.binding, h.data_idx);
            self.free.push(h.inst_idx);
            self.instances[h.inst_idx].mask_idx
        }
+    }

    pub fn data(&self) -> &PrimitiveData {
        &self.data
@@ -169,12 +276,21 @@ impl Primitives {

    pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion {
        self.updated = true;
+        if h.binding == IMAGE_BINDING {
+            &mut self.images[h.inst_idx].region
+        } else {
            &mut self.instances[h.inst_idx].region
        }
+    }
 }

 pub struct PrimitiveChange {
    pub id: WidgetId,
+    /// Which of `Primitives::instances`/`Primitives::images` this change
+    /// belongs to -- their `old`/`new` indices are independent, so a
+    /// consumer matching only on `(layer, inst_idx)` could apply an image's
+    /// renumbering to a rect's handle that happens to share the same index.
+    pub is_image: bool,
    pub old: usize,
    pub new: usize,
 }
@@ -200,7 +316,7 @@ impl PrimitiveHandle {

 primitives!(
    rects: RectPrimitive => 0,
-    textures: TexturePrimitive => 1,
+    glyphs: GlyphPrimitive => 2,
 );

 #[repr(C)]
@@ -223,11 +339,42 @@ impl RectPrimitive {
    }
 }

+/// One glyph, drawn as a sub-rectangle of the glyph atlas array.
+///
+/// `color` is the text colour and is multiplied by the atlas's alpha for an
+/// ordinary mask glyph; a colour glyph (emoji) carries its own colour and
+/// takes the atlas texel unchanged, which is what `GlyphEntry::IS_COLORED`
+/// selects.
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct TexturePrimitive {
-    pub view_idx: u32,
-    pub sampler_idx: u32,
+pub struct GlyphPrimitive {
+    pub uv_min: Vec2,
+    pub uv_max: Vec2,
+    /// Layer of the shared atlas array texture this glyph's page occupies --
+    /// not a bind-group or view index, since a page never gets one of its own.
+    pub layer: u32,
+    pub color: Color<u8>,
+    pub flags: u32,
+    /// Pads this struct's Rust size to match WGSL's storage-buffer layout for
+    /// `GlyphInfo`: two `vec2<f32>` members give the struct an 8-byte
+    /// alignment, which rounds the WGSL size up to 32 bytes even though the
+    /// fields above only total 28. `bytemuck` does not check this for us.
+    _pad: u32,
+}
+
+impl GlyphPrimitive {
+    /// The only constructor, since `_pad` is private: callers outside this
+    /// module cannot write the struct literal.
+    pub fn new(uv_min: Vec2, uv_max: Vec2, layer: u32, color: Color<u8>, flags: u32) -> Self {
+        Self {
+            uv_min,
+            uv_max,
+            layer,
+            color,
+            flags,
+            _pad: 0,
+        }
+    }
 }

 pub struct PrimitiveVec<T> {
@@ -1,12 +1,16 @@
 const RECT: u32 = 0u;
+// TEXTURE has no entry in group 1: a standalone image draws with its own
+// bind group (see UiRenderNode::draw), so there is nothing per-instance left
+// to look up here -- the bind group already picked the texture.
 const TEXTURE: u32 = 1u;
+const GLYPH: u32 = 2u;

@group(0) @binding(0)
 var<uniform> window: WindowUniform;
@group(1) @binding(RECT)
 var<storage> rects: array<Rect>;
-@group(1) @binding(TEXTURE)
-var<storage> textures: array<TextureInfo>;
+@group(1) @binding(GLYPH)
+var<storage> glyphs: array<GlyphInfo>;

 struct Rect {
    color: u32,
@@ -15,9 +19,14 @@ struct Rect {
    inner_radius: f32,
 }

-struct TextureInfo {
-    view_idx: u32,
-    sampler_idx: u32,
+struct GlyphInfo {
+    uv_min: vec2<f32>,
+    uv_max: vec2<f32>,
+    // Layer of the shared atlas array texture, not a view or bind-group
+    // index -- a page never gets its own bind group.
+    layer: u32,
+    color: u32,
+    flags: u32,
 }

 struct Mask {
@@ -40,11 +49,21 @@ struct UiVec2 {
    abs: vec2<f32>,
 }

+// The shared glyph atlas: every page is one layer. Growing it recreates this
+// texture with headroom and copies the old layers across -- see
+// GpuTextures::grow_array -- rather than the binding_array<texture_2d<f32>>
+// this replaced, which needed VK_EXT_descriptor_indexing and does not survive
+// a real share of Android GPUs.
@group(2) @binding(0)
-var views: binding_array<texture_2d<f32>>;
+var atlas: texture_2d_array<f32>;
+// One standalone image's texture. The main draw (rects and glyphs) binds a
+// 1x1 null texture here, since neither samples it; each image draw call
+// binds its own -- see UiRenderNode::draw.
@group(2) @binding(1)
-var samplers: binding_array<sampler>;
+var image_texture: texture_2d<f32>;
@group(2) @binding(2)
+var samp: sampler;
+@group(2) @binding(3)
 var<storage> masks: array<Mask>;

 struct WindowUniform {
@@ -123,7 +142,10 @@ fn fs_main(
            color = draw_rounded_rect(region, rects[i]);
        }
        case TEXTURE: {
-            color = draw_texture(region, textures[i]);
+            color = draw_texture(region);
+        }
+        case GLYPH: {
+            color = draw_glyph(region, glyphs[i]);
        }
        default: {
            color = vec4(1.0, 0.0, 1.0, 1.0);
@@ -143,9 +165,19 @@ fn fs_main(
    return color;
 }

-// TODO: this seems really inefficient (per frag indexing)?
-fn draw_texture(region: Region, info: TextureInfo) -> vec4<f32> {
-    return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv);
+fn draw_texture(region: Region) -> vec4<f32> {
+    return textureSample(image_texture, samp, region.uv);
+}
+
+fn draw_glyph(region: Region, g: GlyphInfo) -> vec4<f32> {
+    let uv = mix(g.uv_min, g.uv_max, region.uv);
+    let texel = textureSample(atlas, samp, uv, i32(g.layer));
+    if (g.flags & 1u) != 0u {
+        return texel;
+    }
+    var color = unpack4x8unorm(g.color);
+    color.a *= texel.a;
+    return color;
 }

 fn draw_rounded_rect(region: Region, rect: Rect) -> vec4<f32> {
@@ -1,59 +1,296 @@
-use image::{DynamicImage, EncodableLayout};
+use image::{DynamicImage, EncodableLayout, GenericImageView};
 use wgpu::{util::DeviceExt, *};

-use crate::{TextureUpdate, Textures};
+use crate::{Mask, PatchRect, TextureKind, TextureUpdate, Textures, render::util::ArrBuf};

+use super::atlas::PAGE;
+
+/// What one texture slot is, GPU-side. Parallel to `Textures`' own slot
+/// numbering (`TextureKind`'s `Image`/`Page`), so a slot's index means the
+/// same thing on both sides without a second map to keep in sync.
+enum Slot {
+    /// A slot that was freed, or pushed and freed within the same batch
+    /// before ever reaching here.
+    Empty,
+    Image(ImageGpu),
+    /// The array layer a page occupies. Pages are never freed (see
+    /// `Textures::free`), so this is the only variant that outlives a `Free`.
+    Page(u32),
+}
+
+struct ImageGpu {
+    /// Kept because a masks or atlas-array rebuild has to build a new bind
+    /// group from it. The `Texture` it came from is not kept: a `TextureView`
+    /// holds its own reference to that, so the image survives without one.
+    view: TextureView,
+    bind_group: BindGroup,
+}
+
+/// Owns the two kinds of texture iris draws:
+///
+/// - **The glyph atlas**, one `texture_2d_array` whose layers are pages
+///   (`Slot::Page`), grown by recreating the array with headroom and
+///   `copy_texture_to_texture`-ing the old layers across. No feature beyond
+///   Vulkan 1.0/GLES sampling is needed for this -- a layer index is an
+///   ordinary sampling operand.
+/// - **Standalone images** (`Slot::Image`), each its own `Texture` and
+///   `BindGroup`, drawn one `draw()` call at a time with that bind group
+///   bound -- see `UiRenderNode::draw`.
+///
+/// This replaced one giant `binding_array<texture_2d<f32>>`, which needed
+/// `VK_EXT_descriptor_indexing` -- an extension a real share of Android GPUs
+/// lack, so the old shape did not run there at all.
 pub struct GpuTextures {
    device: Device,
    queue: Queue,
-    views: Vec<TextureView>,
-    view_count: usize,
-    samplers: Vec<Sampler>,
+
+    slots: Vec<Slot>,
+
+    array_texture: Texture,
+    array_view: TextureView,
+    array_capacity: u32,
+    /// Layers actually written. Only grows -- see `Slot::Page`.
+    page_count: u32,
+
+    sampler: Sampler,
+    /// Bound in the image slot of the main draw's bind group, which has
+    /// nothing of its own to put there: rects and glyphs never sample it,
+    /// but the layout requires something bound regardless.
    null_view: TextureView,
-    no_views: Vec<TextureView>,
 }

 impl GpuTextures {
-    pub fn update(&mut self, textures: &mut Textures) -> bool {
-        let mut changed = false;
+    /// Applies queued `Textures` updates, then reports whether the *main*
+    /// bind group (the one rects and glyphs draw with) needs rebuilding --
+    /// true when the atlas array was recreated (its view identity changed)
+    /// or the masks buffer was, since both are bound there. Pushing or
+    /// freeing a standalone image never touches that group: it built or drops
+    /// its own.
+    pub fn update(
+        &mut self,
+        textures: &mut Textures,
+        rsc_layout: &BindGroupLayout,
+        masks: &ArrBuf<Mask>,
+        masks_resized: bool,
+    ) -> bool {
+        let mut rebuild_main = masks_resized;
+        if masks_resized {
+            // The masks buffer just moved, so every bind group holding a
+            // reference to it -- one per live standalone image -- is stale.
+            self.rebuild_image_bind_groups(rsc_layout, masks);
+        }
        for update in textures.updates() {
-            changed = true;
            match update {
-                TextureUpdate::Push(image) => self.push(image),
-                TextureUpdate::Set(i, image) => self.set(i, image),
-                TextureUpdate::SetFree => self.view_count += 1,
+                TextureUpdate::Push(kind, image) => {
+                    rebuild_main |= self.push(kind, image, rsc_layout, masks);
+                }
+                TextureUpdate::Set(kind, i, image) => {
+                    rebuild_main |= self.set(kind, i, image, rsc_layout, masks);
+                }
+                // A patch changes texture contents, not which layer or bind
+                // group exists, so it never asks for a rebuild -- rebuilding
+                // per glyph is exactly the cost this exists to avoid.
+                TextureUpdate::Patch(i, rect, image) => self.patch(i, rect, image),
+                TextureUpdate::SetFree => {}
                TextureUpdate::Free(i) => self.free(i),
-                TextureUpdate::PushFree => self.push_free(),
+                TextureUpdate::PushFree(_kind) => self.slots.push(Slot::Empty),
            }
        }
-        changed
-    }
-    fn set(&mut self, i: u32, image: &DynamicImage) {
-        self.view_count += 1;
-        let view = self.create_view(image);
-        self.views[i as usize] = view;
-    }
-    fn free(&mut self, i: u32) {
-        self.view_count -= 1;
-        self.views[i as usize] = self.null_view.clone();
-    }
-    fn push(&mut self, image: &DynamicImage) {
-        self.view_count += 1;
-        let view = self.create_view(image);
-        self.views.push(view);
-    }
-    fn push_free(&mut self) {
-        self.view_count += 1;
-        self.views.push(self.null_view.clone());
+        rebuild_main
    }

-    fn create_view(&self, image: &DynamicImage) -> TextureView {
-        let image = image.to_rgba8();
-        let (width, height) = image.dimensions();
+    fn push(
+        &mut self,
+        kind: TextureKind,
+        image: &DynamicImage,
+        rsc_layout: &BindGroupLayout,
+        masks: &ArrBuf<Mask>,
+    ) -> bool {
+        let (slot, rebuilt) = self.make_slot(kind, image, rsc_layout, masks);
+        self.slots.push(slot);
+        rebuilt
+    }
+
+    fn set(
+        &mut self,
+        kind: TextureKind,
+        i: u32,
+        image: &DynamicImage,
+        rsc_layout: &BindGroupLayout,
+        masks: &ArrBuf<Mask>,
+    ) -> bool {
+        let (slot, rebuilt) = self.make_slot(kind, image, rsc_layout, masks);
+        self.slots[i as usize] = slot;
+        rebuilt
+    }
+
+    fn make_slot(
+        &mut self,
+        kind: TextureKind,
+        image: &DynamicImage,
+        rsc_layout: &BindGroupLayout,
+        masks: &ArrBuf<Mask>,
+    ) -> (Slot, bool) {
+        match kind {
+            TextureKind::Image => {
+                let gpu = self.create_image(image, rsc_layout, masks);
+                (Slot::Image(gpu), false)
+            }
+            TextureKind::Page { layer } => {
+                let mut rebuilt = false;
+                if layer >= self.array_capacity {
+                    self.grow_array(rsc_layout, masks);
+                    rebuilt = true;
+                }
+                self.write_full_layer(layer, image);
+                self.page_count = self.page_count.max(layer + 1);
+                (Slot::Page(layer), rebuilt)
+            }
+        }
+    }
+
+    fn free(&mut self, i: u32) {
+        if let Some(slot) = self.slots.get_mut(i as usize) {
+            *slot = Slot::Empty;
+        }
+        // A page's layer is not reclaimed here either -- see `Slot::Page`.
+    }
+
+    fn patch(&mut self, i: u32, rect: PatchRect, image: &DynamicImage) {
+        let Some(&Slot::Page(layer)) = self.slots.get(i as usize) else {
+            return;
+        };
+        if rect.width == 0 || rect.height == 0 {
+            return;
+        }
+        // `write_texture` requires tightly packed rows, unlike the atlas image.
+        let sub = image
+            .view(rect.x, rect.y, rect.width, rect.height)
+            .to_image();
+        self.queue.write_texture(
+            TexelCopyTextureInfo {
+                texture: &self.array_texture,
+                mip_level: 0,
+                origin: Origin3d {
+                    x: rect.x,
+                    y: rect.y,
+                    z: layer,
+                },
+                aspect: TextureAspect::All,
+            },
+            sub.as_bytes(),
+            TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(rect.width * 4),
+                rows_per_image: Some(rect.height),
+            },
+            Extent3d {
+                width: rect.width,
+                height: rect.height,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+
+    fn write_full_layer(&self, layer: u32, image: &DynamicImage) {
+        // Every page is created as exactly PAGE x PAGE (`GlyphAtlas::allocate`),
+        // so this is always a whole-layer write, never a crop.
+        let rgba = image.to_rgba8();
+        self.queue.write_texture(
+            TexelCopyTextureInfo {
+                texture: &self.array_texture,
+                mip_level: 0,
+                origin: Origin3d {
+                    x: 0,
+                    y: 0,
+                    z: layer,
+                },
+                aspect: TextureAspect::All,
+            },
+            rgba.as_bytes(),
+            TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(PAGE * 4),
+                rows_per_image: Some(PAGE),
+            },
+            Extent3d {
+                width: PAGE,
+                height: PAGE,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+
+    /// Doubles the array's layer capacity (headroom, so this is rare) and
+    /// copies the old layers across GPU-side -- no readback. Recreates the
+    /// array's view, which invalidates every bind group that referenced it,
+    /// so this also rebuilds all of them before returning.
+    fn grow_array(&mut self, rsc_layout: &BindGroupLayout, masks: &ArrBuf<Mask>) {
+        let new_capacity = self.array_capacity * 2;
+        let new_texture = Self::create_array_texture(&self.device, new_capacity);
+        if self.page_count > 0 {
+            let mut encoder = self
+                .device
+                .create_command_encoder(&CommandEncoderDescriptor {
+                    label: Some("atlas array grow"),
+                });
+            encoder.copy_texture_to_texture(
+                TexelCopyTextureInfo {
+                    texture: &self.array_texture,
+                    mip_level: 0,
+                    origin: Origin3d::ZERO,
+                    aspect: TextureAspect::All,
+                },
+                TexelCopyTextureInfo {
+                    texture: &new_texture,
+                    mip_level: 0,
+                    origin: Origin3d::ZERO,
+                    aspect: TextureAspect::All,
+                },
+                Extent3d {
+                    width: PAGE,
+                    height: PAGE,
+                    depth_or_array_layers: self.page_count,
+                },
+            );
+            self.queue.submit(std::iter::once(encoder.finish()));
+        }
+        self.array_texture = new_texture;
+        self.array_view = self.array_texture.create_view(&TextureViewDescriptor {
+            dimension: Some(TextureViewDimension::D2Array),
+            ..Default::default()
+        });
+        self.array_capacity = new_capacity;
+        self.rebuild_image_bind_groups(rsc_layout, masks);
+    }
+
+    fn rebuild_image_bind_groups(&mut self, rsc_layout: &BindGroupLayout, masks: &ArrBuf<Mask>) {
+        for slot in &mut self.slots {
+            if let Slot::Image(gpu) = slot {
+                gpu.bind_group = Self::make_image_bind_group(
+                    &self.device,
+                    rsc_layout,
+                    &self.array_view,
+                    &gpu.view,
+                    &self.sampler,
+                    masks,
+                );
+            }
+        }
+    }
+
+    fn create_image(
+        &self,
+        image: &DynamicImage,
+        rsc_layout: &BindGroupLayout,
+        masks: &ArrBuf<Mask>,
+    ) -> ImageGpu {
+        let rgba = image.to_rgba8();
+        let (width, height) = rgba.dimensions();
        let texture = self.device.create_texture_with_data(
            &self.queue,
            &TextureDescriptor {
-                label: None,
+                label: Some("image"),
                size: Extent3d {
                    width,
                    height,
@@ -63,45 +300,138 @@ impl GpuTextures {
                sample_count: 1,
                dimension: TextureDimension::D2,
                format: TextureFormat::Rgba8Unorm,
-                usage: TextureUsages::TEXTURE_BINDING,
+                usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
                view_formats: &[],
            },
            wgt::TextureDataOrder::MipMajor,
-            image.as_bytes(),
+            rgba.as_bytes(),
        );
-        texture.create_view(&TextureViewDescriptor::default())
+        let view = texture.create_view(&TextureViewDescriptor::default());
+        let bind_group = Self::make_image_bind_group(
+            &self.device,
+            rsc_layout,
+            &self.array_view,
+            &view,
+            &self.sampler,
+            masks,
+        );
+        ImageGpu { view, bind_group }
+    }
+
+    /// Builds group 2 for one standalone image: the shared atlas array, this
+    /// image's own view, the shared sampler, and the shared masks buffer --
+    /// the same layout the main draw uses with a null view in the image slot.
+    fn make_image_bind_group(
+        device: &Device,
+        rsc_layout: &BindGroupLayout,
+        array_view: &TextureView,
+        image_view: &TextureView,
+        sampler: &Sampler,
+        masks: &ArrBuf<Mask>,
+    ) -> BindGroup {
+        device.create_bind_group(&BindGroupDescriptor {
+            layout: rsc_layout,
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: BindingResource::TextureView(array_view),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: BindingResource::TextureView(image_view),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: BindingResource::Sampler(sampler),
+                },
+                BindGroupEntry {
+                    binding: 3,
+                    resource: masks.buffer.as_entire_binding(),
+                },
+            ],
+            label: Some("ui rsc image"),
+        })
+    }
+
+    fn create_array_texture(device: &Device, capacity: u32) -> Texture {
+        device.create_texture(&TextureDescriptor {
+            label: Some("glyph atlas array"),
+            size: Extent3d {
+                width: PAGE,
+                height: PAGE,
+                depth_or_array_layers: capacity,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Rgba8Unorm,
+            usage: TextureUsages::TEXTURE_BINDING
+                | TextureUsages::COPY_DST
+                | TextureUsages::COPY_SRC,
+            view_formats: &[],
+        })
    }

    pub fn new(device: &Device, queue: &Queue) -> Self {
+        let sampler = default_sampler(device);
        let null_view = null_texture_view(device);
+        let array_capacity = 1;
+        let array_texture = Self::create_array_texture(device, array_capacity);
+        let array_view = array_texture.create_view(&TextureViewDescriptor {
+            dimension: Some(TextureViewDimension::D2Array),
+            ..Default::default()
+        });
        Self {
            device: device.clone(),
            queue: queue.clone(),
-            views: Vec::new(),
-            samplers: vec![default_sampler(device)],
-            no_views: vec![null_view.clone()],
+            slots: Vec::new(),
+            array_texture,
+            array_view,
+            array_capacity,
+            page_count: 0,
+            sampler,
            null_view,
-            view_count: 0,
        }
    }

-    pub fn views(&self) -> Vec<&TextureView> {
-        if self.views.is_empty() {
-            &self.no_views
-        } else {
-            &self.views
-        }
-        .iter()
-        .by_ref()
-        .collect()
+    pub fn array_view(&self) -> &TextureView {
+        &self.array_view
    }

-    pub fn samplers(&self) -> Vec<&Sampler> {
-        self.samplers.iter().by_ref().collect()
+    pub fn null_view(&self) -> &TextureView {
+        &self.null_view
+    }
+
+    pub fn sampler(&self) -> &Sampler {
+        &self.sampler
+    }
+
+    /// The bind group a standalone image draws with. Panics if `idx` names an
+    /// atlas page or a freed slot instead -- either is a caller bug (the
+    /// wrong kind of instance reached this draw path), not a condition to
+    /// recover from.
+    pub fn image_bind_group(&self, idx: u32) -> &BindGroup {
+        match self.slots.get(idx as usize) {
+            Some(Slot::Image(gpu)) => &gpu.bind_group,
+            other => panic!("texture slot {idx} is not a live standalone image: {other:?}"),
+        }
    }

    pub fn view_count(&self) -> usize {
-        self.view_count
+        self.slots
+            .iter()
+            .filter(|s| !matches!(s, Slot::Empty))
+            .count()
+    }
+}
+
+impl std::fmt::Debug for Slot {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Slot::Empty => write!(f, "Empty"),
+            Slot::Image(_) => write!(f, "Image"),
+            Slot::Page(layer) => write!(f, "Page(layer={layer})"),
+        }
    }
 }

@@ -21,13 +21,18 @@ impl<T: Pod> ArrBuf<T> {
            _pd: PhantomData,
        }
    }
-    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) {
-        if self.len != data.len() {
+    /// Returns whether the underlying `Buffer` was recreated -- a caller that
+    /// cached a `BindGroup` referencing it (as `GpuTextures` does for the
+    /// masks buffer) needs to know to rebuild that too.
+    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) -> bool {
+        let resized = self.len != data.len();
+        if resized {
            self.len = data.len();
            self.buffer =
                Self::init_buf(device, std::mem::size_of_val(data), self.usage, self.label);
        }
        queue.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data));
+        resized
    }
    fn init_buf(device: &Device, size: usize, usage: BufferUsages, label: &'static str) -> Buffer {
        let mut size = size as u64;
@@ -1,7 +1,7 @@
 use crate::{
    Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId,
-    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    TextureHandle, UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, Widget, WidgetId,
+    render::{GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
    util::Vec2,
 };

@@ -77,23 +77,62 @@ impl<'a> Painter<'a> {

    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region.within(&self.region));
+        self.write_image(handle.image_index(), region.within(&self.region));
    }

    pub fn texture(&mut self, handle: &TextureHandle) {
        self.textures.push(handle.clone());
-        self.primitive(handle.primitive());
+        self.write_image(handle.image_index(), self.region);
    }

    pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) {
        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region);
+        self.write_image(handle.image_index(), region);
    }

-    /// returns (handle, offset from top left)
-    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+    /// A standalone image draws with its own bind group rather than sharing
+    /// the layer's one instanced draw, so it goes through
+    /// `Primitives::write_image` instead of `primitive_at`/`Primitive::vec`.
+    fn write_image(&mut self, texture_idx: u32, region: UiRegion) {
+        let h = self
+            .state
+            .layers
+            .write_image(self.layer, self.id, texture_idx, region, self.mask);
+        if self.mask != MaskIdx::NONE {
+            self.rsc.ui_mut().masks.push_ref(self.mask);
+        }
+        self.primitives.push(h);
+    }
+
+    pub fn render_text(
+        &mut self,
+        buffer: &mut TextBuffer,
+        attrs: &TextAttrs,
+        width: Option<f32>,
+    ) -> RenderedText {
        let ui = self.rsc.ui_mut();
-        ui.text.draw(buffer, attrs, &mut ui.textures)
+        ui.text.render(buffer, attrs, width, &mut ui.textures)
+    }
+
+    pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) {
+        for glyph in text.glyphs.iter() {
+            let mut region = origin;
+            region.x.end = region.x.start;
+            region.y.end = region.y.start;
+            let mut region = region.offset(UiVec2::abs(glyph.offset));
+            region.x.end = region.x.start + UiScalar::abs(glyph.entry.width as f32);
+            region.y.end = region.y.start + UiScalar::abs(glyph.entry.height as f32);
+            self.primitive_at(
+                GlyphPrimitive::new(
+                    glyph.entry.uv_min,
+                    glyph.entry.uv_max,
+                    glyph.entry.layer,
+                    text.color,
+                    glyph.entry.flags(),
+                ),
+                region,
+            );
+        }
    }

    pub fn region(&self) -> UiRegion {
@@ -76,8 +76,13 @@ impl SizeCtx<'_> {
        self.output_size
    }

-    pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
-        self.text.draw(buffer, attrs, self.textures)
+    pub fn draw_text(
+        &mut self,
+        buffer: &mut TextBuffer,
+        attrs: &TextAttrs,
+        width: Option<f32>,
+    ) -> RenderedText {
+        self.text.render(buffer, attrs, width, self.textures)
    }

    pub fn label(&self, id: WidgetId) -> &String {
@@ -1,4 +1,3 @@
-use cosmic_text::Family;
 use std::{cell::RefCell, rc::Rc};
 use winit::event::WindowEvent;

@@ -1,4 +1,4 @@
-use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState};
+use iris_core::{UiData, UiRenderNode, UiRenderState};
 use pollster::FutureExt;
 use std::sync::Arc;
 use wgpu::*;
@@ -83,18 +83,15 @@ impl UiRenderer {
            .block_on()
            .expect("Could not get adapter!");

-        let ui_limits = UiLimits::default();
-
+        // No features beyond what wgpu asks for by default, and no
+        // binding-array limits: the atlas is one texture_2d_array and a
+        // standalone image is its own ordinary bind group, neither of which
+        // needs descriptor indexing. The binding array this replaced asked
+        // for VK_EXT_descriptor_indexing unconditionally and so did not run
+        // on a real share of Android GPUs.
        let (device, queue) = adapter
            .request_device(&DeviceDescriptor {
-                required_features: Features::TEXTURE_BINDING_ARRAY
-                    | Features::PARTIALLY_BOUND_BINDING_ARRAY
-                    | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
                required_limits: Limits {
-                    max_binding_array_elements_per_shader_stage: ui_limits
-                        .max_binding_array_elements_per_shader_stage(),
-                    max_binding_array_sampler_elements_per_shader_stage: ui_limits
-                        .max_binding_array_sampler_elements_per_shader_stage(),
                    max_buffer_size: 1 << 30,
                    ..Default::default()
                },
@@ -126,7 +123,7 @@ impl UiRenderer {

        let encoder = Self::create_encoder(&device);

-        let ui = UiRenderNode::new(&device, &queue, &config, ui_limits);
+        let ui = UiRenderNode::new(&device, &queue, &config);

        Self {
            surface,
@@ -1,6 +1,5 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
-#![feature(gen_blocks)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(option_into_flat_iter)]
@@ -1,5 +1,4 @@
 use crate::prelude::*;
-use cosmic_text::{Attrs, Family, Metrics};
 use std::marker::{PhantomData, Sized};

 pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
@@ -20,7 +19,7 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
        self.attrs.color = color;
        self
    }
-    pub fn family(mut self, family: Family<'static>) -> Self {
+    pub fn family(mut self, family: Family) -> Self {
        self.attrs.family = family;
        self
    }
@@ -82,19 +81,13 @@ impl<Rsc: UiRsc> TextBuilderOutput<Rsc> for TextOutput {
        state: &mut Rsc,
        builder: TextBuilder<Rsc, Self, H>,
    ) -> Self::Output {
-        let mut buf = TextBuffer::new_empty(Metrics::new(
-            builder.attrs.font_size,
-            builder.attrs.line_height,
-        ));
+        let buf = TextBuffer::new(&builder.content);
        let hint = builder.hint.get(state);
-        let font_system = &mut state.ui_mut().text.font_system;
-        buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
        let mut text = Text {
            content: builder.content.into(),
            view: TextView::new(buf, builder.attrs, hint),
        };
        text.content.changed = false;
-        builder.attrs.apply(font_system, &mut text.view.buf, None);
        text
    }
 }
@@ -110,19 +103,11 @@ impl<State: UiRsc> TextBuilderOutput<State> for TextEditOutput {
        state: &mut State,
        builder: TextBuilder<State, Self, H>,
    ) -> Self::Output {
-        let buf = TextBuffer::new_empty(Metrics::new(
-            builder.attrs.font_size,
-            builder.attrs.line_height,
-        ));
-        let mut text = TextEdit::new(
+        let buf = TextBuffer::new(&builder.content);
+        TextEdit::new(
            TextView::new(buf, builder.attrs, builder.hint.get(state)),
            builder.output.mode,
-        );
-        let font_system = &mut state.ui_mut().text.font_system;
-        text.buf
-            .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
-        builder.attrs.apply(font_system, &mut text.buf, None);
-        text
+        )
    }
 }

@@ -1,17 +1,30 @@
 use crate::prelude::*;
-use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion};
+use iris_core::{TextData, UiColor};
+use parley::{Affinity, Layout, Selection};
 use std::ops::{Deref, DerefMut};
-use unicode_segmentation::UnicodeSegmentation;
 use winit::{
    event::KeyEvent,
    keyboard::{Key, NamedKey},
 };

+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Motion {
+    Left,
+    Right,
+    LeftWord,
+    RightWord,
+    Up,
+    Down,
+    LineStart,
+    LineEnd,
+}
+
 pub struct TextEdit {
    view: TextView,
-    selection: TextSelection,
-    history: Vec<(String, TextSelection)>,
-    double_hit: Option<Cursor>,
+    /// `None` represents unfocused, which Parley's `Selection` cannot express.
+    selection: Option<Selection>,
+    history: Vec<(String, Option<Selection>)>,
+    double_hit: Option<usize>,
    pub mode: EditMode,
 }

@@ -25,27 +38,19 @@ impl TextEdit {
    pub fn new(view: TextView, mode: EditMode) -> Self {
        Self {
            view,
-            selection: Default::default(),
+            selection: None,
            history: Default::default(),
            double_hit: None,
            mode,
        }
    }
-    pub fn select_content(&self, start: Cursor, end: Cursor) -> String {
-        let (start, end) = sort_cursors(start, end);
-        let mut iter = self.buf.lines.iter().skip(start.line);
-        let first = iter.next().unwrap();
-        if start.line == end.line {
-            first.text()[start.index..end.index].to_string()
-        } else {
-            let mut str = first.text()[start.index..].to_string();
-            for _ in (start.line + 1)..end.line {
-                str = str + "\n" + iter.next().unwrap().text();
-            }
-            let last = iter.next().unwrap();
-            str = str + "\n" + &last.text()[..end.index];
-            str
+
+    pub fn selected_text(&self) -> Option<String> {
+        let sel = self.selection?;
+        if sel.is_collapsed() {
+            return None;
        }
+        Some(self.buf.text()[sel.text_range()].to_string())
    }
 }

@@ -57,40 +62,30 @@ impl Widget for TextEdit {
        painter.layer = base;
        let region = self.region();

-        let size = vec2(1, self.attrs.line_height);
-        match self.selection {
-            TextSelection::None => (),
-            TextSelection::Pos(cursor) => {
-                if let Some(offset) = cursor_pos(cursor, &self.buf) {
-                    painter.primitive_within(
-                        RectPrimitive::color(Color::WHITE),
-                        size.align(Align::TOP_LEFT).offset(offset).within(&region),
-                    );
-                }
-            }
-            TextSelection::Span { start, end } => {
-                let (start, end) = sort_cursors(start, end);
-                for (l, x, width) in iter_layout_lines(start, end, &self.buf) {
-                    let top_left = vec2(x, self.attrs.line_height * l as f32);
+        let Some(selection) = self.selection else {
+            return;
+        };
+        let layout = self.view.buf.layout();
+
+        // parley reports selection as boxes in layout space, so bidi and
+        // wrapped lines come out right without this code knowing about either.
+        for (rect, _) in selection.geometry(layout) {
+            let size = vec2(rect.width() as f32, rect.height() as f32);
+            let top_left = vec2(rect.x0 as f32, rect.y0 as f32);
            painter.primitive_within(
                RectPrimitive::color(Color::SKY),
-                        size.with_x(width)
-                            .align(Align::TOP_LEFT)
-                            .offset(top_left)
-                            .within(&region),
+                size.align(Align::TOP_LEFT).offset(top_left).within(&region),
            );
        }
-                if let Some(end_offset) = cursor_pos(end, &self.buf) {
+
+        let caret = selection.focus().geometry(layout, CARET_WIDTH);
+        let size = vec2(caret.width() as f32, caret.height() as f32);
+        let top_left = vec2(caret.x0 as f32, caret.y0 as f32);
        painter.primitive_within(
            RectPrimitive::color(Color::WHITE),
-                        size.align(Align::TOP_LEFT)
-                            .offset(end_offset)
-                            .within(&region),
+            size.align(Align::TOP_LEFT).offset(top_left).within(&region),
        );
    }
-            }
-        }
-    }

    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
        self.view.desired_width(ctx)
@@ -101,154 +96,58 @@ impl Widget for TextEdit {
    }
 }

-/// provides top left + width
-fn iter_layout_lines(
-    start: Cursor,
-    end: Cursor,
-    buf: &TextBuffer,
-) -> impl Iterator<Item = (usize, f32, f32)> {
-    gen move {
-        let mut iter = buf.layout_runs().enumerate();
-        for (i, line) in iter.by_ref() {
-            if line.line_i == start.line
-                && let Some(start_x) = index_x(&line, start.index)
-            {
-                if start.line == end.line
-                    && let Some(end_x) = index_x(&line, end.index)
-                {
-                    yield (i, start_x, end_x - start_x);
-                    return;
-                }
-                yield (i, start_x, line.line_w - start_x);
-                break;
-            }
-        }
-        for (i, line) in iter {
-            if line.line_i > end.line {
-                return;
-            }
-            if line.line_i == end.line
-                && let Some(end_x) = index_x(&line, end.index)
-            {
-                yield (i, 0.0, end_x);
-                return;
-            }
-            yield (i, 0.0, line.line_w);
-        }
-    }
-}
-
-/// copied & modified from fn found in Editor in cosmic_text
-/// returns x pos of a (non layout) index within an layout run
-fn index_x(run: &LayoutRun, index: usize) -> Option<f32> {
-    for glyph in run.glyphs.iter() {
-        if index == glyph.start {
-            return Some(glyph.x);
-        } else if index > glyph.start && index < glyph.end {
-            // Guess x offset based on characters
-            let mut before = 0;
-            let mut total = 0;
-
-            let cluster = &run.text[glyph.start..glyph.end];
-            for (i, _) in cluster.grapheme_indices(true) {
-                if glyph.start + i < index {
-                    before += 1;
-                }
-                total += 1;
-            }
-
-            let offset = glyph.w * (before as f32) / (total as f32);
-            return Some(glyph.x + offset);
-        }
-    }
-    None
-}
-
-/// returns top of line segment where cursor should visually select
-fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option<Vec2> {
-    let mut prev = None;
-    for run in buf
-        .layout_runs()
-        .skip_while(|r| r.line_i < cursor.line)
-        .take_while(|r| r.line_i == cursor.line)
-    {
-        prev = Some(vec2(run.line_w, run.line_top));
-        if let Some(pos) = index_x(&run, cursor.index) {
-            return Some(vec2(pos, run.line_top));
-        }
-    }
-    prev
-}
+const CARET_WIDTH: f32 = 1.0;

 pub struct TextEditCtx<'a> {
    pub text: &'a mut TextEdit,
-    pub font_system: &'a mut FontSystem,
+    pub data: &'a mut TextData,
 }

 impl<'a> TextEditCtx<'a> {
+    fn layout(&mut self) -> &Layout<UiColor> {
+        let attrs = self.text.view.attrs.clone();
+        let width = self.text.view.wrap_width();
+        self.text.view.buf.shape(self.data, &attrs, width);
+        self.text.view.buf.layout()
+    }
+
+    fn clamp_selection_to_layout(&mut self) {
+        if let Some(sel) = self.text.selection {
+            let layout = self.layout();
+            self.text.selection = Some(sel.refresh(layout));
+        }
+    }
+
    pub fn take(&mut self) -> String {
-        let text = self
-            .text
-            .buf
-            .lines
-            .drain(..)
-            .map(|l| l.into_text())
-            .collect::<Vec<_>>()
-            .join("\n");
-        self.text
-            .buf
-            .set_text(self.font_system, "", &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
+        let text = std::mem::take(self.text.view.buf.edit());
+        self.text.selection = None;
        text
    }

    pub fn set(&mut self, text: &str) {
        let text = self.string(text);
-        self.text
-            .buf
-            .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
+        self.text.view.buf.set_text(text);
+        self.text.view.buf.changed = true;
+        self.text.selection = None;
    }

    pub fn motion(&mut self, motion: Motion, select: bool) {
-        if let TextSelection::Pos(cursor) = self.text.selection
-            && let Some(new) = self.buf_motion(cursor, motion)
-        {
-            if select {
-                self.text.selection = TextSelection::Span {
-                    start: cursor,
-                    end: new,
+        let Some(sel) = self.text.selection else {
+            return;
        };
-            } else {
-                self.text.selection = TextSelection::Pos(new);
-            }
-        } else if let TextSelection::Span { start, end } = self.text.selection {
-            if select {
-                if let Some(cursor) = self.buf_motion(end, motion) {
-                    self.text.selection = TextSelection::Span { start, end: cursor };
-                }
-            } else {
-                let (start, end) = sort_cursors(start, end);
-                let sel = &mut self.text.selection;
-                match motion {
-                    Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start),
-                    Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end),
-                    _ => {
-                        if let Some(cursor) = self.buf_motion(end, motion) {
-                            self.text.selection = TextSelection::Pos(cursor);
-                        }
-                    }
-                }
-            }
-        }
+        let layout = self.layout();
+        let sel = apply_motion(sel, layout, motion, select);
+        self.text.selection = Some(sel);
    }

+    /// Replace the `len` characters before the caret. This is the IME's
+    /// preedit path: it re-sends the whole composition each time.
    pub fn replace(&mut self, len: usize, text: &str) {
        let text = self.string(text);
        for _ in 0..len {
-            self.delete(false);
+            self.backspace(false);
        }
-        self.insert_inner(&text, false);
+        self.insert_str(&text);
    }

    fn string(&self, text: &str) -> String {
@@ -261,202 +160,173 @@ impl<'a> TextEditCtx<'a> {

    pub fn insert(&mut self, text: &str) {
        let text = self.string(text);
-        let mut lines = text.split('\n');
-        let Some(first) = lines.next() else {
-            return;
-        };
-        self.insert_inner(first, true);
-        for line in lines {
-            self.newline();
-            self.insert_inner(line, true);
+        self.insert_str(&text);
    }
+
+    fn insert_str(&mut self, text: &str) {
+        if text.is_empty() {
+            return;
+        }
+        self.clear_span();
+        let at = match self.text.selection {
+            Some(sel) => sel.focus().index(),
+            None => return,
+        };
+        let at = at.min(self.text.view.buf.text().len());
+        self.text.view.buf.edit().insert_str(at, text);
+        self.text.view.buf.changed = true;
+        self.set_caret(at + text.len());
    }

    pub fn clear_span(&mut self) -> bool {
-        if let TextSelection::Span { start, end } = self.text.selection {
-            self.delete_between(start, end);
-            let (start, _) = sort_cursors(start, end);
-            self.text.selection = TextSelection::Pos(start);
+        let Some(sel) = self.text.selection else {
+            return false;
+        };
+        if sel.is_collapsed() {
+            return false;
+        }
+        let range = sel.text_range();
+        self.text.view.buf.edit().replace_range(range.clone(), "");
+        self.text.view.buf.changed = true;
+        self.set_caret(range.start);
        true
-        } else {
-            false
-        }
    }

-    pub fn delete_between(&mut self, start: Cursor, end: Cursor) {
-        let lines = &mut self.text.view.buf.lines;
-        let (start, end) = sort_cursors(start, end);
-        if start.line == end.line {
-            let line = &mut lines[start.line];
-            let text = line.text();
-            let text = text[..start.index].to_string() + &text[end.index..];
-            edit_line(line, text);
-        } else {
-            // start
-            let start_text = lines[start.line].text()[..start.index].to_string();
-            let end_text = &lines[end.line].text()[end.index..];
-            let text = start_text + end_text;
-            edit_line(&mut lines[start.line], text);
-        }
-        // between
-        let range = (start.line + 1)..=end.line;
-        if !range.is_empty() {
-            lines.splice(range, None);
-        }
-    }
-
-    fn insert_inner(&mut self, text: &str, mov: bool) {
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let line = &mut self.text.view.buf.lines[cursor.line];
-            let mut line_text = line.text().to_string();
-            line_text.insert_str(cursor.index, text);
-            edit_line(line, line_text);
-            if mov {
-                for _ in 0..text.chars().count() {
-                    self.motion(Motion::Right, false);
-                }
-            }
-        }
+    fn set_caret(&mut self, index: usize) {
+        let index = index.min(self.text.view.buf.text().len());
+        let layout = self.layout();
+        self.text.selection = Some(Selection::from_byte_index(
+            layout,
+            index,
+            Affinity::default(),
+        ));
    }

    pub fn newline(&mut self) {
-        if self.text.mode == EditMode::SingleLine {
-            return;
-        }
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let lines = &mut self.text.view.buf.lines;
-            let line = &mut lines[cursor.line];
-            let new = line.split_off(cursor.index);
-            cursor.line += 1;
-            lines.insert(cursor.line, new);
-            cursor.index = 0;
+        if self.text.mode == EditMode::MultiLine {
+            self.insert_str("\n");
        }
    }

    pub fn backspace(&mut self, word: bool) {
-        if !self.clear_span()
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-            && (cursor.index != 0 || cursor.line != 0)
-        {
-            self.motion(if word { Motion::LeftWord } else { Motion::Left }, false);
-            self.delete(word);
+        if self.clear_span() {
+            return;
        }
+        let Some(sel) = self.text.selection else {
+            return;
+        };
+        let end = sel.focus().index();
+        if end == 0 {
+            return;
+        }
+        let layout = self.layout();
+        let start = if word {
+            sel.focus().previous_logical_word(layout).index()
+        } else {
+            let Some(cluster) = sel.focus().logical_clusters(layout)[0] else {
+                return;
+            };
+            let range = cluster.text_range();
+            if cluster.is_hard_line_break() || cluster.is_emoji() {
+                range.start
+            } else {
+                self.text.view.buf.text()[..range.end]
+                    .char_indices()
+                    .next_back()
+                    .map_or(range.start, |(start, _)| start)
+            }
+        };
+        self.delete_range(start, end);
    }

    pub fn delete(&mut self, word: bool) {
-        if !self.clear_span()
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-        {
-            if word {
-                let start = *cursor;
-                if let Some(end) = self.buf_motion(start, Motion::RightWord) {
-                    self.delete_between(start, end);
-                }
-            } else {
-                let lines = &mut self.text.view.buf.lines;
-                let line = &mut lines[cursor.line];
-                if cursor.index == line.text().len() {
-                    if cursor.line == lines.len() - 1 {
+        if self.clear_span() {
            return;
        }
-                    let add = lines.remove(cursor.line + 1).into_text();
-                    let line = &mut lines[cursor.line];
-                    let mut cur = line.text().to_string();
-                    cur.push_str(&add);
-                    edit_line(line, cur);
+        let Some(sel) = self.text.selection else {
+            return;
+        };
+        let start = sel.focus().index();
+        if start >= self.text.view.buf.text().len() {
+            return;
+        }
+        let layout = self.layout();
+        let end = if word {
+            sel.focus().next_logical_word(layout).index()
        } else {
-                    let mut text = line.text().to_string();
-                    text.remove(cursor.index);
-                    edit_line(line, text);
-                }
-            }
-        }
+            let clusters = sel.focus().logical_clusters(layout);
+            let Some(cluster) = clusters[1].as_ref() else {
+                return;
+            };
+            cluster.text_range().end
+        };
+        self.delete_range(start, end);
    }

-    fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option<Cursor> {
-        self.text
-            .buf
-            .cursor_motion(self.font_system, cursor, None, motion)
-            .map(|r| r.0)
+    fn delete_range(&mut self, start: usize, end: usize) {
+        self.text.view.buf.edit().replace_range(start..end, "");
+        self.text.view.buf.changed = true;
+        self.set_caret(start);
    }

-    pub fn select_word_at(&mut self, cursor: Cursor) {
-        if let (Some(start), Some(end)) = (
-            self.buf_motion(cursor, Motion::LeftWord),
-            self.buf_motion(cursor, Motion::RightWord),
-        ) {
-            self.text.selection = TextSelection::Span { start, end };
-        }
-    }
-
-    pub fn select_line_at(&mut self, cursor: Cursor) {
-        let end = self.text.buf.lines[cursor.line].text().len();
-        self.text.selection = TextSelection::Span {
-            start: Cursor::new(cursor.line, 0),
-            end: Cursor::new(cursor.line, end),
+    pub fn select_all(&mut self) {
+        let len = self.text.view.buf.text().len();
+        if len == 0 {
+            return;
        }
+        let layout = self.layout();
+        let anchor = parley::Cursor::from_byte_index(layout, 0, Affinity::default());
+        let focus = parley::Cursor::from_byte_index(layout, len, Affinity::default());
+        self.text.selection = Some(Selection::new(anchor, focus));
    }

    pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
        let pos = pos - self.text.region().top_left().to_abs(size);
-        let hit = self.text.buf.hit(pos.x, pos.y);
-        let sel = &mut self.text.selection;
-        match sel {
-            TextSelection::None => {
-                if !drag && let Some(hit) = hit {
-                    *sel = TextSelection::Pos(hit)
-                }
-            }
-            TextSelection::Pos(pos) => match (hit, drag) {
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => (),
-                (Some(hit), false) => {
-                    if recent && hit == *pos {
-                        self.text.double_hit = Some(hit);
-                        return self.select_word_at(hit);
+        let prev_sel = self.text.selection;
+        let prev_hit = self.text.double_hit;
+
+        let layout = self.layout();
+        let (selection, double_hit) = if drag {
+            let Some(selection) = prev_sel else {
+                return;
+            };
+            (selection.extend_to_point(layout, pos.x, pos.y), prev_hit)
        } else {
-                        *pos = hit
-                    }
-                }
-                (Some(end), true) => *sel = TextSelection::Span { start: *pos, end },
-            },
-            TextSelection::Span { start, end } => match (hit, drag) {
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => *sel = TextSelection::Pos(*start),
-                (Some(hit), false) => {
-                    if recent
-                        && let Some(double) = self.text.double_hit
-                        && double == hit
-                    {
-                        return self.select_line_at(hit);
+            let hit = Selection::from_point(layout, pos.x, pos.y);
+            let index = hit.focus().index();
+            // Successive clicks at one index select the word, then the line.
+            if recent && prev_hit == Some(index) {
+                (Selection::line_from_point(layout, pos.x, pos.y), None)
+            } else if recent && prev_sel.map(|s| s.focus().index()) == Some(index) {
+                (
+                    Selection::word_from_point(layout, pos.x, pos.y),
+                    Some(index),
+                )
            } else {
-                        *sel = TextSelection::Pos(hit)
-                    }
-                }
-                (Some(hit), true) => *end = hit,
-            },
-        }
-        if let TextSelection::Span { start, end } = sel
-            && start == end
-        {
-            *sel = TextSelection::Pos(*start);
+                (hit, None)
            }
+        };
+
+        self.text.selection = Some(selection);
+        self.text.double_hit = double_hit;
    }

    pub fn deselect(&mut self) {
-        self.text.selection = TextSelection::None;
+        self.text.selection = None;
+        self.text.double_hit = None;
    }

    pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
-        let old = (self.text.content(), self.text.selection);
+        let old = (self.text.view.buf.text().to_string(), self.text.selection);
        let mut undo = false;
        let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo && let Some((old, selection)) = self.text.history.pop() {
+        if undo {
+            if let Some((old, selection)) = self.text.history.pop() {
                self.set(&old);
                self.text.selection = selection;
-        } else if self.text.content() != old.0 {
+                self.clamp_selection_to_layout();
+            }
+        } else if self.text.view.buf.text() != old.0 {
            self.text.history.push(old);
        }
        res
@@ -481,21 +351,25 @@ impl<'a> TextEditCtx<'a> {
                    }
                }
                NamedKey::ArrowRight => {
-                    if modifiers.control {
-                        self.motion(Motion::RightWord, modifiers.shift)
+                    let motion = if modifiers.control {
+                        Motion::RightWord
                    } else {
-                        self.motion(Motion::Right, modifiers.shift)
-                    }
+                        Motion::Right
+                    };
+                    self.motion(motion, modifiers.shift);
                }
                NamedKey::ArrowLeft => {
-                    if modifiers.control {
-                        self.motion(Motion::LeftWord, modifiers.shift)
+                    let motion = if modifiers.control {
+                        Motion::LeftWord
                    } else {
-                        self.motion(Motion::Left, modifiers.shift)
-                    }
+                        Motion::Left
+                    };
+                    self.motion(motion, modifiers.shift);
                }
                NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift),
                NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift),
+                NamedKey::Home => self.motion(Motion::LineStart, modifiers.shift),
+                NamedKey::End => self.motion(Motion::LineEnd, modifiers.shift),
                NamedKey::Escape => {
                    self.deselect();
                    return TextInputResult::Unfocus;
@@ -507,34 +381,18 @@ impl<'a> TextEditCtx<'a> {
                    match text.as_str() {
                        "v" => return TextInputResult::Paste,
                        "c" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
-                                let content = self.text.select_content(start, end);
+                            if let Some(content) = self.text.selected_text() {
                                return TextInputResult::Copy(content);
                            }
                        }
                        "x" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
-                                let content = self.text.select_content(start, end);
+                            if let Some(content) = self.text.selected_text() {
                                self.clear_span();
                                return TextInputResult::Copy(content);
                            }
                        }
-                        "a" => {
-                            if !self.text.buf.lines[0].text().is_empty()
-                                || self.text.buf.lines.len() > 1
-                            {
-                                let lines = &self.text.buf.lines;
-                                let last_line = lines.len() - 1;
-                                let last_idx = lines[last_line].text().len();
-                                self.text.selection = TextSelection::Span {
-                                    start: Cursor::new(0, 0),
-                                    end: Cursor::new(last_line, last_idx),
-                                };
-                            }
-                        }
-                        "z" => {
-                            *undo = true;
-                        }
+                        "a" => self.select_all(),
+                        "z" => *undo = true,
                        _ => self.insert(text),
                    }
                } else {
@@ -547,6 +405,24 @@ impl<'a> TextEditCtx<'a> {
    }
 }

+fn apply_motion(
+    sel: Selection,
+    layout: &Layout<UiColor>,
+    motion: Motion,
+    extend: bool,
+) -> Selection {
+    match motion {
+        Motion::Left => sel.previous_visual(layout, extend),
+        Motion::Right => sel.next_visual(layout, extend),
+        Motion::LeftWord => sel.previous_visual_word(layout, extend),
+        Motion::RightWord => sel.next_visual_word(layout, extend),
+        Motion::Up => sel.previous_line(layout, extend),
+        Motion::Down => sel.next_line(layout, extend),
+        Motion::LineStart => sel.line_start(layout, extend),
+        Motion::LineEnd => sel.line_end(layout, extend),
+    }
+}
+
 #[derive(Default)]
 pub struct Modifiers {
    pub shift: bool,
@@ -569,33 +445,6 @@ pub enum TextInputResult {
    Paste,
 }

-#[derive(Debug, Default, Clone, Copy)]
-pub enum TextSelection {
-    #[default]
-    None,
-    Pos(Cursor),
-    Span {
-        start: Cursor,
-        end: Cursor,
-    },
-}
-
-impl TextSelection {
-    pub fn clear(&mut self) {
-        match self {
-            TextSelection::None => (),
-            TextSelection::Pos(cursor) => {
-                cursor.line = 0;
-                cursor.index = 0;
-                cursor.affinity = Affinity::default();
-            }
-            TextSelection::Span { start: _, end: _ } => {
-                *self = TextSelection::None;
-            }
-        }
-    }
-}
-
 impl TextInputResult {
    pub fn unfocus(&self) -> bool {
        matches!(self, TextInputResult::Unfocus)
@@ -625,7 +474,7 @@ impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
        let ui = ui.ui_mut();
        TextEditCtx {
            text: ui.widgets.get_mut(self).unwrap(),
-            font_system: &mut ui.text.font_system,
+            data: &mut ui.text,
        }
    }
 }
@@ -6,11 +6,8 @@ pub use edit::*;
 use iris_core::util::MutDetect;

 use crate::prelude::*;
-use cosmic_text::{Attrs, BufferLine, Cursor, Metrics, Shaping};
 use std::ops::{Deref, DerefMut};

-pub const SHAPING: Shaping = Shaping::Advanced;
-
 pub struct Text {
    pub content: MutDetect<String>,
    view: TextView,
@@ -25,6 +22,16 @@ pub struct TextView {
    pub hint: Option<StrongWidget>,
 }

+impl TextView {
+    fn is_empty(&self) -> bool {
+        self.buf.is_empty()
+    }
+
+    pub fn wrap_width(&self) -> Option<f32> {
+        self.width
+    }
+}
+
 impl TextView {
    pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<StrongWidget>) -> Self {
        Self {
@@ -45,45 +52,26 @@ impl TextView {
            .align(self.align)
    }

-    fn tex_region(&self, tex: &RenderedText) -> UiRegion {
-        let region = tex.size.align(self.align);
-        let dims = tex.handle.size();
-        let mut region = region.offset(tex.top_left_offset);
-        region.x.end = region.x.start + UiScalar::abs(dims.x);
-        region.y.end = region.y.start + UiScalar::abs(dims.y);
-        region
-    }
-
-    fn render(&mut self, ctx: &mut SizeCtx) -> RenderedText {
+    fn render(&mut self, ctx: &mut SizeCtx) -> &RenderedText {
        let width = if self.attrs.wrap {
            Some(ctx.px_size().x)
        } else {
            None
        };
-        if width == self.width
-            && let Some(tex) = &self.tex
-            && !self.attrs.changed
-            && !self.buf.changed
-        {
-            return tex.clone();
-        }
+        if width != self.width || self.tex.is_none() || self.attrs.changed || self.buf.changed {
            self.width = width;
-        let font_system = &mut ctx.text.font_system;
-        self.attrs.apply(font_system, &mut self.buf, width);
-        self.buf.shape_until_scroll(font_system, false);
-        let tex = ctx.draw_text(&mut self.buf, &self.attrs);
-        self.tex = Some(tex.clone());
+            self.tex = Some(ctx.draw_text(&mut self.buf, &self.attrs, width));
            self.attrs.changed = false;
            self.buf.changed = false;
-        tex
+        }
+        self.tex.as_ref().unwrap()
    }
    pub fn tex(&self) -> Option<&RenderedText> {
        self.tex.as_ref()
    }
    pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(hint) = &self.hint
-            && let [line] = &self.buf.lines[..]
-            && line.text().is_empty()
+        if self.is_empty()
+            && let Some(hint) = &self.hint
        {
            ctx.width(hint)
        } else {
@@ -91,9 +79,8 @@ impl TextView {
        }
    }
    pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(hint) = &self.hint
-            && let [line] = &self.buf.lines[..]
-            && line.text().is_empty()
+        if self.is_empty()
+            && let Some(hint) = &self.hint
        {
            ctx.height(hint)
        } else {
@@ -101,48 +88,39 @@ impl TextView {
        }
    }
    pub fn draw(&mut self, painter: &mut Painter) -> UiRegion {
-        let tex = self.render(&mut painter.size_ctx());
-        let region = self.tex_region(&tex);
-        if let Some(hint) = &self.hint
-            && let [line] = &self.buf.lines[..]
-            && line.text().is_empty()
-        {
+        let align = self.align;
+        if self.is_empty() && self.hint.is_some() {
+            let region = self.render(&mut painter.size_ctx()).size.align(align);
+            if let Some(hint) = &self.hint {
                painter.widget(hint);
-        } else {
-            painter.texture_within(&tex.handle, region);
            }
+            return region;
+        }
+
+        let tex = self.render(&mut painter.size_ctx());
+        let region = tex.size.align(align);
+        let within = region.within(&painter.region());
+        painter.glyphs(tex, within);
        region
    }

    pub fn content(&self) -> String {
-        self.buf
-            .lines
-            .iter()
-            .map(|l| l.text())
-            .collect::<Vec<_>>()
-            .join("\n")
+        self.buf.text().to_string()
    }
 }

 impl Text {
    pub fn new(content: impl Into<String>) -> Self {
-        let attrs = TextAttrs::default();
-        let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height));
+        let content: String = content.into();
        Self {
-            content: content.into().into(),
-            view: TextView::new(buf, attrs, None),
+            view: TextView::new(TextBuffer::new(&content), TextAttrs::default(), None),
+            content: content.into(),
        }
    }
-    fn update_buf(&mut self, ctx: &mut SizeCtx) {
+    fn update_buf(&mut self, _ctx: &mut SizeCtx) {
        if self.content.changed {
            self.content.changed = false;
-            self.view.buf.set_text(
-                &mut ctx.text.font_system,
-                &self.content,
-                &Attrs::new().family(self.view.attrs.family),
-                SHAPING,
-                None,
-            );
+            self.view.buf.set_text(self.content.as_str());
        }
    }
 }
@@ -164,16 +142,6 @@ impl Widget for Text {
    }
 }

-pub fn sort_cursors(a: Cursor, b: Cursor) -> (Cursor, Cursor) {
-    let start = a.min(b);
-    let end = a.max(b);
-    (start, end)
-}
-
-pub fn edit_line(line: &mut BufferLine, text: String) {
-    line.set_text(text, line.ending(), line.attrs_list().clone());
-}
-
 impl Deref for Text {
    type Target = TextAttrs;

@@ -0,0 +1,67 @@
+use iris::prelude::*;
+
+fn editor(text: &str, mode: EditMode) -> (TextEdit, TextData) {
+    let view = TextView::new(TextBuffer::new(text), TextAttrs::default(), None);
+    (TextEdit::new(view, mode), TextData::default())
+}
+
+fn press(edit: &mut TextEditCtx<'_>, x: f32) {
+    edit.select(vec2(x, 10.0), vec2(400.0, 200.0), false, false);
+}
+
+#[test]
+fn pressing_an_empty_field_places_input() {
+    let (mut text, mut data) = editor("", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, 40.0);
+    edit.insert("hello");
+
+    assert_eq!(edit.text.content(), "hello");
+}
+
+#[test]
+fn preedit_replaces_the_previous_composition() {
+    let (mut text, mut data) = editor("", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, 0.0);
+    edit.replace(0, "に");
+    edit.replace(1, "日本");
+
+    assert_eq!(edit.text.content(), "日本");
+}
+
+#[test]
+fn backspace_respects_utf8_boundaries() {
+    let (mut text, mut data) = editor("aé", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, f32::MAX);
+    edit.backspace(false);
+
+    assert_eq!(edit.text.content(), "a");
+}
+
+#[test]
+fn typing_replaces_the_selection() {
+    let (mut text, mut data) = editor("hello", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    edit.select_all();
+    edit.insert("goodbye");
+
+    assert_eq!(edit.text.content(), "goodbye");
+}