rename grapheme to code-point-utf8

Longer name, but it doesn't lie. We have no data structure right now for
combining multiple code points. And it makes no sense for the notion of
a grapheme to conflate its Unicode encoding.

55 files changed, 1403 insertions, 1408 deletions

diff --git a/126write-int-decimal.subx b/126write-int-decimal.subx
index d30cb762..f61538b8 100644
--- a/126write-int-decimal.subx
+++ b/126write-int-decimal.subx
@@ -324,7 +324,7 @@ test-write-int32-decimal-negative-multiple-digits:
     # . end
     c3/return
 
-decimal-digit?:  # c: grapheme -> result/eax: boolean
+decimal-digit?:  # c: code-point-utf8 -> result/eax: boolean
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -423,7 +423,7 @@ test-decimal-digit-above-9:
     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     c3/return
 
-to-decimal-digit:  # in: grapheme -> out/eax: int
+to-decimal-digit:  # in: code-point-utf8 -> out/eax: int
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/400.mu b/400.mu
index 9baad977..495e57ce 100644
--- a/400.mu
+++ b/400.mu
@@ -97,8 +97,8 @@ sig write-slice out: (addr stream byte), s: (addr slice)
 # bad name alert
 sig slice-to-string ad: (addr allocation-descriptor), in: (addr slice), out: (addr handle array byte)
 sig write-int32-decimal out: (addr stream byte), n: int
-sig decimal-digit? c: grapheme -> _/eax: boolean
-sig to-decimal-digit in: grapheme -> _/eax: int
+sig decimal-digit? c: code-point-utf8 -> _/eax: boolean
+sig to-decimal-digit in: code-point-utf8 -> _/eax: int
 # bad name alert
 # next-word really tokenizes
 # next-raw-word really reads whitespace-separated words
diff --git a/403unicode.mu b/403unicode.mu
index e1bfba3f..5d465d71 100644
--- a/403unicode.mu
+++ b/403unicode.mu
@@ -1,16 +1,11 @@
 # Helpers for Unicode.
 #
-# Mu has no characters, only code points and graphemes.
-# Code points are the indivisible atoms of text streams.
+# The basic unit for rendering Unicode is the code point.
 #   https://en.wikipedia.org/wiki/Code_point
-# Graphemes are the smallest self-contained unit of text.
-# Graphemes may consist of multiple code points.
+# The glyph a non-cursive font displays may represent multiple code points.
 #
-# Mu graphemes are always represented in utf-8, and they are required to fit
-# in 4 bytes. (This can be confusing if you focus just on ASCII, where Mu's
-# graphemes and code-points are identical.)
-#
-# Mu doesn't yet support graphemes consisting of multiple code points.
+# In addition to raw code points (just integers assigned special meaning), Mu
+# provides a common encoding as a convenience: code-point-utf8.
 
 fn test-unicode-serialization-and-deserialization {
   var i/ebx: int <- copy 0
@@ -20,8 +15,8 @@ fn test-unicode-serialization-and-deserialization {
                         # but not emoji
     break-if->=
     var c/eax: code-point <- copy i
-    var _g/eax: grapheme <- to-grapheme c
-    var g/ecx: grapheme <- copy _g
+    var _g/eax: code-point-utf8 <- to-utf8 c
+    var g/ecx: code-point-utf8 <- copy _g
     var c2/eax: code-point <- to-code-point g
     compare i, c2
     {
@@ -51,7 +46,7 @@ fn test-unicode-serialization-and-deserialization {
 }
 
 # transliterated from tb_utf8_char_to_unicode in https://github.com/nsf/termbox
-fn to-code-point in: grapheme -> _/eax: code-point {
+fn to-code-point in: code-point-utf8 -> _/eax: code-point {
   var g/ebx: int <- copy in
   # if single byte, just return it
   {
@@ -61,7 +56,7 @@ fn to-code-point in: grapheme -> _/eax: code-point {
     return result
   }
   #
-  var len/edx: int <- grapheme-length in
+  var len/edx: int <- utf8-length in
   # extract bits from first byte
   var b/eax: byte <- copy-byte g
   var result/edi: code-point <- copy b
@@ -99,16 +94,16 @@ fn to-code-point in: grapheme -> _/eax: code-point {
 
 # transliterated from tb_utf8_unicode_to_char in https://github.com/nsf/termbox
 # https://wiki.tcl-lang.org/page/UTF%2D8+bit+by+bit explains the algorithm
-fn to-grapheme in: code-point -> _/eax: grapheme {
+fn to-utf8 in: code-point -> _/eax: code-point-utf8 {
   var c/eax: int <- copy in
   var num-trailers/ecx: int <- copy 0
   var first/edx: int <- copy 0
-  $to-grapheme:compute-length: {
+  $to-utf8:compute-length: {
     # single byte: just return it
     compare c, 0x7f
     {
       break-if->
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     # 2 bytes
@@ -117,7 +112,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
       break-if->
       num-trailers <- copy 1
       first <- copy 0xc0
-      break $to-grapheme:compute-length
+      break $to-utf8:compute-length
     }
     # 3 bytes
     compare c, 0xffff
@@ -125,7 +120,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
       break-if->
       num-trailers <- copy 2
       first <- copy 0xe0
-      break $to-grapheme:compute-length
+      break $to-utf8:compute-length
     }
     # 4 bytes
     compare c, 0x1fffff
@@ -133,7 +128,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
       break-if->
       num-trailers <- copy 3
       first <- copy 0xf0
-      break $to-grapheme:compute-length
+      break $to-utf8:compute-length
     }
     # more than 4 bytes: unsupported
     compare c, 0x1fffff
@@ -144,7 +139,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
     }
   }
   # emit trailer bytes, 6 bits from 'in', first two bits '10'
-  var result/edi: grapheme <- copy 0
+  var result/edi: code-point-utf8 <- copy 0
   {
     compare num-trailers, 0
     break-if-<=
@@ -166,16 +161,16 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
   return result
 }
 
-# single-byte code point have identical graphemes
-fn test-to-grapheme-single-byte {
+# single-byte code point have identical code-point-utf8s
+fn test-to-utf8-single-byte {
   var in-int/ecx: int <- copy 0
   {
     compare in-int, 0x7f
     break-if->
     var in/eax: code-point <- copy in-int
-    var out/eax: grapheme <- to-grapheme in
+    var out/eax: code-point-utf8 <- to-utf8 in
     var out-int/eax: int <- copy out
-    check-ints-equal out-int, in-int, "F - test-to-grapheme-single-byte"
+    check-ints-equal out-int, in-int, "F - test-to-utf8-single-byte"
     in-int <- increment
     loop
   }
@@ -183,55 +178,55 @@ fn test-to-grapheme-single-byte {
 
                                                               # byte       | byte      | byte      | byte
 # smallest 2-byte utf-8
-fn test-to-grapheme-two-bytes-min {
+fn test-to-utf8-two-bytes-min {
   var in/eax: code-point <- copy 0x80                         #                                 10     00-0000
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0x80c2, "F - to-grapheme/2a"      #                         110 0-0010  10 00-0000
+  check-ints-equal out-int, 0x80c2, "F - to-utf8/2a"      #                         110 0-0010  10 00-0000
 }
 
 # largest 2-byte utf-8
-fn test-to-grapheme-two-bytes-max {
+fn test-to-utf8-two-bytes-max {
   var in/eax: code-point <- copy 0x7ff                        #                             1-1111     11-1111
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0xbfdf, "F - to-grapheme/2b"      #                         110 1-1111  10 11-1111
+  check-ints-equal out-int, 0xbfdf, "F - to-utf8/2b"      #                         110 1-1111  10 11-1111
 }
 
 # smallest 3-byte utf-8
-fn test-to-grapheme-three-bytes-min {
+fn test-to-utf8-three-bytes-min {
   var in/eax: code-point <- copy 0x800                        #                            10-0000     00-0000
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0x80a0e0, "F - to-grapheme/3a"    #              1110 0000  10 10-0000  10 00-0000
+  check-ints-equal out-int, 0x80a0e0, "F - to-utf8/3a"    #              1110 0000  10 10-0000  10 00-0000
 }
 
 # largest 3-byte utf-8
-fn test-to-grapheme-three-bytes-max {
+fn test-to-utf8-three-bytes-max {
   var in/eax: code-point <- copy 0xffff                       #                   1111     11-1111     11-1111
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0xbfbfef, "F - to-grapheme/3b"    #              1110 1111  10 11-1111  10 11-1111
+  check-ints-equal out-int, 0xbfbfef, "F - to-utf8/3b"    #              1110 1111  10 11-1111  10 11-1111
 }
 
 # smallest 4-byte utf-8
-fn test-to-grapheme-four-bytes-min {
+fn test-to-utf8-four-bytes-min {
   var in/eax: code-point <- copy 0x10000                      #                 1-0000     00-0000     00-0000
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0x808090f0, "F - to-grapheme/4a"  # 1111-0 000  10 01-0000  10 00-0000  10 00-0000
+  check-ints-equal out-int, 0x808090f0, "F - to-utf8/4a"  # 1111-0 000  10 01-0000  10 00-0000  10 00-0000
 }
 
 # largest 4-byte utf-8
-fn test-to-grapheme-four-bytes-max {
+fn test-to-utf8-four-bytes-max {
   var in/eax: code-point <- copy 0x1fffff                     #        111     11-1111     11-1111     11-1111
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0xbfbfbff7, "F - to-grapheme/4b"  # 1111-0 111  10 11-1111  10 11-1111  10 11-1111
+  check-ints-equal out-int, 0xbfbfbff7, "F - to-utf8/4b"  # 1111-0 111  10 11-1111  10 11-1111  10 11-1111
 }
 
-# read the next grapheme from a stream of bytes
-fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
+# read the next code-point-utf8 from a stream of bytes
+fn read-code-point-utf8 in: (addr stream byte) -> _/eax: code-point-utf8 {
   # if at eof, return EOF
   {
     var eof?/eax: boolean <- stream-empty? in
@@ -241,18 +236,18 @@ fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
   }
   var c/eax: byte <- read-byte in
   var num-trailers/ecx: int <- copy 0
-  $read-grapheme:compute-length: {
+  $read-code-point-utf8:compute-length: {
     # single byte: just return it
     compare c, 0xc0
     {
       break-if->=
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     compare c, 0xfe
     {
       break-if-<
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     # 2 bytes
@@ -260,27 +255,27 @@ fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
     {
       break-if->=
       num-trailers <- copy 1
-      break $read-grapheme:compute-length
+      break $read-code-point-utf8:compute-length
     }
     # 3 bytes
     compare c, 0xf0
     {
       break-if->=
       num-trailers <- copy 2
-      break $read-grapheme:compute-length
+      break $read-code-point-utf8:compute-length
     }
     # 4 bytes
     compare c, 0xf8
     {
       break-if->=
       num-trailers <- copy 3
-      break $read-grapheme:compute-length
+      break $read-code-point-utf8:compute-length
     }
     abort "utf-8 encodings larger than 4 bytes are not yet supported"
     return 0
   }
   # prepend trailer bytes
-  var result/edi: grapheme <- copy c
+  var result/edi: code-point-utf8 <- copy c
   var num-byte-shifts/edx: int <- copy 1
   {
     compare num-trailers, 0
@@ -297,34 +292,34 @@ fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
   return result
 }
 
-fn test-read-grapheme {
+fn test-read-code-point-utf8 {
   var s: (stream byte 0x30)
   var s2/ecx: (addr stream byte) <- address s
   write s2, "aΒc世d界e"
-  var c/eax: grapheme <- read-grapheme s2
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x61, "F - test grapheme/0"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x61, "F - test code-point-utf8/0"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x92ce/greek-capital-letter-beta, "F - test grapheme/1"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x92ce/greek-capital-letter-beta, "F - test code-point-utf8/1"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x63, "F - test grapheme/2"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x63, "F - test code-point-utf8/2"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x96b8e4, "F - test grapheme/3"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x96b8e4, "F - test code-point-utf8/3"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x64, "F - test grapheme/4"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x64, "F - test code-point-utf8/4"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x8c95e7, "F - test grapheme/5"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x8c95e7, "F - test code-point-utf8/5"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x65, "F - test grapheme/6"
+  check-ints-equal n, 0x65, "F - test code-point-utf8/6"
 }
 
-fn grapheme-length g: grapheme -> _/edx: int {
+fn utf8-length g: code-point-utf8 -> _/edx: int {
   {
     compare g, 0xff
     break-if->
@@ -389,23 +384,23 @@ fn test-shift-left-bytes-5 {
   check-ints-equal result, 0, "F - shift-left-bytes >4"
 }
 
-# write a grapheme to a stream of bytes
+# write a code-point-utf8 to a stream of bytes
 # this is like write-to-stream, except we skip leading 0 bytes
-fn write-grapheme out: (addr stream byte), g: grapheme {
-$write-grapheme:body: {
+fn write-code-point-utf8 out: (addr stream byte), g: code-point-utf8 {
+$write-code-point-utf8:body: {
   var c/eax: int <- copy g
   append-byte out, c  # first byte is always written
   c <- shift-right 8
   compare c, 0
-  break-if-= $write-grapheme:body
+  break-if-= $write-code-point-utf8:body
   append-byte out, c
   c <- shift-right 8
   compare c, 0
-  break-if-= $write-grapheme:body
+  break-if-= $write-code-point-utf8:body
   append-byte out, c
   c <- shift-right 8
   compare c, 0
-  break-if-= $write-grapheme:body
+  break-if-= $write-code-point-utf8:body
   append-byte out, c
 }
 }
diff --git a/411string.mu b/411string.mu
index cf0471ac..493c9b56 100644
--- a/411string.mu
+++ b/411string.mu
@@ -1,4 +1,4 @@
-# read up to 'len' graphemes after skipping the first 'start' ones
+# read up to 'len' code-point-utf8s after skipping the first 'start' ones
 fn substring in: (addr array byte), start: int, len: int, out-ah: (addr handle array byte) {
   var in-stream: (stream byte 0x100)
   var in-stream-addr/esi: (addr stream byte) <- address in-stream
@@ -6,29 +6,29 @@ fn substring in: (addr array byte), start: int, len: int, out-ah: (addr handle a
   var out-stream: (stream byte 0x100)
   var out-stream-addr/edi: (addr stream byte) <- address out-stream
   $substring:core: {
-    # skip 'start' graphemes
+    # skip 'start' code-point-utf8s
     var i/eax: int <- copy 0
     {
       compare i, start
       break-if->=
       {
-        var dummy/eax: grapheme <- read-grapheme in-stream-addr
+        var dummy/eax: code-point-utf8 <- read-code-point-utf8 in-stream-addr
         compare dummy, 0xffffffff/end-of-file
         break-if-= $substring:core
       }
       i <- increment
       loop
     }
-    # copy 'len' graphemes
+    # copy 'len' code-point-utf8s
     i <- copy 0
     {
       compare i, len
       break-if->=
       {
-        var g/eax: grapheme <- read-grapheme in-stream-addr
+        var g/eax: code-point-utf8 <- read-code-point-utf8 in-stream-addr
         compare g, 0xffffffff/end-of-file
         break-if-= $substring:core
-        write-grapheme out-stream-addr, g
+        write-code-point-utf8 out-stream-addr, g
       }
       i <- increment
       loop
@@ -85,7 +85,7 @@ fn test-substring {
   check-strings-equal out, "bcde", "F - test-substring/middle-too-small"
 }
 
-fn split-string in: (addr array byte), delim: grapheme, out: (addr handle array (handle array byte)) {
+fn split-string in: (addr array byte), delim: code-point-utf8, out: (addr handle array (handle array byte)) {
   var in-stream: (stream byte 0x100)
   var in-stream-addr/esi: (addr stream byte) <- address in-stream
   write in-stream-addr, in
@@ -94,10 +94,10 @@ fn split-string in: (addr array byte), delim: grapheme, out: (addr handle array
   var curr-stream: (stream byte 0x100)
   var curr-stream-addr/ecx: (addr stream byte) <- address curr-stream
   $split-string:core: {
-    var g/eax: grapheme <- read-grapheme in-stream-addr
+    var g/eax: code-point-utf8 <- read-code-point-utf8 in-stream-addr
     compare g, 0xffffffff
     break-if-=
-#?     print-grapheme-to-real-screen g
+#?     print-code-point-utf8-to-real-screen g
 #?     print-string-to-real-screen "\n"
     compare g, delim
     {
@@ -110,7 +110,7 @@ fn split-string in: (addr array byte), delim: grapheme, out: (addr handle array
       clear-stream curr-stream-addr
       loop $split-string:core
     }
-    write-grapheme curr-stream-addr, g
+    write-code-point-utf8 curr-stream-addr, g
     loop
   }
   stream-to-array tokens-stream-addr, out
diff --git a/500fake-screen.mu b/500fake-screen.mu
index c34beeaa..f86ce47c 100644
--- a/500fake-screen.mu
+++ b/500fake-screen.mu
@@ -71,7 +71,7 @@ fn initialize-screen _screen: (addr screen), width: int, height: int, pixel-grap
   copy-to *dest, 0
 }
 
-# in graphemes
+# in code-point-utf8s
 fn screen-size _screen: (addr screen) -> _/eax: int, _/ecx: int {
   var screen/esi: (addr screen) <- copy _screen
   var width/eax: int <- copy 0
@@ -459,7 +459,7 @@ fn clear-rect _screen: (addr screen), xmin: int, ymin: int, xmax: int, ymax: int
   set-cursor-position screen, 0, 0
 }
 
-# there's no grapheme that guarantees to cover every pixel, so we'll bump down
+# there's no code-point-utf8 that guarantees to cover every pixel, so we'll bump down
 # to pixels for a real screen
 fn clear-real-screen {
   var y/eax: int <- copy 0
diff --git a/501draw-text.mu b/501draw-text.mu
index 5d2917a9..66260b56 100644
--- a/501draw-text.mu
+++ b/501draw-text.mu
@@ -117,7 +117,7 @@ fn draw-text-rightward screen: (addr screen), text: (addr array byte), x: int, x
 fn draw-stream-rightward screen: (addr screen), stream: (addr stream byte), x: int, xmax: int, y: int, color: int, background-color: int -> _/eax: int {
   var xcurr/ecx: int <- copy x
   {
-    var g/eax: grapheme <- read-grapheme stream
+    var g/eax: code-point-utf8 <- read-code-point-utf8 stream
     compare g, 0xffffffff/end-of-file
     break-if-=
     var c/eax: code-point <- to-code-point g
@@ -218,7 +218,7 @@ fn draw-stream-wrapping-right-then-down screen: (addr screen), stream: (addr str
         next-c <- copy 0
         break $draw-stream-wrapping-right-then-down:read-base
       }
-      var g/eax: grapheme <- read-grapheme stream
+      var g/eax: code-point-utf8 <- read-code-point-utf8 stream
       var _c/eax: code-point <- to-code-point g
       c <- copy _c
     }
@@ -240,7 +240,7 @@ fn draw-stream-wrapping-right-then-down screen: (addr screen), stream: (addr str
       compare done?, 0/false
       break-if-!=
       # read a character
-      var g/eax: grapheme <- read-grapheme stream
+      var g/eax: code-point-utf8 <- read-code-point-utf8 stream
       var c/eax: code-point <- to-code-point g
       # if not a combining character, save for next iteration and loop
       {
@@ -343,7 +343,7 @@ fn draw-int32-hex-wrapping-right-then-down screen: (addr screen), n: int, xmin:
   var xcurr/edx: int <- copy x
   var ycurr/ecx: int <- copy y
   {
-    var g/eax: grapheme <- read-grapheme stream
+    var g/eax: code-point-utf8 <- read-code-point-utf8 stream
     compare g, 0xffffffff/end-of-file
     break-if-=
     var c/eax: code-point <- to-code-point g
@@ -398,7 +398,7 @@ fn draw-int32-decimal-wrapping-right-then-down screen: (addr screen), n: int, xm
   var xcurr/edx: int <- copy x
   var ycurr/ecx: int <- copy y
   {
-    var g/eax: grapheme <- read-grapheme stream
+    var g/eax: code-point-utf8 <- read-code-point-utf8 stream
     compare g, 0xffffffff/end-of-file
     break-if-=
     var c/eax: code-point <- to-code-point g
@@ -466,7 +466,7 @@ fn draw-text-downward screen: (addr screen), text: (addr array byte), x: int, y:
 fn draw-stream-downward screen: (addr screen), stream: (addr stream byte), x: int, y: int, ymax: int, color: int, background-color: int -> _/eax: int {
   var ycurr/ecx: int <- copy y
   {
-    var g/eax: grapheme <- read-grapheme stream
+    var g/eax: code-point-utf8 <- read-code-point-utf8 stream
     compare g, 0xffffffff/end-of-file
     break-if-=
     var c/eax: code-point <- to-code-point g
@@ -508,7 +508,7 @@ fn draw-stream-wrapping-down-then-right screen: (addr screen), stream: (addr str
   var xcurr/edx: int <- copy x
   var ycurr/ecx: int <- copy y
   {
-    var g/eax: grapheme <- read-grapheme stream
+    var g/eax: code-point-utf8 <- read-code-point-utf8 stream
     compare g, 0xffffffff/end-of-file
     break-if-=
     var c/eax: code-point <- to-code-point g
diff --git a/504test-screen.mu b/504test-screen.mu
index 64b378dd..f6bdae3b 100644
--- a/504test-screen.mu
+++ b/504test-screen.mu
@@ -12,7 +12,7 @@ fn check-screen-row-from _screen: (addr screen), x: int, y: int, expected: (addr
   var screen/esi: (addr screen) <- copy _screen
   var failure-count/edi: int <- copy 0
   var index/ecx: int <- screen-cell-index screen, x, y
-  # compare 'expected' with the screen contents starting at 'index', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'index', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -26,16 +26,16 @@ fn check-screen-row-from _screen: (addr screen), x: int, y: int, expected: (addr
       break-if-!=
       var _c/eax: code-point <- screen-code-point-at-index screen, index
       var c/ebx: code-point <- copy _c
-      var expected-grapheme/eax: grapheme <- read-grapheme e-addr
-      var expected-code-point/eax: code-point <- to-code-point expected-grapheme
-      # compare graphemes
-      $check-screen-row-from:compare-graphemes: {
-        # if expected-code-point is space, null grapheme is also ok
+      var expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+      var expected-code-point/eax: code-point <- to-code-point expected-code-point-utf8
+      # compare code-point-utf8s
+      $check-screen-row-from:compare-code-point-utf8s: {
+        # if expected-code-point is space, null code-point-utf8 is also ok
         {
           compare expected-code-point, 0x20
           break-if-!=
           compare c, 0
-          break-if-= $check-screen-row-from:compare-graphemes
+          break-if-= $check-screen-row-from:compare-code-point-utf8s
         }
         # if (c == expected-code-point) print "."
         compare c, expected-code-point
@@ -79,7 +79,7 @@ fn check-screen-row-in-color screen: (addr screen), fg: int, y: int, expected: (
 fn check-screen-row-in-color-from _screen: (addr screen), fg: int, y: int, x: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy _screen
   var index/ecx: int <- screen-cell-index screen, x, y
-  # compare 'expected' with the screen contents starting at 'index', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'index', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -93,11 +93,11 @@ fn check-screen-row-in-color-from _screen: (addr screen), fg: int, y: int, x: in
       break-if-!=
       var _c/eax: code-point <- screen-code-point-at-index screen, index
       var c/ebx: code-point <- copy _c
-      var expected-grapheme/eax: grapheme <- read-grapheme e-addr
-      var _expected-code-point/eax: code-point <- to-code-point expected-grapheme
+      var expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+      var _expected-code-point/eax: code-point <- to-code-point expected-code-point-utf8
       var expected-code-point/edi: code-point <- copy _expected-code-point
       $check-screen-row-in-color-from:compare-cells: {
-        # if expected-code-point is space, null grapheme is also ok
+        # if expected-code-point is space, null code-point-utf8 is also ok
         {
           compare expected-code-point, 0x20
           break-if-!=
@@ -112,14 +112,14 @@ fn check-screen-row-in-color-from _screen: (addr screen), fg: int, y: int, x: in
           compare color, fg
           break-if-!= $check-screen-row-in-color-from:compare-cells
         }
-        # compare graphemes
-        $check-screen-row-in-color-from:compare-graphemes: {
+        # compare code-point-utf8s
+        $check-screen-row-in-color-from:compare-code-point-utf8s: {
           # if (c == expected-code-point) print "."
           compare c, expected-code-point
           {
             break-if-!=
             draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, ".", 3/fg=cyan, 0/bg
-            break $check-screen-row-in-color-from:compare-graphemes
+            break $check-screen-row-in-color-from:compare-code-point-utf8s
           }
           # otherwise print an error
           count-test-failure
@@ -173,7 +173,7 @@ fn check-screen-row-in-background-color screen: (addr screen), bg: int, y: int,
 fn check-screen-row-in-background-color-from _screen: (addr screen), bg: int, y: int, x: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy _screen
   var index/ecx: int <- screen-cell-index screen, x, y
-  # compare 'expected' with the screen contents starting at 'index', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'index', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -187,11 +187,11 @@ fn check-screen-row-in-background-color-from _screen: (addr screen), bg: int, y:
       break-if-!=
       var _g/eax: code-point <- screen-code-point-at-index screen, index
       var g/ebx: code-point <- copy _g
-      var expected-grapheme/eax: grapheme <- read-grapheme e-addr
-      var _expected-code-point/eax: code-point <- to-code-point expected-grapheme
+      var expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+      var _expected-code-point/eax: code-point <- to-code-point expected-code-point-utf8
       var expected-code-point/edi: code-point <- copy _expected-code-point
       $check-screen-row-in-background-color-from:compare-cells: {
-        # if expected-code-point is space, null grapheme is also ok
+        # if expected-code-point is space, null code-point-utf8 is also ok
         {
           compare expected-code-point, 0x20
           break-if-!=
@@ -206,14 +206,14 @@ fn check-screen-row-in-background-color-from _screen: (addr screen), bg: int, y:
           compare background-color, bg
           break-if-!= $check-screen-row-in-background-color-from:compare-cells
         }
-        # compare graphemes
-        $check-screen-row-in-background-color-from:compare-graphemes: {
+        # compare code-point-utf8s
+        $check-screen-row-in-background-color-from:compare-code-point-utf8s: {
           # if (g == expected-code-point) print "."
           compare g, expected-code-point
           {
             break-if-!=
             draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, ".", 3/fg=cyan, 0/bg
-            break $check-screen-row-in-background-color-from:compare-graphemes
+            break $check-screen-row-in-background-color-from:compare-code-point-utf8s
           }
           # otherwise print an error
           count-test-failure
@@ -228,7 +228,7 @@ fn check-screen-row-in-background-color-from _screen: (addr screen), bg: int, y:
           draw-code-point-at-cursor-over-full-screen 0/screen, g, 3/cyan, 0/bg
           draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, "'", 3/fg=cyan, 0/bg
           move-cursor-to-left-margin-of-next-line 0/screen
-          break $check-screen-row-in-background-color-from:compare-graphemes
+          break $check-screen-row-in-background-color-from:compare-code-point-utf8s
         }
         $check-screen-row-in-background-color-from:compare-background-colors: {
           var background-color/eax: int <- screen-background-color-at-index screen, index
@@ -284,8 +284,8 @@ fn check-background-color-in-screen-row-from _screen: (addr screen), bg: int, y:
       var unused?/eax: boolean <- screen-cell-unused-at-index? screen, index
       compare unused?, 0/false
       break-if-!=
-      var _expected-bit/eax: grapheme <- read-grapheme e-addr
-      var expected-bit/edi: grapheme <- copy _expected-bit
+      var _expected-bit/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+      var expected-bit/edi: code-point-utf8 <- copy _expected-bit
       $check-background-color-in-screen-row-from:compare-cells: {
         var background-color/eax: int <- screen-background-color-at-index screen, index
         # if expected-bit is space, assert that background is NOT bg
@@ -336,23 +336,23 @@ fn check-background-color-in-screen-row-from _screen: (addr screen), bg: int, y:
   draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, ".", 3/fg=cyan, 0/bg
 }
 
-fn test-draw-single-grapheme {
+fn test-draw-single-code-point-utf8 {
   var _screen: screen
   var screen/esi: (addr screen) <- address _screen
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   var dummy/eax: int <- draw-code-point screen, 0x61/a, 0/x, 0/y, 1/fg, 2/bg
-  check-screen-row screen, 0/y, "a", "F - test-draw-single-grapheme"  # top-left corner of the screen
-  check-screen-row-in-color screen, 1/fg, 0/y, "a", "F - test-draw-single-grapheme-fg"
-  check-screen-row-in-background-color screen, 2/bg, 0/y, "a", "F - test-draw-single-grapheme-bg"
-  check-background-color-in-screen-row screen, 2/bg, 0/y, "x ", "F - test-draw-single-grapheme-bg2"
+  check-screen-row screen, 0/y, "a", "F - test-draw-single-code-point-utf8"  # top-left corner of the screen
+  check-screen-row-in-color screen, 1/fg, 0/y, "a", "F - test-draw-single-code-point-utf8-fg"
+  check-screen-row-in-background-color screen, 2/bg, 0/y, "a", "F - test-draw-single-code-point-utf8-bg"
+  check-background-color-in-screen-row screen, 2/bg, 0/y, "x ", "F - test-draw-single-code-point-utf8-bg2"
 }
 
-fn test-draw-multiple-graphemes {
+fn test-draw-multiple-code-point-utf8s {
   var _screen: screen
   var screen/esi: (addr screen) <- address _screen
   initialize-screen screen, 0x10/rows, 4/cols, 0/no-pixel-graphics
   draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "Hello, 世界", 1/fg, 2/bg
-  check-screen-row screen, 0/y, "Hello, 世界", "F - test-draw-multiple-graphemes"
-  check-screen-row-in-color screen, 1/fg, 0/y, "Hello, 世界", "F - test-draw-multiple-graphemes-fg"
-  check-background-color-in-screen-row screen, 2/bg, 0/y, "xxxxxxxxx ", "F - test-draw-multiple-graphemes-bg2"
+  check-screen-row screen, 0/y, "Hello, 世界", "F - test-draw-multiple-code-point-utf8s"
+  check-screen-row-in-color screen, 1/fg, 0/y, "Hello, 世界", "F - test-draw-multiple-code-point-utf8s-fg"
+  check-background-color-in-screen-row screen, 2/bg, 0/y, "xxxxxxxxx ", "F - test-draw-multiple-code-point-utf8s-bg2"
 }
diff --git a/513grapheme-stack.mu b/513grapheme-stack.mu
index 3228cfb3..3aa0fd4e 100644
--- a/513grapheme-stack.mu
+++ b/513grapheme-stack.mu
@@ -1,26 +1,26 @@
-# grapheme stacks are the smallest unit of editable text
+# code-point-utf8 stacks are the smallest unit of editable text
 
-type grapheme-stack {
-  data: (handle array grapheme)
+type code-point-utf8-stack {
+  data: (handle array code-point-utf8)
   top: int
 }
 
-fn initialize-grapheme-stack _self: (addr grapheme-stack), n: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var d/edi: (addr handle array grapheme) <- get self, data
+fn initialize-code-point-utf8-stack _self: (addr code-point-utf8-stack), n: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var d/edi: (addr handle array code-point-utf8) <- get self, data
   populate d, n
   var top/eax: (addr int) <- get self, top
   copy-to *top, 0
 }
 
-fn clear-grapheme-stack _self: (addr grapheme-stack) {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn clear-code-point-utf8-stack _self: (addr code-point-utf8-stack) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   copy-to *top, 0
 }
 
-fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn code-point-utf8-stack-empty? _self: (addr code-point-utf8-stack) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   compare *top, 0
   {
@@ -30,26 +30,26 @@ fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
   return 0/false
 }
 
-fn grapheme-stack-length _self: (addr grapheme-stack) -> _/eax: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn code-point-utf8-stack-length _self: (addr code-point-utf8-stack) -> _/eax: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   return *top
 }
 
-fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn push-code-point-utf8-stack _self: (addr code-point-utf8-stack), _val: code-point-utf8 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
-  var data-ah/edx: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/edx: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
-  var dest-addr/edx: (addr grapheme) <- index data, top
-  var val/eax: grapheme <- copy _val
+  var dest-addr/edx: (addr code-point-utf8) <- index data, top
+  var val/eax: code-point-utf8 <- copy _val
   copy-to *dest-addr, val
   add-to *top-addr, 1
 }
 
-fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn pop-code-point-utf8-stack _self: (addr code-point-utf8-stack) -> _/eax: code-point-utf8 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
   {
     compare *top-addr, 0
@@ -57,25 +57,25 @@ fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
     return -1
   }
   subtract-from *top-addr, 1
-  var data-ah/edx: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/edx: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
-  var result-addr/eax: (addr grapheme) <- index data, top
+  var result-addr/eax: (addr code-point-utf8) <- index data, top
   return *result-addr
 }
 
-fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) {
-  var src/esi: (addr grapheme-stack) <- copy _src
-  var data-ah/edi: (addr handle array grapheme) <- get src, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn copy-code-point-utf8-stack _src: (addr code-point-utf8-stack), dest: (addr code-point-utf8-stack) {
+  var src/esi: (addr code-point-utf8-stack) <- copy _src
+  var data-ah/edi: (addr handle array code-point-utf8) <- get src, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get src, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    push-grapheme-stack dest, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    push-code-point-utf8-stack dest, *g
     i <- increment
     loop
   }
@@ -84,12 +84,12 @@ fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack)
 # dump stack to screen from bottom to top
 # hardcoded colors:
 #   matching paren
-fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _self: (addr grapheme-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _self: (addr code-point-utf8-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var matching-open-paren-index/edx: int <- get-matching-open-paren-index self, highlight-matching-open-paren?, open-paren-depth
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var x/eax: int <- copy _x
   var y/ecx: int <- copy _y
   var top-addr/esi: (addr int) <- get self, top
@@ -100,7 +100,7 @@ fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _sel
     {
       var c: code-point
       {
-        var g/eax: (addr grapheme) <- index data, i
+        var g/eax: (addr code-point-utf8) <- index data, i
         var tmp/eax: code-point <- to-code-point *g
         copy-to c, tmp
       }
@@ -123,7 +123,7 @@ fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _sel
 }
 
 # helper for small words
-fn render-stack-from-bottom screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int -> _/eax: int {
+fn render-stack-from-bottom screen: (addr screen), self: (addr code-point-utf8-stack), x: int, y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int -> _/eax: int {
   var _width/eax: int <- copy 0
   var _height/ecx: int <- copy 0
   _width, _height <- screen-size screen
@@ -136,16 +136,16 @@ fn render-stack-from-bottom screen: (addr screen), self: (addr grapheme-stack),
 }
 
 # dump stack to screen from top to bottom
-# optionally render a 'cursor' with the top grapheme
+# optionally render a 'cursor' with the top code-point-utf8
 # hard-coded colors:
 #   matching paren
 #   cursor
-fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self: (addr grapheme-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self: (addr code-point-utf8-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var matching-close-paren-index/edx: int <- get-matching-close-paren-index self, render-cursor?
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var x/eax: int <- copy _x
   var y/ecx: int <- copy _y
   var top-addr/ebx: (addr int) <- get self, top
@@ -159,7 +159,7 @@ fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self:
     break-if-<
     var c: code-point
     {
-      var g/eax: (addr grapheme) <- index data, i
+      var g/eax: (addr code-point-utf8) <- index data, i
       var tmp/eax: code-point <- to-code-point *g
       copy-to c, tmp
     }
@@ -184,7 +184,7 @@ fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self:
     #
     var c: code-point
     {
-      var g/eax: (addr grapheme) <- index data, i
+      var g/eax: (addr code-point-utf8) <- index data, i
       var tmp/eax: code-point <- to-code-point *g
       copy-to c, tmp
     }
@@ -196,7 +196,7 @@ fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self:
 }
 
 # helper for small words
-fn render-stack-from-top screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int {
+fn render-stack-from-top screen: (addr screen), self: (addr code-point-utf8-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int {
   var _width/eax: int <- copy 0
   var _height/ecx: int <- copy 0
   _width, _height <- screen-size screen
@@ -208,190 +208,190 @@ fn render-stack-from-top screen: (addr screen), self: (addr grapheme-stack), x:
   return x2  # y2? yolo
 }
 
-fn test-render-grapheme-stack {
+fn test-render-code-point-utf8-stack {
   # setup: gs = "abc"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x61/a
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x61/a
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x63/c
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 0/y, 0/no-highlight-matching-open-paren, 0/open-paren-depth
-  check-screen-row screen, 0/y, "abc ", "F - test-render-grapheme-stack from bottom"
-  check-ints-equal x, 3, "F - test-render-grapheme-stack from bottom: result"
-  check-background-color-in-screen-row screen, 3/bg=reverse, 0/y, "   ", "F - test-render-grapheme-stack from bottom: bg"
+  check-screen-row screen, 0/y, "abc ", "F - test-render-code-point-utf8-stack from bottom"
+  check-ints-equal x, 3, "F - test-render-code-point-utf8-stack from bottom: result"
+  check-background-color-in-screen-row screen, 3/bg=reverse, 0/y, "   ", "F - test-render-code-point-utf8-stack from bottom: bg"
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 1/y, 0/cursor=false
-  check-screen-row screen, 1/y, "cba ", "F - test-render-grapheme-stack from top without cursor"
-  check-ints-equal x, 3, "F - test-render-grapheme-stack from top without cursor: result"
-  check-background-color-in-screen-row screen, 3/bg=reverse, 1/y, "   ", "F - test-render-grapheme-stack from top without cursor: bg"
+  check-screen-row screen, 1/y, "cba ", "F - test-render-code-point-utf8-stack from top without cursor"
+  check-ints-equal x, 3, "F - test-render-code-point-utf8-stack from top without cursor: result"
+  check-background-color-in-screen-row screen, 3/bg=reverse, 1/y, "   ", "F - test-render-code-point-utf8-stack from top without cursor: bg"
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
-  check-screen-row screen, 2/y, "cba ", "F - test-render-grapheme-stack from top with cursor"
-  check-ints-equal x, 3, "F - test-render-grapheme-stack from top with cursor: result"
-  check-background-color-in-screen-row screen, 3/bg=reverse, 2/y, "|   ", "F - test-render-grapheme-stack from top with cursor: bg"
+  check-screen-row screen, 2/y, "cba ", "F - test-render-code-point-utf8-stack from top with cursor"
+  check-ints-equal x, 3, "F - test-render-code-point-utf8-stack from top with cursor: result"
+  check-background-color-in-screen-row screen, 3/bg=reverse, 2/y, "|   ", "F - test-render-code-point-utf8-stack from top with cursor: bg"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-close-paren {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-close-paren {
   # setup: gs = "(b)"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x29/close-paren
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
-  check-screen-row                      screen,               2/y, "(b) ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren"
-  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|   ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren: cursor"
-  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "  ) ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren: matching paren"
+  check-screen-row                      screen,               2/y, "(b) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren"
+  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|   ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren: cursor"
+  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "  ) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-close-paren-2 {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2 {
   # setup: gs = "(a (b)) c"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 0x10
-  var g/eax: grapheme <- copy 0x63/c
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 0x10
+  var g/eax: code-point-utf8 <- copy 0x63/c
+  push-code-point-utf8-stack gs, g
   g <- copy 0x20/space
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x20/space
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x61/a
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
-  check-screen-row                      screen,               2/y, "(a (b)) c ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2"
-  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|         ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2: cursor"
-  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "      )   ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2: matching paren"
+  check-screen-row                      screen,               2/y, "(a (b)) c ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2"
+  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|         ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2: cursor"
+  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "      )   ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end {
   # setup: gs = "(b)"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x28/open-paren
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 1/open-paren-depth
-  check-screen-row          screen,               2/y, "(b) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end"
-  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(   ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end: matching paren"
+  check-screen-row          screen,               2/y, "(b) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(   ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2 {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2 {
   # setup: gs = "a((b))"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 0x10
-  var g/eax: grapheme <- copy 0x61/a
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 0x10
+  var g/eax: code-point-utf8 <- copy 0x61/a
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 1/open-paren-depth
-  check-screen-row          screen,               2/y, "a((b)) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2"
-  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (     ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2: matching paren"
+  check-screen-row          screen,               2/y, "a((b)) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (     ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren {
   # setup: gs = "(b"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x28/open-paren
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 0/open-paren-depth
-  check-screen-row          screen,               2/y, "(b ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren"
-  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(  ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren: matching paren"
+  check-screen-row          screen,               2/y, "(b ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(  ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren-2 {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-2 {
   # setup: gs = "a((b)"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 0x10
-  var g/eax: grapheme <- copy 0x61/a
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 0x10
+  var g/eax: code-point-utf8 <- copy 0x61/a
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 0/open-paren-depth
-  check-screen-row          screen,               2/y, "a((b) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-2"
-  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (    ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-2: matching paren"
+  check-screen-row          screen,               2/y, "a((b) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-2"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (    ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-2: matching paren"
 }
 
-# return the index of the matching close-paren of the grapheme at cursor (top of stack)
+# return the index of the matching close-paren of the code-point-utf8 at cursor (top of stack)
 # or top index if there's no matching close-paren
-fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?: boolean -> _/edx: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn get-matching-close-paren-index _self: (addr code-point-utf8-stack), render-cursor?: boolean -> _/edx: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/edx: (addr int) <- get self, top
   # if not rendering cursor, return
   compare render-cursor?, 0/false
@@ -399,8 +399,8 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
     break-if-!=
     return *top-addr
   }
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var i/ecx: int <- copy *top-addr
   # if stack is empty, return
   compare i, 0
@@ -410,7 +410,7 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
   }
   # if cursor is not '(' return
   i <- decrement
-  var g/esi: (addr grapheme) <- index data, i
+  var g/esi: (addr code-point-utf8) <- index data, i
   compare *g, 0x28/open-paren
   {
     break-if-=
@@ -422,7 +422,7 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
   {
     compare i, 0
     break-if-<
-    var g/esi: (addr grapheme) <- index data, i
+    var g/esi: (addr code-point-utf8) <- index data, i
     compare *g, 0x28/open-paren
     {
       break-if-!=
@@ -446,8 +446,8 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
 
 # return the index of the first open-paren at the given depth
 # or top index if there's no matching close-paren
-fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean, depth: int -> _/edx: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn get-matching-open-paren-index _self: (addr code-point-utf8-stack), control: boolean, depth: int -> _/edx: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/edx: (addr int) <- get self, top
   # if not rendering cursor, return
   compare control, 0/false
@@ -455,8 +455,8 @@ fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean,
     break-if-!=
     return *top-addr
   }
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var i/ecx: int <- copy *top-addr
   # if stack is empty, return
   compare i, 0
@@ -470,7 +470,7 @@ fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean,
   {
     compare i, 0
     break-if-<
-    var g/esi: (addr grapheme) <- index data, i
+    var g/esi: (addr code-point-utf8) <- index data, i
     compare *g, 0x29/close-paren
     {
       break-if-!=
@@ -494,11 +494,11 @@ fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean,
 
 # compare from bottom
 # beware: modifies 'stream', which must be disposed of after a false result
-fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn prefix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy 0
   {
@@ -506,8 +506,8 @@ fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
     break-if->=
     # if curr != expected, return false
     {
-      var curr-a/edx: (addr grapheme) <- index data, i
-      var expected/eax: grapheme <- read-grapheme s
+      var curr-a/edx: (addr code-point-utf8) <- index data, i
+      var expected/eax: code-point-utf8 <- read-code-point-utf8 s
       {
         compare expected, *curr-a
         break-if-=
@@ -522,11 +522,11 @@ fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
 
 # compare from bottom
 # beware: modifies 'stream', which must be disposed of after a false result
-fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn suffix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/eax: (addr int) <- get self, top
   var i/ebx: int <- copy *top-addr
   i <- decrement
@@ -534,8 +534,8 @@ fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
     compare i, 0
     break-if-<
     {
-      var curr-a/edx: (addr grapheme) <- index data, i
-      var expected/eax: grapheme <- read-grapheme s
+      var curr-a/edx: (addr code-point-utf8) <- index data, i
+      var expected/eax: code-point-utf8 <- read-code-point-utf8 s
       # if curr != expected, return false
       {
         compare expected, *curr-a
@@ -549,18 +549,18 @@ fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
   return 1   # true
 }
 
-fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edx: (addr array grapheme) <- copy _data
+fn code-point-utf8-stack-is-decimal-integer? _self: (addr code-point-utf8-stack) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edx: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy 0
   var result/eax: boolean <- copy 1/true
-  $grapheme-stack-is-integer?:loop: {
+  $code-point-utf8-stack-is-integer?:loop: {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
+    var g/edx: (addr code-point-utf8) <- index data, i
     result <- decimal-digit? *g
     compare result, 0/false
     break-if-=
diff --git a/514gap-buffer.mu b/514gap-buffer.mu
index a5a7273e..6513983c 100644
--- a/514gap-buffer.mu
+++ b/514gap-buffer.mu
@@ -1,8 +1,8 @@
 # primitive for editing text
 
 type gap-buffer {
-  left: grapheme-stack
-  right: grapheme-stack
+  left: code-point-utf8-stack
+  right: code-point-utf8-stack
   # some fields for scanning incrementally through a gap-buffer
   left-read-index: int
   right-read-index: int
@@ -10,41 +10,41 @@ type gap-buffer {
 
 fn initialize-gap-buffer _self: (addr gap-buffer), capacity: int {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  initialize-grapheme-stack left, capacity
-  var right/eax: (addr grapheme-stack) <- get self, right
-  initialize-grapheme-stack right, capacity
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  initialize-code-point-utf8-stack left, capacity
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  initialize-code-point-utf8-stack right, capacity
 }
 
 fn clear-gap-buffer _self: (addr gap-buffer) {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  clear-grapheme-stack left
-  var right/eax: (addr grapheme-stack) <- get self, right
-  clear-grapheme-stack right
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  clear-code-point-utf8-stack left
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  clear-code-point-utf8-stack right
 }
 
 fn gap-buffer-empty? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
   # if !empty?(left) return false
   {
-    var left/eax: (addr grapheme-stack) <- get self, left
-    var result/eax: boolean <- grapheme-stack-empty? left
+    var left/eax: (addr code-point-utf8-stack) <- get self, left
+    var result/eax: boolean <- code-point-utf8-stack-empty? left
     compare result, 0/false
     break-if-!=
     return 0/false
   }
   # return empty?(right)
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var result/eax: boolean <- grapheme-stack-empty? left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var result/eax: boolean <- code-point-utf8-stack-empty? left
   return result
 }
 
 fn gap-buffer-capacity _gap: (addr gap-buffer) -> _/edx: int {
   var gap/esi: (addr gap-buffer) <- copy _gap
-  var left/eax: (addr grapheme-stack) <- get gap, left
-  var left-data-ah/eax: (addr handle array grapheme) <- get left, data
-  var left-data/eax: (addr array grapheme) <- lookup *left-data-ah
+  var left/eax: (addr code-point-utf8-stack) <- get gap, left
+  var left-data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+  var left-data/eax: (addr array code-point-utf8) <- lookup *left-data-ah
   var result/eax: int <- length left-data
   return result
 }
@@ -58,8 +58,8 @@ fn initialize-gap-buffer-with self: (addr gap-buffer), keys: (addr array byte) {
     var done?/eax: boolean <- stream-empty? input-stream
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme input-stream
-    add-grapheme-at-gap self, g
+    var g/eax: code-point-utf8 <- read-code-point-utf8 input-stream
+    add-code-point-utf8-at-gap self, g
     loop
   }
 }
@@ -73,7 +73,7 @@ fn load-gap-buffer-from-stream self: (addr gap-buffer), in: (addr stream byte) {
     var key/eax: byte <- read-byte in
     compare key, 0/null
     break-if-=
-    var g/eax: grapheme <- copy key
+    var g/eax: code-point-utf8 <- copy key
     edit-gap-buffer self, g
     loop
   }
@@ -86,44 +86,44 @@ fn emit-gap-buffer self: (addr gap-buffer), out: (addr stream byte) {
 
 fn append-gap-buffer _self: (addr gap-buffer), out: (addr stream byte) {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
   emit-stack-from-bottom left, out
-  var right/eax: (addr grapheme-stack) <- get self, right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
   emit-stack-from-top right, out
 }
 
 # dump stack from bottom to top
-fn emit-stack-from-bottom _self: (addr grapheme-stack), out: (addr stream byte) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn emit-stack-from-bottom _self: (addr code-point-utf8-stack), out: (addr stream byte) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    write-grapheme out, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    write-code-point-utf8 out, *g
     i <- increment
     loop
   }
 }
 
 # dump stack from top to bottom
-fn emit-stack-from-top _self: (addr grapheme-stack), out: (addr stream byte) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn emit-stack-from-top _self: (addr code-point-utf8-stack), out: (addr stream byte) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy *top-addr
   i <- decrement
   {
     compare i, 0
     break-if-<
-    var g/edx: (addr grapheme) <- index data, i
-    write-grapheme out, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    write-code-point-utf8 out, *g
     i <- decrement
     loop
   }
@@ -133,16 +133,16 @@ fn word-at-gap _self: (addr gap-buffer), out: (addr stream byte) {
   var self/esi: (addr gap-buffer) <- copy _self
   clear-stream out
   {
-    var g/eax: grapheme <- grapheme-at-gap self
-    var at-word?/eax: boolean <- is-ascii-word-grapheme? g
+    var g/eax: code-point-utf8 <- code-point-utf8-at-gap self
+    var at-word?/eax: boolean <- is-ascii-word-code-point-utf8? g
     compare at-word?, 0/false
     break-if-!=
     return
   }
-  var left/ecx: (addr grapheme-stack) <- get self, left
+  var left/ecx: (addr code-point-utf8-stack) <- get self, left
   var left-index/eax: int <- top-most-word left
   emit-stack-from-index left, left-index, out
-  var right/ecx: (addr grapheme-stack) <- get self, right
+  var right/ecx: (addr code-point-utf8-stack) <- get self, right
   var right-index/eax: int <- top-most-word right
   emit-stack-to-index right, right-index, out
 }
@@ -170,7 +170,7 @@ fn test-word-at-gap-single-word-with-gap-at-start {
   check-stream-equal out, "abc", "F - test-word-at-gap-single-word-with-gap-at-start"
 }
 
-fn test-word-at-gap-multiple-words-with-gap-at-non-word-grapheme-at-end {
+fn test-word-at-gap-multiple-words-with-gap-at-non-word-code-point-utf8-at-end {
   var _g: gap-buffer
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer-with g, "abc "
@@ -178,10 +178,10 @@ fn test-word-at-gap-multiple-words-with-gap-at-non-word-grapheme-at-end {
   var out-storage: (stream byte 0x10)
   var out/eax: (addr stream byte) <- address out-storage
   word-at-gap g, out
-  check-stream-equal out, "", "F - test-word-at-gap-multiple-words-with-gap-at-non-word-grapheme-at-end"
+  check-stream-equal out, "", "F - test-word-at-gap-multiple-words-with-gap-at-non-word-code-point-utf8-at-end"
 }
 
-fn test-word-at-gap-multiple-words-with-gap-at-non-word-grapheme-at-start {
+fn test-word-at-gap-multiple-words-with-gap-at-non-word-code-point-utf8-at-start {
   var _g: gap-buffer
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer-with g, " abc"
@@ -190,7 +190,7 @@ fn test-word-at-gap-multiple-words-with-gap-at-non-word-grapheme-at-start {
   var out-storage: (stream byte 0x10)
   var out/eax: (addr stream byte) <- address out-storage
   word-at-gap g, out
-  check-stream-equal out, "", "F - test-word-at-gap-multiple-words-with-gap-at-non-word-grapheme-at-start"
+  check-stream-equal out, "", "F - test-word-at-gap-multiple-words-with-gap-at-non-word-code-point-utf8-at-start"
 }
 
 fn test-word-at-gap-multiple-words-with-gap-at-end {
@@ -220,7 +220,7 @@ fn test-word-at-gap-multiple-words-with-gap-at-final-word {
   var _g: gap-buffer
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer-with g, "a bc d"
-  var dummy/eax: grapheme <- gap-left g
+  var dummy/eax: code-point-utf8 <- gap-left g
   # gap is at final word
   var out-storage: (stream byte 0x10)
   var out/eax: (addr stream byte) <- address out-storage
@@ -232,7 +232,7 @@ fn test-word-at-gap-multiple-words-with-gap-at-final-non-word {
   var _g: gap-buffer
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer-with g, "abc "
-  var dummy/eax: grapheme <- gap-left g
+  var dummy/eax: code-point-utf8 <- gap-left g
   # gap is at final word
   var out-storage: (stream byte 0x10)
   var out/eax: (addr stream byte) <- address out-storage
@@ -240,51 +240,51 @@ fn test-word-at-gap-multiple-words-with-gap-at-final-non-word {
   check-stream-equal out, "", "F - test-word-at-gap-multiple-words-with-gap-at-final-non-word"
 }
 
-fn grapheme-at-gap _self: (addr gap-buffer) -> _/eax: grapheme {
+fn code-point-utf8-at-gap _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   # send top of right most of the time
   var self/esi: (addr gap-buffer) <- copy _self
-  var right/edi: (addr grapheme-stack) <- get self, right
-  var data-ah/eax: (addr handle array grapheme) <- get right, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var right/edi: (addr code-point-utf8-stack) <- get self, right
+  var data-ah/eax: (addr handle array code-point-utf8) <- get right, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top-addr/ecx: (addr int) <- get right, top
   {
     compare *top-addr, 0
     break-if-<=
     var top/ecx: int <- copy *top-addr
     top <- decrement
-    var result/eax: (addr grapheme) <- index data, top
+    var result/eax: (addr code-point-utf8) <- index data, top
     return *result
   }
   # send top of left only if right is empty
-  var left/edi: (addr grapheme-stack) <- get self, left
-  var data-ah/eax: (addr handle array grapheme) <- get left, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var left/edi: (addr code-point-utf8-stack) <- get self, left
+  var data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top-addr/ecx: (addr int) <- get left, top
   {
     compare *top-addr, 0
     break-if-<=
     var top/ecx: int <- copy *top-addr
     top <- decrement
-    var result/eax: (addr grapheme) <- index data, top
+    var result/eax: (addr code-point-utf8) <- index data, top
     return *result
   }
   # send null if everything is empty
   return 0
 }
 
-fn top-most-word _self: (addr grapheme-stack) -> _/eax: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn top-most-word _self: (addr code-point-utf8-stack) -> _/eax: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy *top-addr
   i <- decrement
   {
     compare i, 0
     break-if-<
-    var g/edx: (addr grapheme) <- index data, i
-    var is-word?/eax: boolean <- is-ascii-word-grapheme? *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    var is-word?/eax: boolean <- is-ascii-word-code-point-utf8? *g
     compare is-word?, 0/false
     break-if-=
     i <- decrement
@@ -294,28 +294,28 @@ fn top-most-word _self: (addr grapheme-stack) -> _/eax: int {
   return i
 }
 
-fn emit-stack-from-index _self: (addr grapheme-stack), start: int, out: (addr stream byte) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn emit-stack-from-index _self: (addr code-point-utf8-stack), start: int, out: (addr stream byte) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy start
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    write-grapheme out, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    write-code-point-utf8 out, *g
     i <- increment
     loop
   }
 }
 
-fn emit-stack-to-index _self: (addr grapheme-stack), end: int, out: (addr stream byte) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn emit-stack-to-index _self: (addr code-point-utf8-stack), end: int, out: (addr stream byte) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy *top-addr
   i <- decrement
@@ -324,14 +324,14 @@ fn emit-stack-to-index _self: (addr grapheme-stack), end: int, out: (addr stream
     break-if-<
     compare i, end
     break-if-<
-    var g/edx: (addr grapheme) <- index data, i
-    write-grapheme out, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    write-code-point-utf8 out, *g
     i <- decrement
     loop
   }
 }
 
-fn is-ascii-word-grapheme? g: grapheme -> _/eax: boolean {
+fn is-ascii-word-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
   compare g, 0x21/!
   {
     break-if-!=
@@ -384,14 +384,14 @@ fn is-ascii-word-grapheme? g: grapheme -> _/eax: boolean {
 # cursor is a single other color.
 fn render-gap-buffer-wrapping-right-then-down screen: (addr screen), _gap: (addr gap-buffer), xmin: int, ymin: int, xmax: int, ymax: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int {
   var gap/esi: (addr gap-buffer) <- copy _gap
-  var left/edx: (addr grapheme-stack) <- get gap, left
+  var left/edx: (addr code-point-utf8-stack) <- get gap, left
   var highlight-matching-open-paren?/ebx: boolean <- copy 0/false
   var matching-open-paren-depth/edi: int <- copy 0
   highlight-matching-open-paren?, matching-open-paren-depth <- highlight-matching-open-paren? gap, render-cursor?
   var x2/eax: int <- copy 0
   var y2/ecx: int <- copy 0
   x2, y2 <- render-stack-from-bottom-wrapping-right-then-down screen, left, xmin, ymin, xmax, ymax, xmin, ymin, highlight-matching-open-paren?, matching-open-paren-depth, color, background-color
-  var right/edx: (addr grapheme-stack) <- get gap, right
+  var right/edx: (addr code-point-utf8-stack) <- get gap, right
   x2, y2 <- render-stack-from-top-wrapping-right-then-down screen, right, xmin, ymin, xmax, ymax, x2, y2, render-cursor?, color, background-color
   # decide whether we still need to print a cursor
   var fg/edi: int <- copy color
@@ -399,15 +399,15 @@ fn render-gap-buffer-wrapping-right-then-down screen: (addr screen), _gap: (addr
   compare render-cursor?, 0/false
   {
     break-if-=
-    # if the right side is empty, grapheme stack didn't print the cursor
-    var empty?/eax: boolean <- grapheme-stack-empty? right
+    # if the right side is empty, code-point-utf8 stack didn't print the cursor
+    var empty?/eax: boolean <- code-point-utf8-stack-empty? right
     compare empty?, 0/false
     break-if-=
     # swap foreground and background
     fg <- copy background-color
     bg <- copy color
   }
-  # print a grapheme either way so that cursor position doesn't affect printed width
+  # print a code-point-utf8 either way so that cursor position doesn't affect printed width
   var space/edx: code-point <- copy 0x20
   x2, y2 <- render-code-point screen, space, xmin, ymin, xmax, ymax, x2, y2, fg, bg
   return x2, y2
@@ -427,30 +427,30 @@ fn render-gap-buffer screen: (addr screen), gap: (addr gap-buffer), x: int, y: i
 
 fn gap-buffer-length _gap: (addr gap-buffer) -> _/eax: int {
   var gap/esi: (addr gap-buffer) <- copy _gap
-  var left/eax: (addr grapheme-stack) <- get gap, left
+  var left/eax: (addr code-point-utf8-stack) <- get gap, left
   var tmp/eax: (addr int) <- get left, top
   var left-length/ecx: int <- copy *tmp
-  var right/esi: (addr grapheme-stack) <- get gap, right
+  var right/esi: (addr code-point-utf8-stack) <- get gap, right
   tmp <- get right, top
   var result/eax: int <- copy *tmp
   result <- add left-length
   return result
 }
 
-fn add-grapheme-at-gap _self: (addr gap-buffer), g: grapheme {
+fn add-code-point-utf8-at-gap _self: (addr gap-buffer), g: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  push-grapheme-stack left, g
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  push-code-point-utf8-stack left, g
 }
 
 fn add-code-point-at-gap self: (addr gap-buffer), c: code-point {
-  var g/eax: grapheme <- copy c
-  add-grapheme-at-gap self, g
+  var g/eax: code-point-utf8 <- copy c
+  add-code-point-utf8-at-gap self, g
 }
 
 fn gap-to-start self: (addr gap-buffer) {
   {
-    var curr/eax: grapheme <- gap-left self
+    var curr/eax: code-point-utf8 <- gap-left self
     compare curr, -1
     loop-if-!=
   }
@@ -458,7 +458,7 @@ fn gap-to-start self: (addr gap-buffer) {
 
 fn gap-to-end self: (addr gap-buffer) {
   {
-    var curr/eax: grapheme <- gap-right self
+    var curr/eax: code-point-utf8 <- gap-right self
     compare curr, -1
     loop-if-!=
   }
@@ -466,96 +466,96 @@ fn gap-to-end self: (addr gap-buffer) {
 
 fn gap-at-start? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var result/eax: boolean <- grapheme-stack-empty? left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var result/eax: boolean <- code-point-utf8-stack-empty? left
   return result
 }
 
 fn gap-at-end? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  var right/eax: (addr grapheme-stack) <- get self, right
-  var result/eax: boolean <- grapheme-stack-empty? right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  var result/eax: boolean <- code-point-utf8-stack-empty? right
   return result
 }
 
-fn gap-right _self: (addr gap-buffer) -> _/eax: grapheme {
+fn gap-right _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
-  var g/eax: grapheme <- copy 0
-  var right/ecx: (addr grapheme-stack) <- get self, right
-  g <- pop-grapheme-stack right
+  var g/eax: code-point-utf8 <- copy 0
+  var right/ecx: (addr code-point-utf8-stack) <- get self, right
+  g <- pop-code-point-utf8-stack right
   compare g, -1
   {
     break-if-=
-    var left/ecx: (addr grapheme-stack) <- get self, left
-    push-grapheme-stack left, g
+    var left/ecx: (addr code-point-utf8-stack) <- get self, left
+    push-code-point-utf8-stack left, g
   }
   return g
 }
 
-fn gap-left _self: (addr gap-buffer) -> _/eax: grapheme {
+fn gap-left _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
-  var g/eax: grapheme <- copy 0
+  var g/eax: code-point-utf8 <- copy 0
   {
-    var left/ecx: (addr grapheme-stack) <- get self, left
-    g <- pop-grapheme-stack left
+    var left/ecx: (addr code-point-utf8-stack) <- get self, left
+    g <- pop-code-point-utf8-stack left
   }
   compare g, -1
   {
     break-if-=
-    var right/ecx: (addr grapheme-stack) <- get self, right
-    push-grapheme-stack right, g
+    var right/ecx: (addr code-point-utf8-stack) <- get self, right
+    push-code-point-utf8-stack right, g
   }
   return g
 }
 
 fn index-of-gap _self: (addr gap-buffer) -> _/eax: int {
   var self/eax: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
   var top-addr/eax: (addr int) <- get left, top
   var result/eax: int <- copy *top-addr
   return result
 }
 
-fn first-grapheme-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
+fn first-code-point-utf8-in-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   # try to read from left
-  var left/eax: (addr grapheme-stack) <- get self, left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
   var top-addr/ecx: (addr int) <- get left, top
   compare *top-addr, 0
   {
     break-if-<=
-    var data-ah/eax: (addr handle array grapheme) <- get left, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
-    var result-addr/eax: (addr grapheme) <- index data, 0
+    var data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
+    var result-addr/eax: (addr code-point-utf8) <- index data, 0
     return *result-addr
   }
   # try to read from right
-  var right/eax: (addr grapheme-stack) <- get self, right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
   top-addr <- get right, top
   compare *top-addr, 0
   {
     break-if-<=
-    var data-ah/eax: (addr handle array grapheme) <- get right, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
+    var data-ah/eax: (addr handle array code-point-utf8) <- get right, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
     var top/ecx: int <- copy *top-addr
     top <- decrement
-    var result-addr/eax: (addr grapheme) <- index data, top
+    var result-addr/eax: (addr code-point-utf8) <- index data, top
     return *result-addr
   }
   # give up
   return -1
 }
 
-fn grapheme-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
+fn code-point-utf8-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   # try to read from left
-  var left/ecx: (addr grapheme-stack) <- get self, left
+  var left/ecx: (addr code-point-utf8-stack) <- get self, left
   var top-addr/edx: (addr int) <- get left, top
   compare *top-addr, 0
   {
     break-if-<=
-    var result/eax: grapheme <- pop-grapheme-stack left
-    push-grapheme-stack left, result
+    var result/eax: code-point-utf8 <- pop-code-point-utf8-stack left
+    push-code-point-utf8-stack left, result
     return result
   }
   # give up
@@ -564,27 +564,27 @@ fn grapheme-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: graph
 
 fn delete-before-gap _self: (addr gap-buffer) {
   var self/eax: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var dummy/eax: grapheme <- pop-grapheme-stack left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var dummy/eax: code-point-utf8 <- pop-code-point-utf8-stack left
 }
 
-fn pop-after-gap _self: (addr gap-buffer) -> _/eax: grapheme {
+fn pop-after-gap _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/eax: (addr gap-buffer) <- copy _self
-  var right/eax: (addr grapheme-stack) <- get self, right
-  var result/eax: grapheme <- pop-grapheme-stack right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  var result/eax: code-point-utf8 <- pop-code-point-utf8-stack right
   return result
 }
 
 fn gap-buffer-equal? _self: (addr gap-buffer), s: (addr array byte) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  # complication: graphemes may be multiple bytes
+  # complication: code-point-utf8s may be multiple bytes
   # so don't rely on length
   # instead turn the expected result into a stream and arrange to read from it in order
   var stream-storage: (stream byte 0x10/capacity)
   var expected-stream/ecx: (addr stream byte) <- address stream-storage
   write expected-stream, s
   # compare left
-  var left/edx: (addr grapheme-stack) <- get self, left
+  var left/edx: (addr code-point-utf8-stack) <- get self, left
   var result/eax: boolean <- prefix-match? left, expected-stream
   compare result, 0/false
   {
@@ -592,7 +592,7 @@ fn gap-buffer-equal? _self: (addr gap-buffer), s: (addr array byte) -> _/eax: bo
     return result
   }
   # compare right
-  var right/edx: (addr grapheme-stack) <- get self, right
+  var right/edx: (addr code-point-utf8-stack) <- get self, right
   result <- suffix-match? right, expected-stream
   compare result, 0/false
   {
@@ -625,7 +625,7 @@ fn test-gap-buffer-equal-from-middle {
   add-code-point-at-gap g, 0x61/a
   add-code-point-at-gap g, 0x61/a
   add-code-point-at-gap g, 0x61/a
-  var dummy/eax: grapheme <- gap-left g
+  var dummy/eax: code-point-utf8 <- gap-left g
   # gap is in the middle
   var result/eax: boolean <- gap-buffer-equal? g, "aaa"
   check result, "F - test-gap-buffer-equal-from-middle"
@@ -639,7 +639,7 @@ fn test-gap-buffer-equal-from-start {
   add-code-point-at-gap g, 0x61/a
   add-code-point-at-gap g, 0x61/a
   add-code-point-at-gap g, 0x61/a
-  var dummy/eax: grapheme <- gap-left g
+  var dummy/eax: code-point-utf8 <- gap-left g
   dummy <- gap-left g
   dummy <- gap-left g
   # gap is at the start
@@ -674,9 +674,9 @@ fn gap-buffers-equal? self: (addr gap-buffer), g: (addr gap-buffer) -> _/eax: bo
     compare i, len
     break-if->=
     {
-      var tmp/eax: grapheme <- gap-index self, i
-      var curr/ecx: grapheme <- copy tmp
-      var currg/eax: grapheme <- gap-index g, i
+      var tmp/eax: code-point-utf8 <- gap-index self, i
+      var curr/ecx: code-point-utf8 <- copy tmp
+      var currg/eax: code-point-utf8 <- gap-index g, i
       compare curr, currg
       break-if-=
       return 0/false
@@ -687,36 +687,36 @@ fn gap-buffers-equal? self: (addr gap-buffer), g: (addr gap-buffer) -> _/eax: bo
   return 1/true
 }
 
-fn gap-index _self: (addr gap-buffer), _n: int -> _/eax: grapheme {
+fn gap-index _self: (addr gap-buffer), _n: int -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   var n/ebx: int <- copy _n
   # if n < left->length, index into left
-  var left/edi: (addr grapheme-stack) <- get self, left
+  var left/edi: (addr code-point-utf8-stack) <- get self, left
   var left-len-a/edx: (addr int) <- get left, top
   compare n, *left-len-a
   {
     break-if->=
-    var data-ah/eax: (addr handle array grapheme) <- get left, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
-    var result/eax: (addr grapheme) <- index data, n
+    var data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
+    var result/eax: (addr code-point-utf8) <- index data, n
     return *result
   }
   # shrink n
   n <- subtract *left-len-a
   # if n < right->length, index into right
-  var right/edi: (addr grapheme-stack) <- get self, right
+  var right/edi: (addr code-point-utf8-stack) <- get self, right
   var right-len-a/edx: (addr int) <- get right, top
   compare n, *right-len-a
   {
     break-if->=
-    var data-ah/eax: (addr handle array grapheme) <- get right, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
+    var data-ah/eax: (addr handle array code-point-utf8) <- get right, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
     # idx = right->len - n - 1
     var idx/ebx: int <- copy n
     idx <- subtract *right-len-a
     idx <- negate
     idx <- subtract 1
-    var result/eax: (addr grapheme) <- index data, idx
+    var result/eax: (addr code-point-utf8) <- index data, idx
     return *result
   }
   # error
@@ -757,25 +757,25 @@ fn test-gap-buffer-index {
   var gap/esi: (addr gap-buffer) <- address gap-storage
   initialize-gap-buffer-with gap, "abc"
   # gap is at end, all contents are in left
-  var g/eax: grapheme <- gap-index gap, 0
+  var g/eax: code-point-utf8 <- gap-index gap, 0
   var x/ecx: int <- copy g
   check-ints-equal x, 0x61/a, "F - test-gap-index/left-1"
-  var g/eax: grapheme <- gap-index gap, 1
+  var g/eax: code-point-utf8 <- gap-index gap, 1
   var x/ecx: int <- copy g
   check-ints-equal x, 0x62/b, "F - test-gap-index/left-2"
-  var g/eax: grapheme <- gap-index gap, 2
+  var g/eax: code-point-utf8 <- gap-index gap, 2
   var x/ecx: int <- copy g
   check-ints-equal x, 0x63/c, "F - test-gap-index/left-3"
   # now check when everything is to the right
   gap-to-start gap
   rewind-gap-buffer gap
-  var g/eax: grapheme <- gap-index gap, 0
+  var g/eax: code-point-utf8 <- gap-index gap, 0
   var x/ecx: int <- copy g
   check-ints-equal x, 0x61/a, "F - test-gap-index/right-1"
-  var g/eax: grapheme <- gap-index gap, 1
+  var g/eax: code-point-utf8 <- gap-index gap, 1
   var x/ecx: int <- copy g
   check-ints-equal x, 0x62/b, "F - test-gap-index/right-2"
-  var g/eax: grapheme <- gap-index gap, 2
+  var g/eax: code-point-utf8 <- gap-index gap, 2
   var x/ecx: int <- copy g
   check-ints-equal x, 0x63/c, "F - test-gap-index/right-3"
 }
@@ -788,25 +788,25 @@ fn copy-gap-buffer _src-ah: (addr handle gap-buffer), _dest-ah: (addr handle gap
   var dest-ah/eax: (addr handle gap-buffer) <- copy _dest-ah
   var _dest-a/eax: (addr gap-buffer) <- lookup *dest-ah
   var dest-a/edi: (addr gap-buffer) <- copy _dest-a
-  # copy left grapheme-stack
-  var src/ecx: (addr grapheme-stack) <- get src-a, left
-  var dest/edx: (addr grapheme-stack) <- get dest-a, left
-  copy-grapheme-stack src, dest
-  # copy right grapheme-stack
+  # copy left code-point-utf8-stack
+  var src/ecx: (addr code-point-utf8-stack) <- get src-a, left
+  var dest/edx: (addr code-point-utf8-stack) <- get dest-a, left
+  copy-code-point-utf8-stack src, dest
+  # copy right code-point-utf8-stack
   src <- get src-a, right
   dest <- get dest-a, right
-  copy-grapheme-stack src, dest
+  copy-code-point-utf8-stack src, dest
 }
 
 fn gap-buffer-is-decimal-integer? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  var curr/ecx: (addr grapheme-stack) <- get self, left
-  var result/eax: boolean <- grapheme-stack-is-decimal-integer? curr
+  var curr/ecx: (addr code-point-utf8-stack) <- get self, left
+  var result/eax: boolean <- code-point-utf8-stack-is-decimal-integer? curr
   {
     compare result, 0/false
     break-if-=
     curr <- get self, right
-    result <- grapheme-stack-is-decimal-integer? curr
+    result <- code-point-utf8-stack-is-decimal-integer? curr
   }
   return result
 }
@@ -841,7 +841,7 @@ fn test-render-gap-buffer-with-cursor-at-end {
   #
   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
   check-screen-row screen, 0/y, "abc ", "F - test-render-gap-buffer-with-cursor-at-end"
-  # we've drawn one extra grapheme for the cursor
+  # we've drawn one extra code-point-utf8 for the cursor
   check-ints-equal x, 4, "F - test-render-gap-buffer-with-cursor-at-end: result"
                                                                 # abc
   check-background-color-in-screen-row screen, 3/bg=reverse, 0/y, "   |", "F - test-render-gap-buffer-with-cursor-at-end: bg"
@@ -853,7 +853,7 @@ fn test-render-gap-buffer-with-cursor-in-middle {
   var gap/esi: (addr gap-buffer) <- address gap-storage
   initialize-gap-buffer-with gap, "abc"
   gap-to-end gap
-  var dummy/eax: grapheme <- gap-left gap
+  var dummy/eax: code-point-utf8 <- gap-left gap
   # setup: screen
   var screen-storage: screen
   var screen/edi: (addr screen) <- address screen-storage
@@ -905,7 +905,7 @@ fn test-render-gap-buffer-highlight-matching-open-paren {
   var gap/esi: (addr gap-buffer) <- address gap-storage
   initialize-gap-buffer-with gap, "(a)"
   gap-to-end gap
-  var dummy/eax: grapheme <- gap-left gap
+  var dummy/eax: code-point-utf8 <- gap-left gap
   # setup: screen
   var screen-storage: screen
   var screen/edi: (addr screen) <- address screen-storage
@@ -947,7 +947,7 @@ fn highlight-matching-open-paren? _gap: (addr gap-buffer), render-cursor?: boole
     return 0/false, 0
   }
   var gap/esi: (addr gap-buffer) <- copy _gap
-  var stack/edi: (addr grapheme-stack) <- get gap, right
+  var stack/edi: (addr code-point-utf8-stack) <- get gap, right
   var top-addr/eax: (addr int) <- get stack, top
   var top-index/ecx: int <- copy *top-addr
   compare top-index, 0
@@ -963,9 +963,9 @@ fn highlight-matching-open-paren? _gap: (addr gap-buffer), render-cursor?: boole
       return 0/false, 0
     }
     top-index <- decrement
-    var data-ah/eax: (addr handle array grapheme) <- get stack, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
-    var g/eax: (addr grapheme) <- index data, top-index
+    var data-ah/eax: (addr handle array code-point-utf8) <- get stack, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
+    var g/eax: (addr code-point-utf8) <- index data, top-index
     compare *g, 0x29/close-paren
     {
       break-if-=
@@ -975,9 +975,9 @@ fn highlight-matching-open-paren? _gap: (addr gap-buffer), render-cursor?: boole
   }
   # cursor is not at end; return (char at cursor == ')')
   top-index <- decrement
-  var data-ah/eax: (addr handle array grapheme) <- get stack, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
-  var g/eax: (addr grapheme) <- index data, top-index
+  var data-ah/eax: (addr handle array code-point-utf8) <- get stack, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var g/eax: (addr code-point-utf8) <- index data, top-index
   compare *g, 0x29/close-paren
   {
     break-if-=
@@ -998,7 +998,7 @@ fn test-highlight-matching-open-paren {
   highlight-matching-open-paren?, open-paren-depth <- highlight-matching-open-paren? gap, 1/render-cursor
   check highlight-matching-open-paren?, "F - test-highlight-matching-open-paren: at end immediately after ')'"
   check-ints-equal open-paren-depth, 1, "F - test-highlight-matching-open-paren: depth at end immediately after ')'"
-  var dummy/eax: grapheme <- gap-left gap
+  var dummy/eax: code-point-utf8 <- gap-left gap
   highlight-matching-open-paren?, open-paren-depth <- highlight-matching-open-paren? gap, 1/render-cursor
   check highlight-matching-open-paren?, "F - test-highlight-matching-open-paren: on ')'"
   dummy <- gap-left gap
@@ -1022,8 +1022,8 @@ fn rewind-gap-buffer _self: (addr gap-buffer) {
 fn gap-buffer-scan-done? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
   # more in left?
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var left-size/eax: int <- grapheme-stack-length left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var left-size/eax: int <- code-point-utf8-stack-length left
   var left-read-index/ecx: (addr int) <- get self, left-read-index
   compare *left-read-index, left-size
   {
@@ -1031,8 +1031,8 @@ fn gap-buffer-scan-done? _self: (addr gap-buffer) -> _/eax: boolean {
     return 0/false
   }
   # more in right?
-  var right/eax: (addr grapheme-stack) <- get self, right
-  var right-size/eax: int <- grapheme-stack-length right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  var right-size/eax: int <- code-point-utf8-stack-length right
   var right-read-index/ecx: (addr int) <- get self, right-read-index
   compare *right-read-index, right-size
   {
@@ -1043,73 +1043,73 @@ fn gap-buffer-scan-done? _self: (addr gap-buffer) -> _/eax: boolean {
   return 1/true
 }
 
-fn peek-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
+fn peek-from-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   # more in left?
-  var left/ecx: (addr grapheme-stack) <- get self, left
-  var left-size/eax: int <- grapheme-stack-length left
+  var left/ecx: (addr code-point-utf8-stack) <- get self, left
+  var left-size/eax: int <- code-point-utf8-stack-length left
   var left-read-index-a/edx: (addr int) <- get self, left-read-index
   compare *left-read-index-a, left-size
   {
     break-if->=
-    var left-data-ah/eax: (addr handle array grapheme) <- get left, data
-    var left-data/eax: (addr array grapheme) <- lookup *left-data-ah
+    var left-data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+    var left-data/eax: (addr array code-point-utf8) <- lookup *left-data-ah
     var left-read-index/ecx: int <- copy *left-read-index-a
-    var result/eax: (addr grapheme) <- index left-data, left-read-index
+    var result/eax: (addr code-point-utf8) <- index left-data, left-read-index
     return *result
   }
   # more in right?
-  var right/ecx: (addr grapheme-stack) <- get self, right
-  var _right-size/eax: int <- grapheme-stack-length right
+  var right/ecx: (addr code-point-utf8-stack) <- get self, right
+  var _right-size/eax: int <- code-point-utf8-stack-length right
   var right-size/ebx: int <- copy _right-size
   var right-read-index-a/edx: (addr int) <- get self, right-read-index
   compare *right-read-index-a, right-size
   {
     break-if->=
     # read the right from reverse
-    var right-data-ah/eax: (addr handle array grapheme) <- get right, data
-    var right-data/eax: (addr array grapheme) <- lookup *right-data-ah
+    var right-data-ah/eax: (addr handle array code-point-utf8) <- get right, data
+    var right-data/eax: (addr array code-point-utf8) <- lookup *right-data-ah
     var right-read-index/ebx: int <- copy right-size
     right-read-index <- subtract *right-read-index-a
     right-read-index <- subtract 1
-    var result/eax: (addr grapheme) <- index right-data, right-read-index
+    var result/eax: (addr code-point-utf8) <- index right-data, right-read-index
     return *result
   }
   # if we get here there's nothing left
   return 0/nul
 }
 
-fn read-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
+fn read-from-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   # more in left?
-  var left/ecx: (addr grapheme-stack) <- get self, left
-  var left-size/eax: int <- grapheme-stack-length left
+  var left/ecx: (addr code-point-utf8-stack) <- get self, left
+  var left-size/eax: int <- code-point-utf8-stack-length left
   var left-read-index-a/edx: (addr int) <- get self, left-read-index
   compare *left-read-index-a, left-size
   {
     break-if->=
-    var left-data-ah/eax: (addr handle array grapheme) <- get left, data
-    var left-data/eax: (addr array grapheme) <- lookup *left-data-ah
+    var left-data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+    var left-data/eax: (addr array code-point-utf8) <- lookup *left-data-ah
     var left-read-index/ecx: int <- copy *left-read-index-a
-    var result/eax: (addr grapheme) <- index left-data, left-read-index
+    var result/eax: (addr code-point-utf8) <- index left-data, left-read-index
     increment *left-read-index-a
     return *result
   }
   # more in right?
-  var right/ecx: (addr grapheme-stack) <- get self, right
-  var _right-size/eax: int <- grapheme-stack-length right
+  var right/ecx: (addr code-point-utf8-stack) <- get self, right
+  var _right-size/eax: int <- code-point-utf8-stack-length right
   var right-size/ebx: int <- copy _right-size
   var right-read-index-a/edx: (addr int) <- get self, right-read-index
   compare *right-read-index-a, right-size
   {
     break-if->=
     # read the right from reverse
-    var right-data-ah/eax: (addr handle array grapheme) <- get right, data
-    var right-data/eax: (addr array grapheme) <- lookup *right-data-ah
+    var right-data-ah/eax: (addr handle array code-point-utf8) <- get right, data
+    var right-data/eax: (addr array code-point-utf8) <- lookup *right-data-ah
     var right-read-index/ebx: int <- copy right-size
     right-read-index <- subtract *right-read-index-a
     right-read-index <- subtract 1
-    var result/eax: (addr grapheme) <- index right-data, right-read-index
+    var result/eax: (addr code-point-utf8) <- index right-data, right-read-index
     increment *right-read-index-a
     return *result
   }
@@ -1120,8 +1120,8 @@ fn read-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
 fn put-back-from-gap-buffer _self: (addr gap-buffer) {
   var self/esi: (addr gap-buffer) <- copy _self
   # more in right?
-  var right/eax: (addr grapheme-stack) <- get self, right
-  var right-size/eax: int <- grapheme-stack-length right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  var right-size/eax: int <- code-point-utf8-stack-length right
   var right-read-index-a/eax: (addr int) <- get self, right-read-index
   compare *right-read-index-a, 0
   {
@@ -1130,8 +1130,8 @@ fn put-back-from-gap-buffer _self: (addr gap-buffer) {
     return
   }
   # more in left?
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var left-size/eax: int <- grapheme-stack-length left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var left-size/eax: int <- code-point-utf8-stack-length left
   var left-read-index-a/eax: (addr int) <- get self, left-read-index
   decrement *left-read-index-a
 }
@@ -1143,22 +1143,22 @@ fn test-read-from-gap-buffer {
   # gap is at end, all contents are in left
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check-not done?, "F - test-read-from-gap-buffer/left-1/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0x61/a, "F - test-read-from-gap-buffer/left-1"
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check-not done?, "F - test-read-from-gap-buffer/left-2/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0x62/b, "F - test-read-from-gap-buffer/left-2"
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check-not done?, "F - test-read-from-gap-buffer/left-3/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0x63/c, "F - test-read-from-gap-buffer/left-3"
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check done?, "F - test-read-from-gap-buffer/left-4/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0/nul, "F - test-read-from-gap-buffer/left-4"
   # now check when everything is to the right
@@ -1166,22 +1166,22 @@ fn test-read-from-gap-buffer {
   rewind-gap-buffer gap
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check-not done?, "F - test-read-from-gap-buffer/right-1/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0x61/a, "F - test-read-from-gap-buffer/right-1"
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check-not done?, "F - test-read-from-gap-buffer/right-2/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0x62/b, "F - test-read-from-gap-buffer/right-2"
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check-not done?, "F - test-read-from-gap-buffer/right-3/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0x63/c, "F - test-read-from-gap-buffer/right-3"
   var done?/eax: boolean <- gap-buffer-scan-done? gap
   check done?, "F - test-read-from-gap-buffer/right-4/done"
-  var g/eax: grapheme <- read-from-gap-buffer gap
+  var g/eax: code-point-utf8 <- read-from-gap-buffer gap
   var x/ecx: int <- copy g
   check-ints-equal x, 0/nul, "F - test-read-from-gap-buffer/right-4"
 }
@@ -1190,7 +1190,7 @@ fn skip-spaces-from-gap-buffer self: (addr gap-buffer) {
   var done?/eax: boolean <- gap-buffer-scan-done? self
   compare done?, 0/false
   break-if-!=
-  var g/eax: grapheme <- peek-from-gap-buffer self
+  var g/eax: code-point-utf8 <- peek-from-gap-buffer self
   {
     compare g, 0x20/space
     break-if-=
@@ -1200,8 +1200,8 @@ fn skip-spaces-from-gap-buffer self: (addr gap-buffer) {
   loop
 }
 
-fn edit-gap-buffer self: (addr gap-buffer), key: grapheme {
-  var g/edx: grapheme <- copy key
+fn edit-gap-buffer self: (addr gap-buffer), key: code-point-utf8 {
+  var g/edx: code-point-utf8 <- copy key
   {
     compare g, 8/backspace
     break-if-!=
@@ -1211,13 +1211,13 @@ fn edit-gap-buffer self: (addr gap-buffer), key: grapheme {
   {
     compare g, 0x80/left-arrow
     break-if-!=
-    var dummy/eax: grapheme <- gap-left self
+    var dummy/eax: code-point-utf8 <- gap-left self
     return
   }
   {
     compare g, 0x83/right-arrow
     break-if-!=
-    var dummy/eax: grapheme <- gap-right self
+    var dummy/eax: code-point-utf8 <- gap-right self
     return
   }
   {
@@ -1271,11 +1271,11 @@ fn edit-gap-buffer self: (addr gap-buffer), key: grapheme {
     return
   }
   # default: insert character
-  add-grapheme-at-gap self, g
+  add-code-point-utf8-at-gap self, g
 }
 
 fn gap-to-start-of-next-word self: (addr gap-buffer) {
-  var curr/eax: grapheme <- copy 0
+  var curr/eax: code-point-utf8 <- copy 0
   # skip to next space
   {
     curr <- gap-right self
@@ -1302,7 +1302,7 @@ fn gap-to-start-of-next-word self: (addr gap-buffer) {
 }
 
 fn gap-to-end-of-previous-word self: (addr gap-buffer) {
-  var curr/eax: grapheme <- copy 0
+  var curr/eax: code-point-utf8 <- copy 0
   # skip to previous space
   {
     curr <- gap-left self
@@ -1330,7 +1330,7 @@ fn gap-to-end-of-previous-word self: (addr gap-buffer) {
 
 fn gap-to-previous-start-of-line self: (addr gap-buffer) {
   # skip past immediate newline
-  var dummy/eax: grapheme <- gap-left self
+  var dummy/eax: code-point-utf8 <- gap-left self
   # skip to previous newline
   {
     dummy <- gap-left self
@@ -1351,7 +1351,7 @@ fn gap-to-previous-start-of-line self: (addr gap-buffer) {
 
 fn gap-to-next-end-of-line self: (addr gap-buffer) {
   # skip past immediate newline
-  var dummy/eax: grapheme <- gap-right self
+  var dummy/eax: code-point-utf8 <- gap-right self
   # skip to next newline
   {
     dummy <- gap-right self
@@ -1380,7 +1380,7 @@ fn gap-up self: (addr gap-buffer) {
   {
     compare i, col
     break-if->=
-    var curr/eax: grapheme <- gap-right self
+    var curr/eax: code-point-utf8 <- gap-right self
     {
       compare curr, -1
       break-if-!=
@@ -1402,13 +1402,13 @@ fn gap-down self: (addr gap-buffer) {
   var col/edx: int <- count-columns-to-start-of-line self
   # skip to start of next line
   gap-to-end-of-line self
-  var dummy/eax: grapheme <- gap-right self
+  var dummy/eax: code-point-utf8 <- gap-right self
   # skip ahead by up to col on previous line
   var i/ecx: int <- copy 0
   {
     compare i, col
     break-if->=
-    var curr/eax: grapheme <- gap-right self
+    var curr/eax: code-point-utf8 <- gap-right self
     {
       compare curr, -1
       break-if-!=
@@ -1427,7 +1427,7 @@ fn gap-down self: (addr gap-buffer) {
 
 fn count-columns-to-start-of-line self: (addr gap-buffer) -> _/edx: int {
   var count/edx: int <- copy 0
-  var dummy/eax: grapheme <- copy 0
+  var dummy/eax: code-point-utf8 <- copy 0
   # skip to previous newline
   {
     dummy <- gap-left self
@@ -1449,7 +1449,7 @@ fn count-columns-to-start-of-line self: (addr gap-buffer) -> _/edx: int {
 }
 
 fn gap-to-end-of-line self: (addr gap-buffer) {
-  var dummy/eax: grapheme <- copy 0
+  var dummy/eax: code-point-utf8 <- copy 0
   # skip to next newline
   {
     dummy <- gap-right self
diff --git a/apps/ex15.mu b/apps/ex15.mu
index 51bfc1db..570704d6 100644
--- a/apps/ex15.mu
+++ b/apps/ex15.mu
@@ -32,13 +32,13 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
   var dummy/eax: int <-    draw-code-point-on-real-screen   0x61/a,                       0/x 0/y, 3/fg 0/bg
   var dummy/eax: int <- overlay-code-point-on-real-screen 0x0300/combining-grave-accent,  0/x 0/y, 3/fg 0/bg
 
-  # below a grapheme with a descender, the accent uglily overlaps
+  # below a code-point-utf8 with a descender, the accent uglily overlaps
   #   https://en.wikipedia.org/wiki/Descender
   var dummy/eax: int <-    draw-code-point-on-real-screen   0x67/g,                       4/x 3/y, 3/fg 0/bg
   var dummy/eax: int <-    draw-code-point-on-real-screen   0x61/a,                       4/x 4/y, 3/fg 0/bg
   var dummy/eax: int <- overlay-code-point-on-real-screen 0x0300/combining-grave-accent,  4/x 4/y, 3/fg 0/bg
 
-  # beside a grapheme with a descender, it becomes more obvious that monowidth fonts can't make baselines line up
+  # beside a code-point-utf8 with a descender, it becomes more obvious that monowidth fonts can't make baselines line up
   #   https://en.wikipedia.org/wiki/Baseline_(typography)
   var dummy/eax: int <-    draw-code-point-on-real-screen   0x67/g,                       8/x 3/y, 3/fg 0/bg
   var dummy/eax: int <-    draw-code-point-on-real-screen   0x61/a,                       9/x 3/y, 3/fg 0/bg
@@ -82,62 +82,62 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
   var dummy/eax: int <- draw-code-point-on-real-screen 0x0915/devanagari-letter-ka, 0x13/x 9/y, 3/fg 0/bg
   var dummy/eax: int <- overlay-code-point-on-real-screen 0x0903/devanagari-visarga, 0x13/x 9/y, 3/fg 0/bg
 
-  # render the same devanagari letters as a single stream of utf-8 graphemes rather than individual code-points.
+  # render the same devanagari letters as a single stream of utf-8 code-point-utf8s rather than individual code-points.
   var text-storage: (stream byte 0x200)
   var text/esi: (addr stream byte) <- address text-storage
-  var g/eax: grapheme <- to-grapheme 0x0915/devanagari-letter-ka
-  var ka/ecx: grapheme <- copy g
+  var g/eax: code-point-utf8 <- to-utf8 0x0915/devanagari-letter-ka
+  var ka/ecx: code-point-utf8 <- copy g
   # ka
-  write-grapheme text, ka
+  write-code-point-utf8 text, ka
   # kaa
-  write-grapheme text, ka
-  g <- to-grapheme 0x093e/devanagari-vowel-aa
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x093e/devanagari-vowel-aa
+  write-code-point-utf8 text, g
   # ki
-  write-grapheme text, ka
-  g <- to-grapheme 0x093f/devanagari-vowel-i
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x093f/devanagari-vowel-i
+  write-code-point-utf8 text, g
   # kee
-  write-grapheme text, ka
-  g <- to-grapheme 0x0940/devanagari-vowel-ii
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0940/devanagari-vowel-ii
+  write-code-point-utf8 text, g
   # ku
-  write-grapheme text, ka
-  g <- to-grapheme 0x0941/devanagari-vowel-u
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0941/devanagari-vowel-u
+  write-code-point-utf8 text, g
   # koo
-  write-grapheme text, ka
-  g <- to-grapheme 0x0942/devanagari-vowel-oo
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0942/devanagari-vowel-oo
+  write-code-point-utf8 text, g
   # kay
-  write-grapheme text, ka
-  g <- to-grapheme 0x0947/devanagari-vowel-E
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0947/devanagari-vowel-E
+  write-code-point-utf8 text, g
   # kai
-  write-grapheme text, ka
-  g <- to-grapheme 0x0948/devanagari-vowel-ai
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0948/devanagari-vowel-ai
+  write-code-point-utf8 text, g
   # ko
-  write-grapheme text, ka
-  g <- to-grapheme 0x094b/devanagari-vowel-o
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x094b/devanagari-vowel-o
+  write-code-point-utf8 text, g
   # kow
-  write-grapheme text, ka
-  g <- to-grapheme 0x094f/devanagari-vowel-aw
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x094f/devanagari-vowel-aw
+  write-code-point-utf8 text, g
   # kan
-  write-grapheme text, ka
-  g <- to-grapheme 0x0902/devanagari-anusvara
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0902/devanagari-anusvara
+  write-code-point-utf8 text, g
   # kaha
-  write-grapheme text, ka
-  g <- to-grapheme 0x0903/devanagari-visarga
-  write-grapheme text, g
+  write-code-point-utf8 text, ka
+  g <- to-utf8 0x0903/devanagari-visarga
+  write-code-point-utf8 text, g
   # render everything
   set-cursor-position screen, 4/x 0xe/y
   draw-stream-wrapping-right-then-down-from-cursor-over-full-screen screen, text, 3/fg 0/bg
 
-  # a stream of tamil graphemes (with interspersed spaces for clarity) that don't look the same in Mu
+  # a stream of tamil code-point-utf8s (with interspersed spaces for clarity) that don't look the same in Mu
   set-cursor-position 0, 4/x 0x12/y
   draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0, "எ ஃ கு ", 3/fg 0/bg
   set-cursor-position 0, 4/x 0x13/y
diff --git a/apps/ex9.mu b/apps/ex9.mu
index deb3f2f7..c192bde8 100644
--- a/apps/ex9.mu
+++ b/apps/ex9.mu
@@ -33,7 +33,7 @@ fn word-count in: (addr stream byte) -> _/eax: int {
     var done?/eax: boolean <- stream-empty? in
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme in
+    var g/eax: code-point-utf8 <- read-code-point-utf8 in
     {
       compare g, 0x20/space
       break-if-!=
diff --git a/apps/hest-life.mu b/apps/hest-life.mu
index 721db5c8..340f7214 100644
--- a/apps/hest-life.mu
+++ b/apps/hest-life.mu
@@ -28,7 +28,7 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
   var second-screen/edi: (addr screen) <- address second-buffer
   initialize-screen second-screen, 0x80, 0x30, 1/include-pixels
   render second-screen, env
-  convert-graphemes-to-pixels second-screen
+  convert-code-point-utf8s-to-pixels second-screen
   copy-pixels second-screen, screen
   {
     edit keyboard, env
@@ -39,7 +39,7 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
       step env
       clear-screen second-screen
       render second-screen, env
-      convert-graphemes-to-pixels second-screen
+      convert-code-point-utf8s-to-pixels second-screen
       copy-pixels second-screen, screen
     }
     linger
diff --git a/browse-slack/environment.mu b/browse-slack/environment.mu
index 8f53a7f8..e4e24ff6 100644
--- a/browse-slack/environment.mu
+++ b/browse-slack/environment.mu
@@ -615,12 +615,12 @@ fn draw-json-stream-wrapping-right-then-down screen: (addr screen), stream: (add
     }
     compare c, 0xffffffff/end-of-file
     break-if-=
-    $draw-json-stream-wrapping-right-then-down:render-grapheme: {
+    $draw-json-stream-wrapping-right-then-down:render-code-point-utf8: {
       compare c, 0x5c/backslash
       {
         break-if-!=
         xcurr, ycurr <- render-json-escaped-code-point screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
-        break $draw-json-stream-wrapping-right-then-down:render-grapheme
+        break $draw-json-stream-wrapping-right-then-down:render-code-point-utf8
       }
       compare c, 0xa/newline
       {
@@ -629,7 +629,7 @@ fn draw-json-stream-wrapping-right-then-down screen: (addr screen), stream: (add
         var dummy/eax: int <- draw-code-point screen, 0x20/space, xcurr, ycurr, color, background-color
         xcurr <- copy xmin
         ycurr <- increment
-        break $draw-json-stream-wrapping-right-then-down:render-grapheme
+        break $draw-json-stream-wrapping-right-then-down:render-code-point-utf8
       }
       var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
       # overlay a combining character if necessary
@@ -639,7 +639,7 @@ fn draw-json-stream-wrapping-right-then-down screen: (addr screen), stream: (add
         break-if-!=
         # read a character
         # no combining character allowed here
-        var g/eax: grapheme <- read-grapheme stream
+        var g/eax: code-point-utf8 <- read-code-point-utf8 stream
         var c/eax: code-point <- to-code-point g
         # if not a combining character, save for next iteration and loop
         {
@@ -672,7 +672,7 @@ fn draw-json-stream-wrapping-right-then-down screen: (addr screen), stream: (add
 
 # just return a different register
 fn read-json-code-point stream: (addr stream byte) -> _/ebx: code-point {
-  var g/eax: grapheme <- read-grapheme stream
+  var g/eax: code-point-utf8 <- read-code-point-utf8 stream
   var result/eax: code-point <- to-code-point g
   return result
 }
@@ -1012,7 +1012,7 @@ fn update-search _env: (addr environment), key: byte, users: (addr array user),
   # otherwise delegate
   var search-terms-ah/eax: (addr handle gap-buffer) <- get env, search-terms
   var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
-  var g/ecx: grapheme <- copy key
+  var g/ecx: code-point-utf8 <- copy key
   edit-gap-buffer search-terms, g
 }
 
diff --git a/editor/Mu.tmbundle/Syntaxes/Mu.tmLanguage b/editor/Mu.tmbundle/Syntaxes/Mu.tmLanguage
index 64f71320..b10d6d17 100644
--- a/editor/Mu.tmbundle/Syntaxes/Mu.tmLanguage
+++ b/editor/Mu.tmbundle/Syntaxes/Mu.tmLanguage
@@ -48,7 +48,7 @@
 		</dict>
 		<dict>
 			<key>match</key>
-			<string>\b(addr|array|boolean|byte|code-point|grapheme|handle|int|float|stream|type)\b</string>
+			<string>\b(addr|array|boolean|byte|code-point|code-point-utf8|handle|int|float|stream|type)\b</string>
 			<key>name</key>
 			<string>storage.type.mu</string>
 		</dict>
diff --git a/editor/VSCode/syntaxes/Mu.tmLanguage b/editor/VSCode/syntaxes/Mu.tmLanguage
index 64f71320..b10d6d17 100644
--- a/editor/VSCode/syntaxes/Mu.tmLanguage
+++ b/editor/VSCode/syntaxes/Mu.tmLanguage
@@ -48,7 +48,7 @@
 		</dict>
 		<dict>
 			<key>match</key>
-			<string>\b(addr|array|boolean|byte|code-point|grapheme|handle|int|float|stream|type)\b</string>
+			<string>\b(addr|array|boolean|byte|code-point|code-point-utf8|handle|int|float|stream|type)\b</string>
 			<key>name</key>
 			<string>storage.type.mu</string>
 		</dict>
diff --git a/linux/126write-int-decimal.subx b/linux/126write-int-decimal.subx
index 04f8b021..c48e17c8 100644
--- a/linux/126write-int-decimal.subx
+++ b/linux/126write-int-decimal.subx
@@ -303,7 +303,7 @@ test-write-int32-decimal-negative-multiple-digits:
     # . end
     c3/return
 
-decimal-digit?:  # c: grapheme -> result/eax: boolean
+decimal-digit?:  # c: code-point-utf8 -> result/eax: boolean
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -402,7 +402,7 @@ test-decimal-digit-above-9:
     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     c3/return
 
-to-decimal-digit:  # in: grapheme -> out/eax: int
+to-decimal-digit:  # in: code-point-utf8 -> out/eax: int
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/linux/304screen.subx b/linux/304screen.subx
index 0b24fdbf..fb8ac0ea 100644
--- a/linux/304screen.subx
+++ b/linux/304screen.subx
@@ -157,8 +157,8 @@ $print-stream-to-real-screen:end:
     5d/pop-to-ebp
     c3/return
 
-# print a grapheme in utf-8 (only up to 4 bytes so far)
-print-grapheme-to-real-screen:  # c: grapheme
+# print a code-point-utf8 in utf-8 (only up to 4 bytes so far)
+print-code-point-utf8-to-real-screen:  # c: code-point-utf8
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -170,31 +170,31 @@ print-grapheme-to-real-screen:  # c: grapheme
     8a/byte-> *(ebp+8) 0/r32/al
     # if (curr == 0) return
     3d/compare-eax-and 0/imm32
-    74/jump-if-= $print-grapheme-to-real-screen:end/disp8
+    74/jump-if-= $print-code-point-utf8-to-real-screen:end/disp8
     #
     (print-byte-to-real-screen %eax)
     # curr = *(ebp+9)
     8a/byte-> *(ebp+9) 0/r32/al
     # if (curr == 0) return
     3d/compare-eax-and 0/imm32
-    74/jump-if-= $print-grapheme-to-real-screen:end/disp8
+    74/jump-if-= $print-code-point-utf8-to-real-screen:end/disp8
     #
     (print-byte-to-real-screen %eax)
     # curr = *(ebp+10)
     8a/byte-> *(ebp+0xa) 0/r32/al
     # if (curr == 0) return
     3d/compare-eax-and 0/imm32
-    74/jump-if-= $print-grapheme-to-real-screen:end/disp8
+    74/jump-if-= $print-code-point-utf8-to-real-screen:end/disp8
     #
     (print-byte-to-real-screen %eax)
     # curr = *(ebp+11)
     8a/byte-> *(ebp+0xb) 0/r32/al
     # if (curr == 0) return
     3d/compare-eax-and 0/imm32
-    74/jump-if-= $print-grapheme-to-real-screen:end/disp8
+    74/jump-if-= $print-code-point-utf8-to-real-screen:end/disp8
     #
     (print-byte-to-real-screen %eax)
-$print-grapheme-to-real-screen:end:
+$print-code-point-utf8-to-real-screen:end:
     # . restore registers
     58/pop-to-eax
     # . epilogue
diff --git a/linux/305keyboard.subx b/linux/305keyboard.subx
index 32159e49..21be1081 100644
--- a/linux/305keyboard.subx
+++ b/linux/305keyboard.subx
@@ -121,15 +121,15 @@ $enable-keyboard-type-mode:end:
 
 # read keys or escapes up to 4 bytes
 #
-# fun fact: terminal escapes and graphemes in utf-8 don't conflict!
-# - in graphemes all but the first/lowest byte will have a 1 in the MSB (be
+# fun fact: terminal escapes and code-point-utf8s in utf-8 don't conflict!
+# - in code-point-utf8s all but the first/lowest byte will have a 1 in the MSB (be
 #   greater than 0x7f)
 # - in escapes every byte will have a 0 in the MSB
 # the two categories overlap only when the first/lowest byte is 0x1b or 'esc'
 #
 # Only use this in immediate mode; in type (typewriter) mode 4 bytes may get
 # parts of multiple keys.
-read-key-from-real-keyboard:  # -> result/eax: grapheme
+read-key-from-real-keyboard:  # -> result/eax: code-point-utf8
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
diff --git a/linux/400.mu b/linux/400.mu
index c757c970..a391a76e 100644
--- a/linux/400.mu
+++ b/linux/400.mu
@@ -113,8 +113,8 @@ sig skip-until-close-paren line: (addr stream byte)
 #sig skip-until-close-paren-in-slice curr: (addr byte), end: (addr byte) -> _/eax: (addr byte)
 sig write-stream-data f: (addr buffered-file), s: (addr stream byte)
 sig write-int32-decimal out: (addr stream byte), n: int
-sig decimal-digit? c: grapheme -> _/eax: boolean
-sig to-decimal-digit in: grapheme -> _/eax: int
+sig decimal-digit? c: code-point-utf8 -> _/eax: boolean
+sig to-decimal-digit in: code-point-utf8 -> _/eax: int
 # bad name alert
 # next-word really tokenizes
 # next-raw-word really reads whitespace-separated words
@@ -159,7 +159,7 @@ sig move-cursor-on-real-screen row: int, column: int
 sig print-string-to-real-screen s: (addr array byte)
 sig print-slice-to-real-screen s: (addr slice)
 sig print-stream-to-real-screen s: (addr stream byte)
-sig print-grapheme-to-real-screen c: grapheme
+sig print-code-point-utf8-to-real-screen c: code-point-utf8
 sig print-int32-hex-to-real-screen n: int
 sig print-int32-hex-bits-to-real-screen n: int, bits: int
 sig print-int32-decimal-to-real-screen n: int
@@ -174,7 +174,7 @@ sig hide-cursor-on-real-screen
 sig show-cursor-on-real-screen
 sig enable-keyboard-immediate-mode
 sig enable-keyboard-type-mode
-sig read-key-from-real-keyboard -> _/eax: grapheme
+sig read-key-from-real-keyboard -> _/eax: code-point-utf8
 sig read-line-from-real-keyboard out: (addr stream byte)
 sig open filename: (addr array byte), write?: boolean, out: (addr handle buffered-file)
 sig populate-buffered-file-containing contents: (addr array byte), out: (addr handle buffered-file)
diff --git a/linux/403unicode.mu b/linux/403unicode.mu
index 8594615a..655cae2b 100644
--- a/linux/403unicode.mu
+++ b/linux/403unicode.mu
@@ -1,31 +1,31 @@
 # Helpers for Unicode.
 #
-# Mu has no characters, only code points and graphemes.
+# Mu has no characters, only code points and code-point-utf8s.
 # Code points are the indivisible atoms of text streams.
 #   https://en.wikipedia.org/wiki/Code_point
 # Graphemes are the smallest self-contained unit of text.
 # Graphemes may consist of multiple code points.
 #
-# Mu graphemes are always represented in utf-8, and they are required to fit
+# Mu code-point-utf8s are always represented in utf-8, and they are required to fit
 # in 4 bytes.
 #
-# Mu doesn't currently support combining code points, or graphemes made of
+# Mu doesn't currently support combining code points, or code-point-utf8s made of
 # multiple code points. One day we will.
 # On Linux, we also don't currently support code points that translate into
-# multiple or wide graphemes. (In particular, Tab will never be supported.)
+# multiple or wide code-point-utf8s. (In particular, Tab will never be supported.)
 
 # transliterated from tb_utf8_unicode_to_char in https://github.com/nsf/termbox
 # https://wiki.tcl-lang.org/page/UTF%2D8+bit+by+bit explains the algorithm
-fn to-grapheme in: code-point -> _/eax: grapheme {
+fn to-utf8 in: code-point -> _/eax: code-point-utf8 {
   var c/eax: int <- copy in
   var num-trailers/ecx: int <- copy 0
   var first/edx: int <- copy 0
-  $to-grapheme:compute-length: {
+  $to-utf8:compute-length: {
     # single byte: just return it
     compare c, 0x7f
     {
       break-if->
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     # 2 bytes
@@ -34,7 +34,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
       break-if->
       num-trailers <- copy 1
       first <- copy 0xc0
-      break $to-grapheme:compute-length
+      break $to-utf8:compute-length
     }
     # 3 bytes
     compare c, 0xffff
@@ -42,7 +42,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
       break-if->
       num-trailers <- copy 2
       first <- copy 0xe0
-      break $to-grapheme:compute-length
+      break $to-utf8:compute-length
     }
     # 4 bytes
     compare c, 0x1fffff
@@ -50,7 +50,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
       break-if->
       num-trailers <- copy 3
       first <- copy 0xf0
-      break $to-grapheme:compute-length
+      break $to-utf8:compute-length
     }
     # more than 4 bytes: unsupported
     # TODO: print to stderr
@@ -65,7 +65,7 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
     }
   }
   # emit trailer bytes, 6 bits from 'in', first two bits '10'
-  var result/edi: grapheme <- copy 0
+  var result/edi: code-point-utf8 <- copy 0
   {
     compare num-trailers, 0
     break-if-<=
@@ -87,16 +87,16 @@ fn to-grapheme in: code-point -> _/eax: grapheme {
   return result
 }
 
-# single-byte code point have identical graphemes
-fn test-to-grapheme-single-byte {
+# single-byte code point have identical code-point-utf8s
+fn test-to-utf8-single-byte {
   var in-int/ecx: int <- copy 0
   {
     compare in-int, 0x7f
     break-if->
     var in/eax: code-point <- copy in-int
-    var out/eax: grapheme <- to-grapheme in
+    var out/eax: code-point-utf8 <- to-utf8 in
     var out-int/eax: int <- copy out
-    check-ints-equal out-int, in-int, "F - test-to-grapheme-single-byte"
+    check-ints-equal out-int, in-int, "F - test-to-utf8-single-byte"
     in-int <- increment
     loop
   }
@@ -104,55 +104,55 @@ fn test-to-grapheme-single-byte {
 
                                                               # byte       | byte      | byte      | byte
 # smallest 2-byte utf-8
-fn test-to-grapheme-two-bytes-min {
+fn test-to-utf8-two-bytes-min {
   var in/eax: code-point <- copy 0x80                         #                                 10     00-0000
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0x80c2, "F - to-grapheme/2a"      #                         110 0-0010  10 00-0000
+  check-ints-equal out-int, 0x80c2, "F - to-utf8/2a"      #                         110 0-0010  10 00-0000
 }
 
 # largest 2-byte utf-8
-fn test-to-grapheme-two-bytes-max {
+fn test-to-utf8-two-bytes-max {
   var in/eax: code-point <- copy 0x7ff                        #                             1-1111     11-1111
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0xbfdf, "F - to-grapheme/2b"      #                         110 1-1111  10 11-1111
+  check-ints-equal out-int, 0xbfdf, "F - to-utf8/2b"      #                         110 1-1111  10 11-1111
 }
 
 # smallest 3-byte utf-8
-fn test-to-grapheme-three-bytes-min {
+fn test-to-utf8-three-bytes-min {
   var in/eax: code-point <- copy 0x800                        #                            10-0000     00-0000
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0x80a0e0, "F - to-grapheme/3a"    #              1110 0000  10 10-0000  10 00-0000
+  check-ints-equal out-int, 0x80a0e0, "F - to-utf8/3a"    #              1110 0000  10 10-0000  10 00-0000
 }
 
 # largest 3-byte utf-8
-fn test-to-grapheme-three-bytes-max {
+fn test-to-utf8-three-bytes-max {
   var in/eax: code-point <- copy 0xffff                       #                   1111     11-1111     11-1111
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0xbfbfef, "F - to-grapheme/3b"    #              1110 1111  10 11-1111  10 11-1111
+  check-ints-equal out-int, 0xbfbfef, "F - to-utf8/3b"    #              1110 1111  10 11-1111  10 11-1111
 }
 
 # smallest 4-byte utf-8
-fn test-to-grapheme-four-bytes-min {
+fn test-to-utf8-four-bytes-min {
   var in/eax: code-point <- copy 0x10000                      #                 1-0000     00-0000     00-0000
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0x808090f0, "F - to-grapheme/4a"  # 1111-0 000  10 01-0000  10 00-0000  10 00-0000
+  check-ints-equal out-int, 0x808090f0, "F - to-utf8/4a"  # 1111-0 000  10 01-0000  10 00-0000  10 00-0000
 }
 
 # largest 4-byte utf-8
-fn test-to-grapheme-four-bytes-max {
+fn test-to-utf8-four-bytes-max {
   var in/eax: code-point <- copy 0x1fffff                     #        111     11-1111     11-1111     11-1111
-  var out/eax: grapheme <- to-grapheme in
+  var out/eax: code-point-utf8 <- to-utf8 in
   var out-int/eax: int <- copy out
-  check-ints-equal out-int, 0xbfbfbff7, "F - to-grapheme/4b"  # 1111-0 111  10 11-1111  10 11-1111  10 11-1111
+  check-ints-equal out-int, 0xbfbfbff7, "F - to-utf8/4b"  # 1111-0 111  10 11-1111  10 11-1111  10 11-1111
 }
 
-# read the next grapheme from a stream of bytes
-fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
+# read the next code-point-utf8 from a stream of bytes
+fn read-code-point-utf8 in: (addr stream byte) -> _/eax: code-point-utf8 {
   # if at eof, return EOF
   {
     var eof?/eax: boolean <- stream-empty? in
@@ -162,18 +162,18 @@ fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
   }
   var c/eax: byte <- read-byte in
   var num-trailers/ecx: int <- copy 0
-  $read-grapheme:compute-length: {
+  $read-code-point-utf8:compute-length: {
     # single byte: just return it
     compare c, 0xc0
     {
       break-if->=
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     compare c, 0xfe
     {
       break-if-<
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     # 2 bytes
@@ -181,23 +181,23 @@ fn read-grapheme in: (addr stream byte) -> _/eax: grapheme {
     {
       break-if->=
       num-trailers <- copy 1
-      break $read-grapheme:compute-length
+      break $read-code-point-utf8:compute-length
     }
     # 3 bytes
     compare c, 0xf0
     {
       break-if->=
       num-trailers <- copy 2
-      break $read-grapheme:compute-length
+      break $read-code-point-utf8:compute-length
     }
     # 4 bytes
     compare c, 0xf8
     {
       break-if->=
       num-trailers <- copy 3
-      break $read-grapheme:compute-length
+      break $read-code-point-utf8:compute-length
     }
-$read-grapheme:abort: {
+$read-code-point-utf8:abort: {
       # TODO: print to stderr
       print-string-to-real-screen "utf-8 encodings larger than 4 bytes are not yet supported. First byte seen: "
       var n/eax: int <- copy c
@@ -208,7 +208,7 @@ $read-grapheme:abort: {
     }
   }
   # prepend trailer bytes
-  var result/edi: grapheme <- copy c
+  var result/edi: code-point-utf8 <- copy c
   var num-byte-shifts/edx: int <- copy 1
   {
     compare num-trailers, 0
@@ -225,48 +225,48 @@ $read-grapheme:abort: {
   return result
 }
 
-fn test-read-grapheme {
+fn test-read-code-point-utf8 {
   var s: (stream byte 0x30)
   var s2/ecx: (addr stream byte) <- address s
   write s2, "aΒc世d界e"
-  var c/eax: grapheme <- read-grapheme s2
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x61, "F - test grapheme/0"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x61, "F - test code-point-utf8/0"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x92ce/greek-capital-letter-beta, "F - test grapheme/1"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x92ce/greek-capital-letter-beta, "F - test code-point-utf8/1"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x63, "F - test grapheme/2"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x63, "F - test code-point-utf8/2"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x96b8e4, "F - test grapheme/3"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x96b8e4, "F - test code-point-utf8/3"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x64, "F - test grapheme/4"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x64, "F - test code-point-utf8/4"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x8c95e7, "F - test grapheme/5"
-  var c/eax: grapheme <- read-grapheme s2
+  check-ints-equal n, 0x8c95e7, "F - test code-point-utf8/5"
+  var c/eax: code-point-utf8 <- read-code-point-utf8 s2
   var n/eax: int <- copy c
-  check-ints-equal n, 0x65, "F - test grapheme/6"
+  check-ints-equal n, 0x65, "F - test code-point-utf8/6"
 }
 
-fn read-grapheme-buffered in: (addr buffered-file) -> _/eax: grapheme {
+fn read-code-point-utf8-buffered in: (addr buffered-file) -> _/eax: code-point-utf8 {
   var c/eax: byte <- read-byte-buffered in
   var num-trailers/ecx: int <- copy 0
-  $read-grapheme-buffered:compute-length: {
+  $read-code-point-utf8-buffered:compute-length: {
     # single byte: just return it
     compare c, 0xc0
     {
       break-if->=
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     compare c, 0xfe
     {
       break-if-<
-      var g/eax: grapheme <- copy c
+      var g/eax: code-point-utf8 <- copy c
       return g
     }
     # 2 bytes
@@ -274,23 +274,23 @@ fn read-grapheme-buffered in: (addr buffered-file) -> _/eax: grapheme {
     {
       break-if->=
       num-trailers <- copy 1
-      break $read-grapheme-buffered:compute-length
+      break $read-code-point-utf8-buffered:compute-length
     }
     # 3 bytes
     compare c, 0xf0
     {
       break-if->=
       num-trailers <- copy 2
-      break $read-grapheme-buffered:compute-length
+      break $read-code-point-utf8-buffered:compute-length
     }
     # 4 bytes
     compare c, 0xf8
     {
       break-if->=
       num-trailers <- copy 3
-      break $read-grapheme-buffered:compute-length
+      break $read-code-point-utf8-buffered:compute-length
     }
-$read-grapheme-buffered:abort: {
+$read-code-point-utf8-buffered:abort: {
       # TODO: print to stderr
       print-string-to-real-screen "utf-8 encodings larger than 4 bytes are not supported. First byte seen: "
       var n/eax: int <- copy c
@@ -301,7 +301,7 @@ $read-grapheme-buffered:abort: {
     }
   }
   # prepend trailer bytes
-  var result/edi: grapheme <- copy c
+  var result/edi: code-point-utf8 <- copy c
   var num-byte-shifts/edx: int <- copy 1
   {
     compare num-trailers, 0
@@ -364,23 +364,23 @@ fn test-shift-left-bytes-5 {
   check-ints-equal result, 0, "F - shift-left-bytes >4"
 }
 
-# write a grapheme to a stream of bytes
+# write a code-point-utf8 to a stream of bytes
 # this is like write-to-stream, except we skip leading 0 bytes
-fn write-grapheme out: (addr stream byte), g: grapheme {
-$write-grapheme:body: {
+fn write-code-point-utf8 out: (addr stream byte), g: code-point-utf8 {
+$write-code-point-utf8:body: {
   var c/eax: int <- copy g
   append-byte out, c  # first byte is always written
   c <- shift-right 8
   compare c, 0
-  break-if-= $write-grapheme:body
+  break-if-= $write-code-point-utf8:body
   append-byte out, c
   c <- shift-right 8
   compare c, 0
-  break-if-= $write-grapheme:body
+  break-if-= $write-code-point-utf8:body
   append-byte out, c
   c <- shift-right 8
   compare c, 0
-  break-if-= $write-grapheme:body
+  break-if-= $write-code-point-utf8:body
   append-byte out, c
 }
 }
diff --git a/linux/405screen.mu b/linux/405screen.mu
index c850df2a..ffb0deb8 100644
--- a/linux/405screen.mu
+++ b/linux/405screen.mu
@@ -18,7 +18,7 @@ type screen {
 }
 
 type screen-cell {
-  data: grapheme
+  data: code-point-utf8
   color: int
   background-color: int
   bold?: boolean
@@ -83,7 +83,7 @@ fn clear-screen screen: (addr screen) {
     return
   }
   # fake screen
-  var space/edi: grapheme <- copy 0x20
+  var space/edi: code-point-utf8 <- copy 0x20
   move-cursor screen, 1, 1
   var screen-addr/esi: (addr screen) <- copy screen
   var i/eax: int <- copy 1
@@ -96,7 +96,7 @@ fn clear-screen screen: (addr screen) {
     {
       compare j, *ncols
       break-if->
-      print-grapheme screen, space
+      print-code-point-utf8 screen, space
       j <- increment
       loop
     }
@@ -186,8 +186,8 @@ fn print-stream _screen: (addr screen), s: (addr stream byte) {
     var done?/eax: boolean <- stream-empty? s
     compare done?, 0
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s
-    print-grapheme screen, g
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s
+    print-code-point-utf8 screen, g
     loop
   }
 }
@@ -211,11 +211,11 @@ fn print-array-of-ints-in-decimal screen: (addr screen), _a: (addr array int) {
   }
 }
 
-fn print-grapheme screen: (addr screen), c: grapheme {
+fn print-code-point-utf8 screen: (addr screen), c: code-point-utf8 {
   compare screen, 0
   {
     break-if-!=
-    print-grapheme-to-real-screen c
+    print-code-point-utf8-to-real-screen c
     return
   }
   # fake screen
@@ -239,7 +239,7 @@ fn print-grapheme screen: (addr screen), c: grapheme {
     break-if-<=
     copy-to *cursor-row-addr, num-rows
     # if (top-index > data size) top-index = 0, otherwise top-index += num-cols
-    $print-grapheme:perform-scroll: {
+    $print-code-point-utf8:perform-scroll: {
       var top-index-addr/ebx: (addr int) <- get screen-addr, top-index
       var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data
       var data/eax: (addr array screen-cell) <- lookup *data-ah
@@ -248,7 +248,7 @@ fn print-grapheme screen: (addr screen), c: grapheme {
       {
         break-if->=
         add-to *top-index-addr, num-cols
-        break $print-grapheme:perform-scroll
+        break $print-code-point-utf8:perform-scroll
       }
       {
         break-if-<
@@ -257,7 +257,7 @@ fn print-grapheme screen: (addr screen), c: grapheme {
     }
   }
   var idx/ecx: int <- current-screen-cell-index screen-addr
-#?   print-string-to-real-screen "printing grapheme at screen index "
+#?   print-string-to-real-screen "printing code-point-utf8 at screen index "
 #?   print-int32-hex-to-real-screen idx
 #?   print-string-to-real-screen ": "
   var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data
@@ -266,9 +266,9 @@ fn print-grapheme screen: (addr screen), c: grapheme {
   var dest-cell/ecx: (addr screen-cell) <- index data, offset
   var src-cell/eax: (addr screen-cell) <- get screen-addr, curr-attributes
   copy-object src-cell, dest-cell
-  var dest/eax: (addr grapheme) <- get dest-cell, data
-  var c2/ecx: grapheme <- copy c
-#?   print-grapheme-to-real-screen c2
+  var dest/eax: (addr code-point-utf8) <- get dest-cell, data
+  var c2/ecx: code-point-utf8 <- copy c
+#?   print-code-point-utf8-to-real-screen c2
 #?   print-string-to-real-screen "\n"
   copy-to *dest, c2
   increment *cursor-col-addr
@@ -305,21 +305,21 @@ fn screen-cell-index screen-on-stack: (addr screen), row: int, col: int -> _/ecx
   return result
 }
 
-fn screen-grapheme-at screen-on-stack: (addr screen), row: int, col: int -> _/eax: grapheme {
+fn screen-code-point-utf8-at screen-on-stack: (addr screen), row: int, col: int -> _/eax: code-point-utf8 {
   var screen-addr/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen-addr, row, col
-  var result/eax: grapheme <- screen-grapheme-at-idx screen-addr, idx
+  var result/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen-addr, idx
   return result
 }
 
-fn screen-grapheme-at-idx screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: grapheme {
+fn screen-code-point-utf8-at-idx screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: code-point-utf8 {
   var screen-addr/esi: (addr screen) <- copy screen-on-stack
   var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data
   var data/eax: (addr array screen-cell) <- lookup *data-ah
   var idx/ecx: int <- copy idx-on-stack
   var offset/ecx: (offset screen-cell) <- compute-offset data, idx
   var cell/eax: (addr screen-cell) <- index data, offset
-  var src/eax: (addr grapheme) <- get cell, data
+  var src/eax: (addr code-point-utf8) <- get cell, data
   return *src
 }
 
@@ -433,8 +433,8 @@ fn screen-blink-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/e
 }
 
 fn print-code-point screen: (addr screen), c: code-point {
-  var g/eax: grapheme <- to-grapheme c
-  print-grapheme screen, g
+  var g/eax: code-point-utf8 <- to-utf8 c
+  print-code-point-utf8 screen, g
 }
 
 fn print-int32-hex screen: (addr screen), n: int {
@@ -453,8 +453,8 @@ fn print-int32-hex screen: (addr screen), n: int {
     var done?/eax: boolean <- stream-empty? s2-addr
     compare done?, 0
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s2-addr
-    print-grapheme screen, g
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s2-addr
+    print-code-point-utf8 screen, g
     loop
   }
 }
@@ -475,8 +475,8 @@ fn print-int32-hex-bits screen: (addr screen), n: int, bits: int {
     var done?/eax: boolean <- stream-empty? s2-addr
     compare done?, 0
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s2-addr
-    print-grapheme screen, g
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s2-addr
+    print-code-point-utf8 screen, g
     loop
   }
 }
@@ -497,8 +497,8 @@ fn print-int32-decimal screen: (addr screen), n: int {
     var done?/eax: boolean <- stream-empty? s2-addr
     compare done?, 0
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s2-addr
-    print-grapheme screen, g
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s2-addr
+    print-code-point-utf8 screen, g
     loop
   }
 }
@@ -631,7 +631,7 @@ fn check-screen-row screen: (addr screen), row-idx: int, expected: (addr array b
 fn check-screen-row-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -639,35 +639,35 @@ fn check-screen-row-from screen-on-stack: (addr screen), row-idx: int, col-idx:
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    # compare graphemes
-    $check-screen-row-from:compare-graphemes: {
-      # if expected-grapheme is space, null grapheme is also ok
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    # compare code-point-utf8s
+    $check-screen-row-from:compare-code-point-utf8s: {
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
-        break-if-= $check-screen-row-from:compare-graphemes
+        break-if-= $check-screen-row-from:compare-code-point-utf8s
       }
-      # if (g == expected-grapheme) print "."
-      compare g, expected-grapheme
+      # if (g == expected-code-point-utf8) print "."
+      compare g, expected-code-point-utf8
       {
         break-if-!=
         print-string-to-real-screen "."
-        break $check-screen-row-from:compare-graphemes
+        break $check-screen-row-from:compare-code-point-utf8s
       }
       # otherwise print an error
       print-string-to-real-screen msg
       print-string-to-real-screen ": expected '"
-      print-grapheme-to-real-screen expected-grapheme
+      print-code-point-utf8-to-real-screen expected-code-point-utf8
       print-string-to-real-screen "' at ("
       print-int32-hex-to-real-screen row-idx
       print-string-to-real-screen ", "
       print-int32-hex-to-real-screen col-idx
       print-string-to-real-screen ") but observed '"
-      print-grapheme-to-real-screen g
+      print-code-point-utf8-to-real-screen g
       print-string-to-real-screen "'\n"
     }
     idx <- increment
@@ -685,7 +685,7 @@ fn check-screen-row-in-color screen: (addr screen), fg: int, row-idx: int, expec
 fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -693,45 +693,45 @@ fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-i
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var _expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    var expected-grapheme/edi: grapheme <- copy _expected-grapheme
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var _expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    var expected-code-point-utf8/edi: code-point-utf8 <- copy _expected-code-point-utf8
     $check-screen-row-in-color-from:compare-cells: {
-      # if expected-grapheme is space, null grapheme is also ok
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
         break-if-= $check-screen-row-in-color-from:compare-cells
       }
-      # if expected-grapheme is space, a different color is ok
+      # if expected-code-point-utf8 is space, a different color is ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         var color/eax: int <- screen-color-at-idx screen, idx
         compare color, fg
         break-if-!= $check-screen-row-in-color-from:compare-cells
       }
-      # compare graphemes
-      $check-screen-row-in-color-from:compare-graphemes: {
-        # if (g == expected-grapheme) print "."
-        compare g, expected-grapheme
+      # compare code-point-utf8s
+      $check-screen-row-in-color-from:compare-code-point-utf8s: {
+        # if (g == expected-code-point-utf8) print "."
+        compare g, expected-code-point-utf8
         {
           break-if-!=
           print-string-to-real-screen "."
-          break $check-screen-row-in-color-from:compare-graphemes
+          break $check-screen-row-in-color-from:compare-code-point-utf8s
         }
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
         print-int32-hex-to-real-screen col-idx
         print-string-to-real-screen ") but observed '"
-        print-grapheme-to-real-screen g
+        print-code-point-utf8-to-real-screen g
         print-string-to-real-screen "'\n"
       }
       $check-screen-row-in-color-from:compare-colors: {
@@ -745,7 +745,7 @@ fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-i
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
@@ -772,7 +772,7 @@ fn check-screen-row-in-background-color screen: (addr screen), bg: int, row-idx:
 fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -780,45 +780,45 @@ fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg:
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var _expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    var expected-grapheme/edx: grapheme <- copy _expected-grapheme
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var _expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    var expected-code-point-utf8/edx: code-point-utf8 <- copy _expected-code-point-utf8
     $check-screen-row-in-background-color-from:compare-cells: {
-      # if expected-grapheme is space, null grapheme is also ok
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
         break-if-= $check-screen-row-in-background-color-from:compare-cells
       }
-      # if expected-grapheme is space, a different color is ok
+      # if expected-code-point-utf8 is space, a different color is ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         var color/eax: int <- screen-background-color-at-idx screen, idx
         compare color, bg
         break-if-!= $check-screen-row-in-background-color-from:compare-cells
       }
-      # compare graphemes
-      $check-screen-row-in-background-color-from:compare-graphemes: {
-        # if (g == expected-grapheme) print "."
-        compare g, expected-grapheme
+      # compare code-point-utf8s
+      $check-screen-row-in-background-color-from:compare-code-point-utf8s: {
+        # if (g == expected-code-point-utf8) print "."
+        compare g, expected-code-point-utf8
         {
           break-if-!=
           print-string-to-real-screen "."
-          break $check-screen-row-in-background-color-from:compare-graphemes
+          break $check-screen-row-in-background-color-from:compare-code-point-utf8s
         }
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
         print-int32-hex-to-real-screen col-idx
         print-string-to-real-screen ") but observed '"
-        print-grapheme-to-real-screen g
+        print-code-point-utf8-to-real-screen g
         print-string-to-real-screen "'\n"
       }
       $check-screen-row-in-background-color-from:compare-colors: {
@@ -832,7 +832,7 @@ fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg:
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
@@ -857,7 +857,7 @@ fn check-screen-row-in-bold screen: (addr screen), row-idx: int, expected: (addr
 fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -865,45 +865,45 @@ fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, c
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var _expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    var expected-grapheme/edx: grapheme <- copy _expected-grapheme
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var _expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    var expected-code-point-utf8/edx: code-point-utf8 <- copy _expected-code-point-utf8
     $check-screen-row-in-bold-from:compare-cells: {
-      # if expected-grapheme is space, null grapheme is also ok
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
         break-if-= $check-screen-row-in-bold-from:compare-cells
       }
-      # if expected-grapheme is space, non-bold is ok
+      # if expected-code-point-utf8 is space, non-bold is ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         var bold?/eax: boolean <- screen-bold-at-idx? screen, idx
         compare bold?, 1
         break-if-!= $check-screen-row-in-bold-from:compare-cells
       }
-      # compare graphemes
-      $check-screen-row-in-bold-from:compare-graphemes: {
-        # if (g == expected-grapheme) print "."
-        compare g, expected-grapheme
+      # compare code-point-utf8s
+      $check-screen-row-in-bold-from:compare-code-point-utf8s: {
+        # if (g == expected-code-point-utf8) print "."
+        compare g, expected-code-point-utf8
         {
           break-if-!=
           print-string-to-real-screen "."
-          break $check-screen-row-in-bold-from:compare-graphemes
+          break $check-screen-row-in-bold-from:compare-code-point-utf8s
         }
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
         print-int32-hex-to-real-screen col-idx
         print-string-to-real-screen ") but observed '"
-        print-grapheme-to-real-screen g
+        print-code-point-utf8-to-real-screen g
         print-string-to-real-screen "'\n"
       }
       $check-screen-row-in-bold-from:compare-bold: {
@@ -917,7 +917,7 @@ fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, c
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
@@ -938,7 +938,7 @@ fn check-screen-row-in-underline screen: (addr screen), row-idx: int, expected:
 fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -946,45 +946,45 @@ fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: i
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var _expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    var expected-grapheme/edx: grapheme <- copy _expected-grapheme
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var _expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    var expected-code-point-utf8/edx: code-point-utf8 <- copy _expected-code-point-utf8
     $check-screen-row-in-underline-from:compare-cells: {
-      # if expected-grapheme is space, null grapheme is also ok
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
         break-if-= $check-screen-row-in-underline-from:compare-cells
       }
-      # if expected-grapheme is space, non-underline is ok
+      # if expected-code-point-utf8 is space, non-underline is ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         var underline?/eax: boolean <- screen-underline-at-idx? screen, idx
         compare underline?, 1
         break-if-!= $check-screen-row-in-underline-from:compare-cells
       }
-      # compare graphemes
-      $check-screen-row-in-underline-from:compare-graphemes: {
-        # if (g == expected-grapheme) print "."
-        compare g, expected-grapheme
+      # compare code-point-utf8s
+      $check-screen-row-in-underline-from:compare-code-point-utf8s: {
+        # if (g == expected-code-point-utf8) print "."
+        compare g, expected-code-point-utf8
         {
           break-if-!=
           print-string-to-real-screen "."
-          break $check-screen-row-in-underline-from:compare-graphemes
+          break $check-screen-row-in-underline-from:compare-code-point-utf8s
         }
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
         print-int32-hex-to-real-screen col-idx
         print-string-to-real-screen ") but observed '"
-        print-grapheme-to-real-screen g
+        print-code-point-utf8-to-real-screen g
         print-string-to-real-screen "'\n"
       }
       $check-screen-row-in-underline-from:compare-underline: {
@@ -998,7 +998,7 @@ fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: i
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
@@ -1019,7 +1019,7 @@ fn check-screen-row-in-reverse screen: (addr screen), row-idx: int, expected: (a
 fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -1027,45 +1027,45 @@ fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var _expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    var expected-grapheme/edx: grapheme <- copy _expected-grapheme
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var _expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    var expected-code-point-utf8/edx: code-point-utf8 <- copy _expected-code-point-utf8
     $check-screen-row-in-reverse-from:compare-cells: {
-      # if expected-grapheme is space, null grapheme is also ok
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
         break-if-= $check-screen-row-in-reverse-from:compare-cells
       }
-      # if expected-grapheme is space, non-reverse is ok
+      # if expected-code-point-utf8 is space, non-reverse is ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx
         compare reverse?, 1
         break-if-!= $check-screen-row-in-reverse-from:compare-cells
       }
-      # compare graphemes
-      $check-screen-row-in-reverse-from:compare-graphemes: {
-        # if (g == expected-grapheme) print "."
-        compare g, expected-grapheme
+      # compare code-point-utf8s
+      $check-screen-row-in-reverse-from:compare-code-point-utf8s: {
+        # if (g == expected-code-point-utf8) print "."
+        compare g, expected-code-point-utf8
         {
           break-if-!=
           print-string-to-real-screen "."
-          break $check-screen-row-in-reverse-from:compare-graphemes
+          break $check-screen-row-in-reverse-from:compare-code-point-utf8s
         }
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
         print-int32-hex-to-real-screen col-idx
         print-string-to-real-screen ") but observed '"
-        print-grapheme-to-real-screen g
+        print-code-point-utf8-to-real-screen g
         print-string-to-real-screen "'\n"
       }
       $check-screen-row-in-reverse-from:compare-reverse: {
@@ -1079,7 +1079,7 @@ fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
@@ -1100,7 +1100,7 @@ fn check-screen-row-in-blinking screen: (addr screen), row-idx: int, expected: (
 fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
   var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx
-  # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
+  # compare 'expected' with the screen contents starting at 'idx', code-point-utf8 by code-point-utf8
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
   write e-addr, expected
@@ -1108,45 +1108,45 @@ fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: in
     var done?/eax: boolean <- stream-empty? e-addr
     compare done?, 0
     break-if-!=
-    var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx
-    var g/ebx: grapheme <- copy _g
-    var _expected-grapheme/eax: grapheme <- read-grapheme e-addr
-    var expected-grapheme/edx: grapheme <- copy _expected-grapheme
+    var _g/eax: code-point-utf8 <- screen-code-point-utf8-at-idx screen, idx
+    var g/ebx: code-point-utf8 <- copy _g
+    var _expected-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 e-addr
+    var expected-code-point-utf8/edx: code-point-utf8 <- copy _expected-code-point-utf8
     $check-screen-row-in-blinking-from:compare-cells: {
-      # if expected-grapheme is space, null grapheme is also ok
+      # if expected-code-point-utf8 is space, null code-point-utf8 is also ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         compare g, 0
         break-if-= $check-screen-row-in-blinking-from:compare-cells
       }
-      # if expected-grapheme is space, non-blinking is ok
+      # if expected-code-point-utf8 is space, non-blinking is ok
       {
-        compare expected-grapheme, 0x20
+        compare expected-code-point-utf8, 0x20
         break-if-!=
         var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx
         compare blinking?, 1
         break-if-!= $check-screen-row-in-blinking-from:compare-cells
       }
-      # compare graphemes
-      $check-screen-row-in-blinking-from:compare-graphemes: {
-        # if (g == expected-grapheme) print "."
-        compare g, expected-grapheme
+      # compare code-point-utf8s
+      $check-screen-row-in-blinking-from:compare-code-point-utf8s: {
+        # if (g == expected-code-point-utf8) print "."
+        compare g, expected-code-point-utf8
         {
           break-if-!=
           print-string-to-real-screen "."
-          break $check-screen-row-in-blinking-from:compare-graphemes
+          break $check-screen-row-in-blinking-from:compare-code-point-utf8s
         }
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
         print-int32-hex-to-real-screen col-idx
         print-string-to-real-screen ") but observed '"
-        print-grapheme-to-real-screen g
+        print-code-point-utf8-to-real-screen g
         print-string-to-real-screen "'\n"
       }
       $check-screen-row-in-blinking-from:compare-blinking: {
@@ -1160,7 +1160,7 @@ fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: in
         # otherwise print an error
         print-string-to-real-screen msg
         print-string-to-real-screen ": expected '"
-        print-grapheme-to-real-screen expected-grapheme
+        print-code-point-utf8-to-real-screen expected-code-point-utf8
         print-string-to-real-screen "' at ("
         print-int32-hex-to-real-screen row-idx
         print-string-to-real-screen ", "
@@ -1175,21 +1175,21 @@ fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: in
   }
 }
 
-fn test-print-single-grapheme {
+fn test-print-single-code-point-utf8 {
   var screen-on-stack: screen
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
-  check-screen-row screen, 1/row, "a", "F - test-print-single-grapheme"  # top-left corner of the screen
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
+  check-screen-row screen, 1/row, "a", "F - test-print-single-code-point-utf8"  # top-left corner of the screen
 }
 
-fn test-print-multiple-graphemes {
+fn test-print-multiple-code-point-utf8s {
   var screen-on-stack: screen
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   print-string screen, "Hello, 世界"
-  check-screen-row screen, 1/row, "Hello, 世界", "F - test-print-multiple-graphemes"
+  check-screen-row screen, 1/row, "Hello, 世界", "F - test-print-multiple-code-point-utf8s"
 }
 
 fn test-move-cursor {
@@ -1197,8 +1197,8 @@ fn test-move-cursor {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   move-cursor screen, 1, 4
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   check-screen-row screen, 1/row, "   a", "F - test-move-cursor"  # top row
 }
 
@@ -1207,8 +1207,8 @@ fn test-move-cursor-zeroes {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   move-cursor screen, 0, 0
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   check-screen-row screen, 1/row, "a", "F - test-move-cursor-zeroes"  # top-left corner of the screen
 }
 
@@ -1217,8 +1217,8 @@ fn test-move-cursor-zero-row {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   move-cursor screen, 0, 2
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   check-screen-row screen, 1/row, " a", "F - test-move-cursor-zero-row"  # top row
 }
 
@@ -1227,8 +1227,8 @@ fn test-move-cursor-zero-column {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   move-cursor screen, 4, 0
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   check-screen-row screen, 4/row, "a", "F - test-move-cursor-zero-column"
 }
 
@@ -1237,8 +1237,8 @@ fn test-move-cursor-negative-row {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5, 3
   move-cursor screen, -1/row, 2/col
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   # no move
   check-screen-row screen, 1/row, "a", "F - test-move-cursor-negative-row"
 }
@@ -1248,8 +1248,8 @@ fn test-move-cursor-negative-column {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5, 3
   move-cursor screen, 2/row, -1/col
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   # no move
   check-screen-row screen, 1/row, "a", "F - test-move-cursor-negative-column"
 }
@@ -1259,8 +1259,8 @@ fn test-move-cursor-column-too-large {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 3/cols
   move-cursor screen, 1/row, 4/col
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   # top row is empty
   check-screen-row screen, 1/row, "   ", "F - test-move-cursor-column-too-large"
   # character shows up on next row
@@ -1272,8 +1272,8 @@ fn test-move-cursor-column-too-large-saturates {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 3/cols
   move-cursor screen, 1/row, 6/col
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   # top row is empty
   check-screen-row screen, 1/row, "   ", "F - test-move-cursor-column-too-large-saturates"  # top-left corner of the screen
   # character shows up at the start of next row
@@ -1285,8 +1285,8 @@ fn test-move-cursor-row-too-large {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 3/cols
   move-cursor screen, 6/row, 2/col
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   # bottom row shows the character
   check-screen-row screen, 5/row, " a", "F - test-move-cursor-row-too-large"
 }
@@ -1296,8 +1296,8 @@ fn test-move-cursor-row-too-large-saturates {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 3/cols
   move-cursor screen, 9/row, 2/col
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   # bottom row shows the character
   check-screen-row screen, 5/row, " a", "F - test-move-cursor-row-too-large-saturates"
 }
@@ -1307,8 +1307,8 @@ fn test-check-screen-row-from {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   move-cursor screen, 1, 4
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   check-screen-row screen, 1/row, "   a", "F - test-check-screen-row-from/baseline"
   check-screen-row-from screen, 1/row, 4/col, "a", "F - test-check-screen-row-from"
 }
@@ -1328,8 +1328,8 @@ fn test-check-screen-scrolls-on-overflow {
   initialize-screen screen, 5/rows, 4/cols
   # single character starting at bottom right
   move-cursor screen, 5/rows, 4/cols
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   check-screen-row-from screen, 5/row, 4/col, "a", "F - test-check-screen-scrolls-on-overflow/baseline"  # bottom-right corner of the screen
   # multiple characters starting at bottom right
   move-cursor screen, 5, 4
@@ -1348,14 +1348,14 @@ fn test-check-screen-color {
   var screen-on-stack: screen
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   start-color screen, 1/fg, 0/bg
   c <- copy 0x62/b
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   start-color screen, 0/fg, 7/bg
   c <- copy 0x63/c
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   check-screen-row-in-color screen, 0/fg, 1/row, "a c", "F - test-check-screen-color"
 }
 
@@ -1363,14 +1363,14 @@ fn test-check-screen-background-color {
   var screen-on-stack: screen
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   start-color screen, 0/fg, 1/bg
   c <- copy 0x62/b
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   start-color screen, 0/fg, 7/bg
   c <- copy 0x63/c
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   check-screen-row-in-background-color screen, 7/bg, 1/row, "a c", "F - test-check-screen-background-color"
 }
 
@@ -1379,14 +1379,14 @@ fn test-check-screen-bold {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   start-bold screen
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   reset-formatting screen
   c <- copy 0x62/b
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   start-bold screen
   c <- copy 0x63/c
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   check-screen-row-in-bold screen, 1/row, "a c", "F - test-check-screen-bold"
 }
 
@@ -1395,14 +1395,14 @@ fn test-check-screen-underline {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   start-underline screen
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   reset-formatting screen
   c <- copy 0x62/b
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   start-underline screen
   c <- copy 0x63/c
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   check-screen-row-in-underline screen, 1/row, "a c", "F - test-check-screen-underline"
 }
 
@@ -1411,14 +1411,14 @@ fn test-check-screen-reverse {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   start-reverse-video screen
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   reset-formatting screen
   c <- copy 0x62/b
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   start-reverse-video screen
   c <- copy 0x63/c
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   check-screen-row-in-reverse screen, 1/row, "a c", "F - test-check-screen-reverse"
 }
 
@@ -1427,14 +1427,14 @@ fn test-check-screen-blinking {
   var screen/esi: (addr screen) <- address screen-on-stack
   initialize-screen screen, 5/rows, 4/cols
   start-blinking screen
-  var c/eax: grapheme <- copy 0x61/a
-  print-grapheme screen, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  print-code-point-utf8 screen, c
   reset-formatting screen
   c <- copy 0x62/b
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   start-blinking screen
   c <- copy 0x63/c
-  print-grapheme screen, c
+  print-code-point-utf8 screen, c
   check-screen-row-in-blinking screen, 1/row, "a c", "F - test-check-screen-blinking"
 }
 
diff --git a/linux/407right-justify.mu b/linux/407right-justify.mu
index b7322ae5..aa767782 100644
--- a/linux/407right-justify.mu
+++ b/linux/407right-justify.mu
@@ -6,7 +6,7 @@ fn print-int32-decimal-right-justified screen: (addr screen), n: int, _width: in
   {
     compare n-width, width
     break-if->=
-    print-grapheme screen, 0x20/space
+    print-code-point-utf8 screen, 0x20/space
     width <- decrement
     loop
   }
diff --git a/linux/411string.mu b/linux/411string.mu
index cf0471ac..493c9b56 100644
--- a/linux/411string.mu
+++ b/linux/411string.mu
@@ -1,4 +1,4 @@
-# read up to 'len' graphemes after skipping the first 'start' ones
+# read up to 'len' code-point-utf8s after skipping the first 'start' ones
 fn substring in: (addr array byte), start: int, len: int, out-ah: (addr handle array byte) {
   var in-stream: (stream byte 0x100)
   var in-stream-addr/esi: (addr stream byte) <- address in-stream
@@ -6,29 +6,29 @@ fn substring in: (addr array byte), start: int, len: int, out-ah: (addr handle a
   var out-stream: (stream byte 0x100)
   var out-stream-addr/edi: (addr stream byte) <- address out-stream
   $substring:core: {
-    # skip 'start' graphemes
+    # skip 'start' code-point-utf8s
     var i/eax: int <- copy 0
     {
       compare i, start
       break-if->=
       {
-        var dummy/eax: grapheme <- read-grapheme in-stream-addr
+        var dummy/eax: code-point-utf8 <- read-code-point-utf8 in-stream-addr
         compare dummy, 0xffffffff/end-of-file
         break-if-= $substring:core
       }
       i <- increment
       loop
     }
-    # copy 'len' graphemes
+    # copy 'len' code-point-utf8s
     i <- copy 0
     {
       compare i, len
       break-if->=
       {
-        var g/eax: grapheme <- read-grapheme in-stream-addr
+        var g/eax: code-point-utf8 <- read-code-point-utf8 in-stream-addr
         compare g, 0xffffffff/end-of-file
         break-if-= $substring:core
-        write-grapheme out-stream-addr, g
+        write-code-point-utf8 out-stream-addr, g
       }
       i <- increment
       loop
@@ -85,7 +85,7 @@ fn test-substring {
   check-strings-equal out, "bcde", "F - test-substring/middle-too-small"
 }
 
-fn split-string in: (addr array byte), delim: grapheme, out: (addr handle array (handle array byte)) {
+fn split-string in: (addr array byte), delim: code-point-utf8, out: (addr handle array (handle array byte)) {
   var in-stream: (stream byte 0x100)
   var in-stream-addr/esi: (addr stream byte) <- address in-stream
   write in-stream-addr, in
@@ -94,10 +94,10 @@ fn split-string in: (addr array byte), delim: grapheme, out: (addr handle array
   var curr-stream: (stream byte 0x100)
   var curr-stream-addr/ecx: (addr stream byte) <- address curr-stream
   $split-string:core: {
-    var g/eax: grapheme <- read-grapheme in-stream-addr
+    var g/eax: code-point-utf8 <- read-code-point-utf8 in-stream-addr
     compare g, 0xffffffff
     break-if-=
-#?     print-grapheme-to-real-screen g
+#?     print-code-point-utf8-to-real-screen g
 #?     print-string-to-real-screen "\n"
     compare g, delim
     {
@@ -110,7 +110,7 @@ fn split-string in: (addr array byte), delim: grapheme, out: (addr handle array
       clear-stream curr-stream-addr
       loop $split-string:core
     }
-    write-grapheme curr-stream-addr, g
+    write-code-point-utf8 curr-stream-addr, g
     loop
   }
   stream-to-array tokens-stream-addr, out
diff --git a/linux/apps/arith.mu b/linux/apps/arith.mu
index 4393a34c..08b2008d 100644
--- a/linux/apps/arith.mu
+++ b/linux/apps/arith.mu
@@ -33,7 +33,7 @@
 
 fn main -> _/ebx: int {
   enable-keyboard-immediate-mode
-  var look/esi: grapheme <- copy 0  # lookahead
+  var look/esi: code-point-utf8 <- copy 0  # lookahead
   var n/eax: int <- copy 0  # result of each expression
   print-string 0/screen, "press ctrl-c or ctrl-d to exit\n"
   # read-eval-print loop
@@ -55,17 +55,17 @@ fn main -> _/ebx: int {
   return 0
 }
 
-fn simplify -> _/eax: int, _/esi: grapheme {
+fn simplify -> _/eax: int, _/esi: code-point-utf8 {
   # prime the pump
-  var look/esi: grapheme <- get-char
+  var look/esi: code-point-utf8 <- get-char
   # do it
   var result/eax: int <- copy 0
   result, look <- expression look
   return result, look
 }
 
-fn expression _look: grapheme -> _/eax: int, _/esi: grapheme {
-  var look/esi: grapheme <- copy _look
+fn expression _look: code-point-utf8 -> _/eax: int, _/esi: code-point-utf8 {
+  var look/esi: code-point-utf8 <- copy _look
   # read arg
   var result/eax: int <- copy 0
   result, look <- term look
@@ -78,7 +78,7 @@ fn expression _look: grapheme -> _/eax: int, _/esi: grapheme {
       break-if-= $expression:loop
     }
     # read operator
-    var op/ecx: grapheme <- copy 0
+    var op/ecx: code-point-utf8 <- copy 0
     op, look <- operator look
     # read next arg
     var second/edx: int <- copy 0
@@ -109,8 +109,8 @@ fn expression _look: grapheme -> _/eax: int, _/esi: grapheme {
   return result, look
 }
 
-fn term _look: grapheme -> _/eax: int, _/esi: grapheme {
-  var look/esi: grapheme <- copy _look
+fn term _look: code-point-utf8 -> _/eax: int, _/esi: code-point-utf8 {
+  var look/esi: code-point-utf8 <- copy _look
   # read arg
   look <- skip-spaces look
   var result/eax: int <- copy 0
@@ -124,7 +124,7 @@ fn term _look: grapheme -> _/eax: int, _/esi: grapheme {
       break-if-= $term:loop
     }
     # read operator
-    var op/ecx: grapheme <- copy 0
+    var op/ecx: code-point-utf8 <- copy 0
     op, look <- operator look
     # read next arg
     var second/edx: int <- copy 0
@@ -154,8 +154,8 @@ fn term _look: grapheme -> _/eax: int, _/esi: grapheme {
   return result, look
 }
 
-fn factor _look: grapheme -> _/eax: int, _/esi: grapheme {
-  var look/esi: grapheme <- copy _look  # should be a no-op
+fn factor _look: code-point-utf8 -> _/eax: int, _/esi: code-point-utf8 {
+  var look/esi: code-point-utf8 <- copy _look  # should be a no-op
   look <- skip-spaces look
   # if next char is not '(', parse a number
   compare look, 0x28/open-paren
@@ -174,7 +174,7 @@ fn factor _look: grapheme -> _/eax: int, _/esi: grapheme {
   return result, look
 }
 
-fn mul-or-div? c: grapheme -> _/eax: boolean {
+fn mul-or-div? c: code-point-utf8 -> _/eax: boolean {
   compare c, 0x2a/*
   {
     break-if-!=
@@ -188,7 +188,7 @@ fn mul-or-div? c: grapheme -> _/eax: boolean {
   return 0/false
 }
 
-fn add-or-sub? c: grapheme -> _/eax: boolean {
+fn add-or-sub? c: code-point-utf8 -> _/eax: boolean {
   compare c, 0x2b/+
   {
     break-if-!=
@@ -202,14 +202,14 @@ fn add-or-sub? c: grapheme -> _/eax: boolean {
   return 0/false
 }
 
-fn operator _look: grapheme -> _/ecx: grapheme, _/esi: grapheme {
-  var op/ecx: grapheme <- copy _look
-  var look/esi: grapheme <- get-char
+fn operator _look: code-point-utf8 -> _/ecx: code-point-utf8, _/esi: code-point-utf8 {
+  var op/ecx: code-point-utf8 <- copy _look
+  var look/esi: code-point-utf8 <- get-char
   return op, look
 }
 
-fn num _look: grapheme -> _/eax: int, _/esi: grapheme {
-  var look/esi: grapheme <- copy _look
+fn num _look: code-point-utf8 -> _/eax: int, _/esi: code-point-utf8 {
+  var look/esi: code-point-utf8 <- copy _look
   var result/edi: int <- copy 0
   {
     var first-digit/eax: int <- to-decimal-digit look
@@ -234,8 +234,8 @@ fn num _look: grapheme -> _/eax: int, _/esi: grapheme {
   return result, look
 }
 
-fn skip-spaces _look: grapheme -> _/esi: grapheme {
-  var look/esi: grapheme <- copy _look  # should be a no-op
+fn skip-spaces _look: code-point-utf8 -> _/esi: code-point-utf8 {
+  var look/esi: code-point-utf8 <- copy _look  # should be a no-op
   {
     compare look, 0x20
     break-if-!=
@@ -245,9 +245,9 @@ fn skip-spaces _look: grapheme -> _/esi: grapheme {
   return look
 }
 
-fn get-char -> _/esi: grapheme {
-  var look/eax: grapheme <- read-key-from-real-keyboard
-  print-grapheme-to-real-screen look
+fn get-char -> _/esi: code-point-utf8 {
+  var look/eax: code-point-utf8 <- read-key-from-real-keyboard
+  print-code-point-utf8-to-real-screen look
   compare look, 4
   {
     break-if-!=
diff --git a/linux/apps/parse-int.mu b/linux/apps/parse-int.mu
index 0f8c71d1..ccff8d44 100644
--- a/linux/apps/parse-int.mu
+++ b/linux/apps/parse-int.mu
@@ -37,7 +37,7 @@ fn parse-int _in: (addr array byte) -> _/eax: int {
     var tmp/ebx: (addr byte) <- index in, i
     var c/eax: byte <- copy-byte *tmp
     #
-    var g/eax: grapheme <- copy c
+    var g/eax: code-point-utf8 <- copy c
     var digit/eax: int <- to-decimal-digit g
     result <- add digit
     i <- increment
diff --git a/linux/apps/print-file.mu b/linux/apps/print-file.mu
index 75ce2e39..284b805e 100644
--- a/linux/apps/print-file.mu
+++ b/linux/apps/print-file.mu
@@ -30,8 +30,8 @@ fn main _args: (addr array addr array byte) -> _/ebx: int {
       var c/eax: byte <- read-byte-buffered in-addr
       compare c, 0xffffffff/end-of-file
       break-if-=
-      var g/eax: grapheme <- copy c
-      print-grapheme 0/screen, g
+      var g/eax: code-point-utf8 <- copy c
+      print-code-point-utf8 0/screen, g
       loop
     }
   }
diff --git a/linux/apps/tui.mu b/linux/apps/tui.mu
index 4e58b986..f4fc914c 100644
--- a/linux/apps/tui.mu
+++ b/linux/apps/tui.mu
@@ -23,7 +23,7 @@ fn main -> _/ebx: int {
 
   print-string 0/screen, "press a key to see its code: "
   enable-keyboard-immediate-mode
-  var x/eax: grapheme <- read-key-from-real-keyboard
+  var x/eax: code-point-utf8 <- read-key-from-real-keyboard
   enable-keyboard-type-mode
   enable-screen-type-mode
   print-string 0/screen, "You pressed "
diff --git a/linux/browse/main.mu b/linux/browse/main.mu
index 5b4f2e06..27504afe 100644
--- a/linux/browse/main.mu
+++ b/linux/browse/main.mu
@@ -49,7 +49,7 @@ fn interactive fs: (addr buffered-file) {
   #
   {
     render paginated-screen, fs
-    var key/eax: grapheme <- read-key-from-real-keyboard
+    var key/eax: code-point-utf8 <- read-key-from-real-keyboard
     compare key, 0x71/'q'
     loop-if-!=
   }
@@ -160,13 +160,13 @@ fn test-render-asterisk-in-text {
 fn render-normal screen: (addr paginated-screen), fs: (addr buffered-file) {
   var newline-seen?/esi: boolean <- copy 0/false
   var start-of-paragraph?/edi: boolean <- copy 1/true
-  var previous-grapheme/ebx: grapheme <- copy 0
+  var previous-code-point-utf8/ebx: code-point-utf8 <- copy 0
 $render-normal:loop: {
     # if done-drawing?(screen) break
     var done?/eax: boolean <- done-drawing? screen
     compare done?, 0/false
     break-if-!=
-    var c/eax: grapheme <- read-grapheme-buffered fs
+    var c/eax: code-point-utf8 <- read-code-point-utf8-buffered fs
 $render-normal:loop-body: {
       # if (c == EOF) break
       compare c, 0xffffffff/end-of-file
@@ -186,8 +186,8 @@ $render-normal:loop-body: {
         # otherwise render two newlines
         {
           break-if-=
-          add-grapheme screen, 0xa/newline
-          add-grapheme screen, 0xa/newline
+          add-code-point-utf8 screen, 0xa/newline
+          add-code-point-utf8 screen, 0xa/newline
           newline-seen? <- copy 0/false
           start-of-paragraph? <- copy 1/true
           break $render-normal:loop-body
@@ -221,20 +221,20 @@ $render-normal:flush-buffered-newline: {
         {
           compare c, 0x20
           break-if-!=
-          add-grapheme screen, 0xa/newline
+          add-code-point-utf8 screen, 0xa/newline
           break $render-normal:flush-buffered-newline
         }
-        add-grapheme screen, 0x20/space
+        add-code-point-utf8 screen, 0x20/space
         # fall through to print c
       }
       ## end soft newline support
 
 $render-normal:whitespace-separated-regions: {
-        # if previous-grapheme wasn't whitespace, skip this block
+        # if previous-code-point-utf8 wasn't whitespace, skip this block
         {
-          compare previous-grapheme, 0x20/space
+          compare previous-code-point-utf8, 0x20/space
           break-if-=
-          compare previous-grapheme, 0xa/newline
+          compare previous-code-point-utf8, 0xa/newline
           break-if-=
           break $render-normal:whitespace-separated-regions
         }
@@ -260,9 +260,9 @@ $render-normal:whitespace-separated-regions: {
         }
       }
       #
-      add-grapheme screen, c
+      add-code-point-utf8 screen, c
     }  # $render-normal:loop-body
-    previous-grapheme <- copy c
+    previous-code-point-utf8 <- copy c
     loop
   }  # $render-normal:loop
 }
@@ -271,7 +271,7 @@ fn render-header-line screen: (addr paginated-screen), fs: (addr buffered-file)
 $render-header-line:body: {
   # compute color based on number of '#'s
   var header-level/esi: int <- copy 1  # caller already grabbed one
-  var c/eax: grapheme <- copy 0
+  var c/eax: code-point-utf8 <- copy 0
   {
     # if done-drawing?(screen) return
     {
@@ -280,7 +280,7 @@ $render-header-line:body: {
       break-if-!= $render-header-line:body
     }
     #
-    c <- read-grapheme-buffered fs
+    c <- read-code-point-utf8-buffered fs
     # if (c != '#') break
     compare c, 0x23/'#'
     break-if-!=
@@ -298,7 +298,7 @@ $render-header-line:body: {
       break-if-!=
     }
     #
-    c <- read-grapheme-buffered fs
+    c <- read-code-point-utf8-buffered fs
     # if (c == EOF) break
     compare c, 0xffffffff/end-of-file
     break-if-=
@@ -306,7 +306,7 @@ $render-header-line:body: {
     compare c, 0xa/newline
     break-if-=
     #
-    add-grapheme screen, c
+    add-code-point-utf8 screen, c
     #
     loop
   }
@@ -353,7 +353,7 @@ fn render-until-asterisk screen: (addr paginated-screen), fs: (addr buffered-fil
     compare done?, 0/false
     break-if-!=
     #
-    var c/eax: grapheme <- read-grapheme-buffered fs
+    var c/eax: code-point-utf8 <- read-code-point-utf8-buffered fs
     # if (c == EOF) break
     compare c, 0xffffffff/end-of-file
     break-if-=
@@ -361,7 +361,7 @@ fn render-until-asterisk screen: (addr paginated-screen), fs: (addr buffered-fil
     compare c, 0x2a/'*'
     break-if-=
     #
-    add-grapheme screen, c
+    add-code-point-utf8 screen, c
     #
     loop
   }
@@ -374,7 +374,7 @@ fn render-until-underscore screen: (addr paginated-screen), fs: (addr buffered-f
     compare done?, 0/false
     break-if-!=
     #
-    var c/eax: grapheme <- read-grapheme-buffered fs
+    var c/eax: code-point-utf8 <- read-code-point-utf8-buffered fs
     # if (c == EOF) break
     compare c, 0xffffffff/end-of-file
     break-if-=
@@ -382,7 +382,7 @@ fn render-until-underscore screen: (addr paginated-screen), fs: (addr buffered-f
     compare c, 0x5f/'_'
     break-if-=
     #
-    add-grapheme screen, c
+    add-code-point-utf8 screen, c
     #
     loop
   }
diff --git a/linux/browse/paginated-screen.mu b/linux/browse/paginated-screen.mu
index f4579d95..05f954a7 100644
--- a/linux/browse/paginated-screen.mu
+++ b/linux/browse/paginated-screen.mu
@@ -7,7 +7,7 @@
 #   on each frame
 #     start-drawing
 #     while !done-drawing
-#       add-grapheme ...
+#       add-code-point-utf8 ...
 
 type paginated-screen {
   screen: (handle screen)
@@ -152,23 +152,23 @@ fn done-drawing? _self: (addr paginated-screen) -> _/eax: boolean {
   return 1/true
 }
 
-fn add-grapheme _self: (addr paginated-screen), c: grapheme {
-#?   print-string-to-real-screen "add-grapheme: "
-#?   print-grapheme-to-real-screen c
+fn add-code-point-utf8 _self: (addr paginated-screen), c: code-point-utf8 {
+#?   print-string-to-real-screen "add-code-point-utf8: "
+#?   print-code-point-utf8-to-real-screen c
 #?   print-string-to-real-screen "\n"
-$add-grapheme:body: {
+$add-code-point-utf8:body: {
   var self/esi: (addr paginated-screen) <- copy _self
   {
     compare c, 0xa/newline
     break-if-!=
     next-line self
     reposition-cursor self
-    break $add-grapheme:body
+    break $add-code-point-utf8:body
   }
   # print c
   var screen-ah/eax: (addr handle screen) <- get self, screen
   var screen-addr/eax: (addr screen) <- lookup *screen-ah
-  print-grapheme screen-addr, c
+  print-code-point-utf8 screen-addr, c
   # self->col++
   var tmp/eax: (addr int) <- get self, col
   increment *tmp
@@ -186,21 +186,21 @@ $add-grapheme:body: {
 
 ## tests
 
-fn test-print-grapheme-on-paginated-screen {
+fn test-print-code-point-utf8-on-paginated-screen {
   var pg-on-stack: paginated-screen
   var pg/eax: (addr paginated-screen) <- address pg-on-stack
   initialize-fake-paginated-screen pg, 3/rows, 0xa/cols, 0xa/page-width, 0, 0
   start-drawing pg
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-grapheme-on-paginated-screen/done"
+    check-ints-equal done, 0, "F - test-print-code-point-utf8-on-paginated-screen/done"
   }
   var screen-ah/eax: (addr handle screen) <- get pg, screen
   var screen-addr/eax: (addr screen) <- lookup *screen-ah
-  check-screen-row screen-addr, 1, "a", "F - test-print-grapheme-on-paginated-screen"
+  check-screen-row screen-addr, 1, "a", "F - test-print-code-point-utf8-on-paginated-screen"
 }
 
 fn test-print-single-page {
@@ -210,29 +210,29 @@ fn test-print-single-page {
   start-drawing pg
   # pages at columns [1, 3), [3, 5)
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page/done-1"
   }
   {
-    var c/ecx: grapheme <- copy 0x62/b
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x62/b
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page/done-2"
   }
   {
-    var c/ecx: grapheme <- copy 0x63/c
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x63/c
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page/done-3"
   }
   {
-    var c/ecx: grapheme <- copy 0x64/d
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x64/d
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page/done-4"
@@ -250,36 +250,36 @@ fn test-print-single-page-narrower-than-page-width {
   initialize-fake-paginated-screen pg, 2/rows, 4/cols, 5/page-width, 0, 0
   start-drawing pg
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width/done-1"
   }
   {
-    var c/ecx: grapheme <- copy 0x62/b
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x62/b
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width/done-2"
   }
   {
-    var c/ecx: grapheme <- copy 0x63/c
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x63/c
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width/done-3"
   }
   {
-    var c/ecx: grapheme <- copy 0x64/d
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x64/d
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width/done-4"
   }
   {
-    var c/ecx: grapheme <- copy 0x65/e
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x65/e
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width/done-5"
@@ -297,36 +297,36 @@ fn test-print-single-page-narrower-than-page-width-with-margin {
   initialize-fake-paginated-screen pg, 2/rows, 4/cols, 5/page-width, 0/top-margin, 1/left-margin
   start-drawing pg
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width-with-margin/done-1"
   }
   {
-    var c/ecx: grapheme <- copy 0x62/b
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x62/b
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width-with-margin/done-2"
   }
   {
-    var c/ecx: grapheme <- copy 0x63/c
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x63/c
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width-with-margin/done-3"
   }
   {
-    var c/ecx: grapheme <- copy 0x64/d
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x64/d
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width-with-margin/done-4"
   }
   {
-    var c/ecx: grapheme <- copy 0x65/e
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x65/e
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-single-page-narrower-than-page-width-with-margin/done-5"
@@ -344,29 +344,29 @@ fn test-print-multiple-pages {
   initialize-fake-paginated-screen pg, 2/rows, 2/cols, 1/page-width, 0, 0
   start-drawing pg
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages/done-1"
   }
   {
-    var c/ecx: grapheme <- copy 0x62/b
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x62/b
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages/done-2"
   }
   {
-    var c/ecx: grapheme <- copy 0x63/c
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x63/c
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages/done-3"
   }
   {
-    var c/ecx: grapheme <- copy 0x64/d
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x64/d
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 1, "F - test-print-multiple-pages/done-4"
@@ -384,57 +384,57 @@ fn test-print-multiple-pages-2 {
   initialize-fake-paginated-screen pg, 2/rows, 4/cols, 2/page-width, 0, 0
   start-drawing pg
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-1"
   }
   {
-    var c/ecx: grapheme <- copy 0x62/b
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x62/b
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-2"
   }
   {
-    var c/ecx: grapheme <- copy 0x63/c
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x63/c
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-3"
   }
   {
-    var c/ecx: grapheme <- copy 0x64/d
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x64/d
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-4"
   }
   {
-    var c/ecx: grapheme <- copy 0x65/e
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x65/e
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-5"
   }
   {
-    var c/ecx: grapheme <- copy 0x66/f
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x66/f
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-6"
   }
   {
-    var c/ecx: grapheme <- copy 0x67/g
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x67/g
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 0, "F - test-print-multiple-pages-2/done-7"
   }
   {
-    var c/ecx: grapheme <- copy 0x68/h
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x68/h
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
     check-ints-equal done, 1, "F - test-print-multiple-pages-2/done-8"
@@ -452,60 +452,60 @@ fn test-print-multiple-pages-with-margins {
   initialize-fake-paginated-screen pg, 3/rows, 6/cols, 2/page-width, 1/top-margin, 1/left-margin
   start-drawing pg
   {
-    var c/ecx: grapheme <- copy 0x61/a
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x61/a
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-1"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-1"
   }
   {
-    var c/ecx: grapheme <- copy 0x62/b
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x62/b
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-2"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-2"
   }
   {
-    var c/ecx: grapheme <- copy 0x63/c
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x63/c
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-3"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-3"
   }
   {
-    var c/ecx: grapheme <- copy 0x64/d
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x64/d
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-4"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-4"
   }
   {
-    var c/ecx: grapheme <- copy 0x65/e
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x65/e
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-5"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-5"
   }
   {
-    var c/ecx: grapheme <- copy 0x66/f
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x66/f
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-6"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-6"
   }
   {
-    var c/ecx: grapheme <- copy 0x67/g
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x67/g
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/grapheme-7"
+    check-ints-equal done, 0, "F - test-print-multiple-pages-with-margins/code-point-utf8-7"
   }
   {
-    var c/ecx: grapheme <- copy 0x68/h
-    add-grapheme pg, c
+    var c/ecx: code-point-utf8 <- copy 0x68/h
+    add-code-point-utf8 pg, c
     var done?/eax: boolean <- done-drawing? pg
     var done/eax: int <- copy done?
-    check-ints-equal done, 1, "F - test-print-multiple-pages-with-margins/grapheme-8"
+    check-ints-equal done, 1, "F - test-print-multiple-pages-with-margins/code-point-utf8-8"
   }
   var screen-ah/eax: (addr handle screen) <- get pg, screen
   var screen-addr/eax: (addr screen) <- lookup *screen-ah
diff --git a/linux/mu b/linux/mu
index fdeacea0..94cb0a6e 100755
--- a/linux/mu
+++ b/linux/mu
Binary files differdiff --git a/linux/mu.subx b/linux/mu.subx
index 879b751e..b4c55006 100644
--- a/linux/mu.subx
+++ b/linux/mu.subx
@@ -416,8 +416,8 @@ Type-id:  # (stream (addr array byte))
   "stream"/imm32  # 11
   "slice"/imm32  # 12
   "code-point"/imm32  # 13; smallest scannable unit from a text stream
-  "grapheme"/imm32  # 14; smallest printable unit; will eventually be composed of multiple code-points, but currently corresponds 1:1
-                    # only 4-byte graphemes in utf-8 are currently supported;
+  "code-point-utf8"/imm32  # 14; smallest printable unit; will eventually be composed of multiple code-points, but currently corresponds 1:1
+                    # only 4-byte code-point-utf8s in utf-8 are currently supported;
                     # unclear how we should deal with larger clusters.
   "float"/imm32     # 15
   # 0x40
@@ -22183,9 +22183,9 @@ $mu-numberlike-output?:check-code-point:
     (simple-mu-type? %esi 0xd)  # code-point => eax
     3d/compare-eax-and 0/imm32/false
     75/jump-if-!= $mu-numberlike-output?:return-true/disp8
-$mu-numberlike-output?:check-grapheme:
-    # if t is a grapheme, return
-    (simple-mu-type? %esi 0xe)  # grapheme => eax
+$mu-numberlike-output?:check-code-point-utf8:
+    # if t is a code-point-utf8, return
+    (simple-mu-type? %esi 0xe)  # code-point-utf8 => eax
     3d/compare-eax-and 0/imm32/false
     75/jump-if-!= $mu-numberlike-output?:return-true/disp8
 $mu-numberlike-output?:return-false:
diff --git a/linux/tile/box.mu b/linux/tile/box.mu
index 859d0b8e..f5155ea8 100644
--- a/linux/tile/box.mu
+++ b/linux/tile/box.mu
@@ -78,7 +78,7 @@ fn clear-rect screen: (addr screen), row1: int, col1: int, row2: int, col2: int
     {
       compare j, col2
       break-if->
-      print-grapheme screen 0x20/space
+      print-code-point-utf8 screen 0x20/space
       j <- increment
       loop
     }
@@ -98,7 +98,7 @@ fn clear-rect2 screen: (addr screen), row1: int, col1: int, w: int, h: int {
     {
       compare j, h
       break-if->=
-      print-grapheme screen 0x20/space
+      print-code-point-utf8 screen 0x20/space
       j <- increment
       loop
     }
diff --git a/linux/tile/environment.mu b/linux/tile/environment.mu
index 3c869d3c..1512db6d 100644
--- a/linux/tile/environment.mu
+++ b/linux/tile/environment.mu
@@ -70,7 +70,7 @@ fn initialize-environment-with-fake-screen _self: (addr environment), nrows: int
 # Iterate
 #############
 
-fn process _self: (addr environment), key: grapheme {
+fn process _self: (addr environment), key: code-point-utf8 {
   var self/esi: (addr environment) <- copy _self
   var fn-name-ah/eax: (addr handle word) <- get self, partial-function-name
   var fn-name/eax: (addr word) <- lookup *fn-name-ah
@@ -102,7 +102,7 @@ fn process _self: (addr environment), key: grapheme {
 }
 
 # collect new name in partial-function-name, and move the cursor to function with that name
-fn process-goto-dialog _self: (addr environment), key: grapheme {
+fn process-goto-dialog _self: (addr environment), key: code-point-utf8 {
   var self/esi: (addr environment) <- copy _self
   var fn-name-ah/edi: (addr handle word) <- get self, partial-function-name
   # if 'esc' pressed, cancel goto
@@ -130,7 +130,7 @@ fn process-goto-dialog _self: (addr environment), key: grapheme {
   compare key, 0x7f/del  # backspace on Macs
   $process-goto-dialog:backspace: {
     break-if-!=
-    # if not at start, delete grapheme before cursor
+    # if not at start, delete code-point-utf8 before cursor
     var fn-name/eax: (addr word) <- lookup *fn-name-ah
     var at-start?/eax: boolean <- cursor-at-start? fn-name
     compare at-start?, 0/false
@@ -142,24 +142,24 @@ fn process-goto-dialog _self: (addr environment), key: grapheme {
     return
   }
   # otherwise insert key within current word
-  var print?/eax: boolean <- real-grapheme? key
-  $process-goto-dialog:real-grapheme: {
+  var print?/eax: boolean <- real-code-point-utf8? key
+  $process-goto-dialog:real-code-point-utf8: {
     compare print?, 0/false
     break-if-=
     var fn-name/eax: (addr word) <- lookup *fn-name-ah
-    add-grapheme-to-word fn-name, key
+    add-code-point-utf8-to-word fn-name, key
     return
   }
   # silently ignore other hotkeys
 }
 
-fn process-function _self: (addr environment), _function: (addr function), key: grapheme {
+fn process-function _self: (addr environment), _function: (addr function), key: code-point-utf8 {
   var self/esi: (addr environment) <- copy _self
   var function/edi: (addr function) <- copy _function
   process-function-edit self, function, key
 }
 
-fn process-function-edit _self: (addr environment), _function: (addr function), key: grapheme {
+fn process-function-edit _self: (addr environment), _function: (addr function), key: code-point-utf8 {
   var self/esi: (addr environment) <- copy _self
   var function/edi: (addr function) <- copy _function
   var cursor-word-ah/ebx: (addr handle word) <- get function, cursor-word
@@ -290,7 +290,7 @@ fn process-function-edit _self: (addr environment), _function: (addr function),
   compare key, 0x7f/del  # backspace on Macs
   $process-function-edit:backspace: {
     break-if-!=
-    # if not at start of some word, delete grapheme before cursor within current word
+    # if not at start of some word, delete code-point-utf8 before cursor within current word
     var at-start?/eax: boolean <- cursor-at-start? cursor-word
     compare at-start?, 0/false
     {
@@ -325,25 +325,25 @@ fn process-function-edit _self: (addr environment), _function: (addr function),
       copy-object new-prev-word-ah, cursor-word-ah
       return
     }
-    # if start of word is quote and grapheme before cursor is not, just insert it as usual
+    # if start of word is quote and code-point-utf8 before cursor is not, just insert it as usual
     # TODO: support string escaping
     {
-      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
-      compare first-grapheme, 0x22/double-quote
+      var first-code-point-utf8/eax: code-point-utf8 <- first-code-point-utf8 cursor-word
+      compare first-code-point-utf8, 0x22/double-quote
       break-if-!=
-      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
-      compare final-grapheme, 0x22/double-quote
+      var final-code-point-utf8/eax: code-point-utf8 <- code-point-utf8-before-cursor cursor-word
+      compare final-code-point-utf8, 0x22/double-quote
       break-if-=
       break $process-function-edit:space
     }
-    # if start of word is '[' and grapheme before cursor is not ']', just insert it as usual
+    # if start of word is '[' and code-point-utf8 before cursor is not ']', just insert it as usual
     # TODO: support nested arrays
     {
-      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
-      compare first-grapheme, 0x5b/[
+      var first-code-point-utf8/eax: code-point-utf8 <- first-code-point-utf8 cursor-word
+      compare first-code-point-utf8, 0x5b/[
       break-if-!=
-      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
-      compare final-grapheme, 0x5d/]
+      var final-code-point-utf8/eax: code-point-utf8 <- code-point-utf8-before-cursor cursor-word
+      compare final-code-point-utf8, 0x5d/]
       break-if-=
       break $process-function-edit:space
     }
@@ -368,26 +368,26 @@ fn process-function-edit _self: (addr environment), _function: (addr function),
       var at-end?/eax: boolean <- cursor-at-end? cursor-word
       compare at-end?, 0/false
       break-if-!=
-      var g/eax: grapheme <- pop-after-cursor cursor-word
-      add-grapheme-to-word next-word, g
+      var g/eax: code-point-utf8 <- pop-after-cursor cursor-word
+      add-code-point-utf8-to-word next-word, g
       loop
     }
     cursor-to-start next-word
     return
   }
   # otherwise insert key within current word
-  var g/edx: grapheme <- copy key
-  var print?/eax: boolean <- real-grapheme? key
-  $process-function-edit:real-grapheme: {
+  var g/edx: code-point-utf8 <- copy key
+  var print?/eax: boolean <- real-code-point-utf8? key
+  $process-function-edit:real-code-point-utf8: {
     compare print?, 0/false
     break-if-=
-    add-grapheme-to-word cursor-word, g
+    add-code-point-utf8-to-word cursor-word, g
     return
   }
   # silently ignore other hotkeys
 }
 
-fn process-sandbox _self: (addr environment), _sandbox: (addr sandbox), key: grapheme {
+fn process-sandbox _self: (addr environment), _sandbox: (addr sandbox), key: code-point-utf8 {
   var self/esi: (addr environment) <- copy _self
   var sandbox/edi: (addr sandbox) <- copy _sandbox
   var rename-word-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-cursor-word
@@ -413,7 +413,7 @@ fn process-sandbox _self: (addr environment), _sandbox: (addr sandbox), key: gra
   process-sandbox-edit self, sandbox, key
 }
 
-fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key: grapheme {
+fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key: code-point-utf8 {
   var self/esi: (addr environment) <- copy _self
   var sandbox/edi: (addr sandbox) <- copy _sandbox
   var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
@@ -730,7 +730,7 @@ fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key
   compare key, 0x7f/del  # backspace on Macs
   $process-sandbox-edit:backspace: {
     break-if-!=
-    # if not at start of some word, delete grapheme before cursor within current word
+    # if not at start of some word, delete code-point-utf8 before cursor within current word
     var at-start?/eax: boolean <- cursor-at-start? cursor-word
     compare at-start?, 0/false
     {
@@ -766,25 +766,25 @@ fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key
       decrement-final-element cursor-call-path
       return
     }
-    # if start of word is quote and grapheme before cursor is not, just insert it as usual
+    # if start of word is quote and code-point-utf8 before cursor is not, just insert it as usual
     # TODO: support string escaping
     {
-      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
-      compare first-grapheme, 0x22/double-quote
+      var first-code-point-utf8/eax: code-point-utf8 <- first-code-point-utf8 cursor-word
+      compare first-code-point-utf8, 0x22/double-quote
       break-if-!=
-      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
-      compare final-grapheme, 0x22/double-quote
+      var final-code-point-utf8/eax: code-point-utf8 <- code-point-utf8-before-cursor cursor-word
+      compare final-code-point-utf8, 0x22/double-quote
       break-if-=
       break $process-sandbox-edit:space
     }
-    # if start of word is '[' and grapheme before cursor is not ']', just insert it as usual
+    # if start of word is '[' and code-point-utf8 before cursor is not ']', just insert it as usual
     # TODO: support nested arrays
     {
-      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
-      compare first-grapheme, 0x5b/[
+      var first-code-point-utf8/eax: code-point-utf8 <- first-code-point-utf8 cursor-word
+      compare first-code-point-utf8, 0x5b/[
       break-if-!=
-      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
-      compare final-grapheme, 0x5d/]
+      var final-code-point-utf8/eax: code-point-utf8 <- code-point-utf8-before-cursor cursor-word
+      compare final-code-point-utf8, 0x5d/]
       break-if-=
       break $process-sandbox-edit:space
     }
@@ -809,8 +809,8 @@ fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key
       var at-end?/eax: boolean <- cursor-at-end? cursor-word
       compare at-end?, 0/false
       break-if-!=
-      var g/eax: grapheme <- pop-after-cursor cursor-word
-      add-grapheme-to-word next-word, g
+      var g/eax: code-point-utf8 <- pop-after-cursor cursor-word
+      add-code-point-utf8-to-word next-word, g
       loop
     }
     cursor-to-start next-word
@@ -838,12 +838,12 @@ fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key
     return
   }
   # otherwise insert key within current word
-  var g/edx: grapheme <- copy key
-  var print?/eax: boolean <- real-grapheme? key
-  $process-sandbox-edit:real-grapheme: {
+  var g/edx: code-point-utf8 <- copy key
+  var print?/eax: boolean <- real-code-point-utf8? key
+  $process-sandbox-edit:real-code-point-utf8: {
     compare print?, 0/false
     break-if-=
-    add-grapheme-to-word cursor-word, g
+    add-code-point-utf8-to-word cursor-word, g
     return
   }
   # silently ignore other hotkeys
@@ -852,7 +852,7 @@ fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key
 # collect new name in partial-name-for-cursor-word, and then rename the word
 # at cursor to it
 # Precondition: cursor-call-path is a singleton (not within a call)
-fn process-sandbox-rename _sandbox: (addr sandbox), key: grapheme {
+fn process-sandbox-rename _sandbox: (addr sandbox), key: code-point-utf8 {
   var sandbox/esi: (addr sandbox) <- copy _sandbox
   var new-name-ah/edi: (addr handle word) <- get sandbox, partial-name-for-cursor-word
   # if 'esc' pressed, cancel rename
@@ -911,7 +911,7 @@ fn process-sandbox-rename _sandbox: (addr sandbox), key: grapheme {
     {
       var new-name/eax: (addr word) <- lookup *new-name-ah
       cursor-to-start new-name
-      add-grapheme-to-word new-name, 0x3d/=
+      add-code-point-utf8-to-word new-name, 0x3d/=
     }
     # append name to new line
     chain-words new-line-word-ah, new-name-ah
@@ -941,7 +941,7 @@ fn process-sandbox-rename _sandbox: (addr sandbox), key: grapheme {
   compare key, 0x7f/del  # backspace on Macs
   $process-sandbox-rename:backspace: {
     break-if-!=
-    # if not at start, delete grapheme before cursor
+    # if not at start, delete code-point-utf8 before cursor
     var new-name/eax: (addr word) <- lookup *new-name-ah
     var at-start?/eax: boolean <- cursor-at-start? new-name
     compare at-start?, 0/false
@@ -953,12 +953,12 @@ fn process-sandbox-rename _sandbox: (addr sandbox), key: grapheme {
     return
   }
   # otherwise insert key within current word
-  var print?/eax: boolean <- real-grapheme? key
-  $process-sandbox-rename:real-grapheme: {
+  var print?/eax: boolean <- real-code-point-utf8? key
+  $process-sandbox-rename:real-code-point-utf8: {
     compare print?, 0/false
     break-if-=
     var new-name/eax: (addr word) <- lookup *new-name-ah
-    add-grapheme-to-word new-name, key
+    add-code-point-utf8-to-word new-name, key
     return
   }
   # silently ignore other hotkeys
@@ -968,7 +968,7 @@ fn process-sandbox-rename _sandbox: (addr sandbox), key: grapheme {
 # of the sandbox to be a new function with that name. Replace the last line
 # with a call to the appropriate function.
 # Precondition: cursor-call-path is a singleton (not within a call)
-fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle function), key: grapheme {
+fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle function), key: code-point-utf8 {
   var sandbox/esi: (addr sandbox) <- copy _sandbox
   var new-name-ah/edi: (addr handle word) <- get sandbox, partial-name-for-function
   # if 'esc' pressed, cancel define
@@ -1033,7 +1033,7 @@ fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle func
   compare key, 0x7f/del  # backspace on Macs
   $process-sandbox-define:backspace: {
     break-if-!=
-    # if not at start, delete grapheme before cursor
+    # if not at start, delete code-point-utf8 before cursor
     var new-name/eax: (addr word) <- lookup *new-name-ah
     var at-start?/eax: boolean <- cursor-at-start? new-name
     compare at-start?, 0/false
@@ -1045,12 +1045,12 @@ fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle func
     return
   }
   # otherwise insert key within current word
-  var print?/eax: boolean <- real-grapheme? key
-  $process-sandbox-define:real-grapheme: {
+  var print?/eax: boolean <- real-code-point-utf8? key
+  $process-sandbox-define:real-code-point-utf8: {
     compare print?, 0/false
     break-if-=
     var new-name/eax: (addr word) <- lookup *new-name-ah
-    add-grapheme-to-word new-name, key
+    add-code-point-utf8-to-word new-name, key
     return
   }
   # silently ignore other hotkeys
@@ -2107,7 +2107,7 @@ fn render-function-right-aligned screen: (addr screen), row: int, right-col: int
   start-color screen, 0, 0xf7
   clear-rect screen, row, col, new-row, col2
   col <- add 1
-#?   var dummy/eax: grapheme <- read-key-from-real-keyboard
+#?   var dummy/eax: code-point-utf8 <- read-key-from-real-keyboard
   render-function screen, row, col, f
   new-row <- add 1/function-bottom-margin
   col <- subtract 1/function-left-padding
@@ -2144,7 +2144,7 @@ fn render-function screen: (addr screen), row: int, col: int, _f: (addr function
   render-line-without-stack screen, body, row, col, cursor-word, cursor-row, cursor-col
 }
 
-fn real-grapheme? g: grapheme -> _/eax: boolean {
+fn real-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
   # if g == newline return true
   compare g, 0xa
   {
diff --git a/linux/tile/gap-buffer.mu b/linux/tile/gap-buffer.mu
index 0132daf0..1441684b 100644
--- a/linux/tile/gap-buffer.mu
+++ b/linux/tile/gap-buffer.mu
@@ -1,14 +1,14 @@
 type gap-buffer {
-  left: grapheme-stack
-  right: grapheme-stack
+  left: code-point-utf8-stack
+  right: code-point-utf8-stack
 }
 
 fn initialize-gap-buffer _self: (addr gap-buffer) {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  initialize-grapheme-stack left, 0x10/max-word-size
-  var right/eax: (addr grapheme-stack) <- get self, right
-  initialize-grapheme-stack right, 0x10/max-word-size
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  initialize-code-point-utf8-stack left, 0x10/max-word-size
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  initialize-code-point-utf8-stack right, 0x10/max-word-size
 }
 
 # just for tests
@@ -21,8 +21,8 @@ fn initialize-gap-buffer-with self: (addr gap-buffer), s: (addr array byte) {
     var done?/eax: boolean <- stream-empty? stream
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme stream
-    add-grapheme-at-gap self, g
+    var g/eax: code-point-utf8 <- read-code-point-utf8 stream
+    add-code-point-utf8-at-gap self, g
     loop
   }
 }
@@ -37,44 +37,44 @@ fn gap-buffer-to-string self: (addr gap-buffer), out: (addr handle array byte) {
 fn emit-gap-buffer _self: (addr gap-buffer), out: (addr stream byte) {
   var self/esi: (addr gap-buffer) <- copy _self
   clear-stream out
-  var left/eax: (addr grapheme-stack) <- get self, left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
   emit-stack-from-bottom left, out
-  var right/eax: (addr grapheme-stack) <- get self, right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
   emit-stack-from-top right, out
 }
 
 # dump stack from bottom to top
-fn emit-stack-from-bottom _self: (addr grapheme-stack), out: (addr stream byte) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn emit-stack-from-bottom _self: (addr code-point-utf8-stack), out: (addr stream byte) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    write-grapheme out, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    write-code-point-utf8 out, *g
     i <- increment
     loop
   }
 }
 
 # dump stack from top to bottom
-fn emit-stack-from-top _self: (addr grapheme-stack), out: (addr stream byte) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn emit-stack-from-top _self: (addr code-point-utf8-stack), out: (addr stream byte) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy *top-addr
   i <- decrement
   {
     compare i, 0
     break-if-<
-    var g/edx: (addr grapheme) <- index data, i
-    write-grapheme out, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    write-code-point-utf8 out, *g
     i <- decrement
     loop
   }
@@ -82,33 +82,33 @@ fn emit-stack-from-top _self: (addr grapheme-stack), out: (addr stream byte) {
 
 fn render-gap-buffer screen: (addr screen), _gap: (addr gap-buffer) {
   var gap/esi: (addr gap-buffer) <- copy _gap
-  var left/eax: (addr grapheme-stack) <- get gap, left
+  var left/eax: (addr code-point-utf8-stack) <- get gap, left
   render-stack-from-bottom left, screen
-  var right/eax: (addr grapheme-stack) <- get gap, right
+  var right/eax: (addr code-point-utf8-stack) <- get gap, right
   render-stack-from-top right, screen
 }
 
 fn gap-buffer-length _gap: (addr gap-buffer) -> _/eax: int {
   var gap/esi: (addr gap-buffer) <- copy _gap
-  var left/eax: (addr grapheme-stack) <- get gap, left
+  var left/eax: (addr code-point-utf8-stack) <- get gap, left
   var tmp/eax: (addr int) <- get left, top
   var left-length/ecx: int <- copy *tmp
-  var right/esi: (addr grapheme-stack) <- get gap, right
+  var right/esi: (addr code-point-utf8-stack) <- get gap, right
   tmp <- get right, top
   var result/eax: int <- copy *tmp
   result <- add left-length
   return result
 }
 
-fn add-grapheme-at-gap _self: (addr gap-buffer), g: grapheme {
+fn add-code-point-utf8-at-gap _self: (addr gap-buffer), g: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  push-grapheme-stack left, g
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  push-code-point-utf8-stack left, g
 }
 
 fn gap-to-start self: (addr gap-buffer) {
   {
-    var curr/eax: grapheme <- gap-left self
+    var curr/eax: code-point-utf8 <- gap-left self
     compare curr, -1
     loop-if-!=
   }
@@ -116,7 +116,7 @@ fn gap-to-start self: (addr gap-buffer) {
 
 fn gap-to-end self: (addr gap-buffer) {
   {
-    var curr/eax: grapheme <- gap-right self
+    var curr/eax: code-point-utf8 <- gap-right self
     compare curr, -1
     loop-if-!=
   }
@@ -124,96 +124,96 @@ fn gap-to-end self: (addr gap-buffer) {
 
 fn gap-at-start? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var result/eax: boolean <- grapheme-stack-empty? left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var result/eax: boolean <- code-point-utf8-stack-empty? left
   return result
 }
 
 fn gap-at-end? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  var right/eax: (addr grapheme-stack) <- get self, right
-  var result/eax: boolean <- grapheme-stack-empty? right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  var result/eax: boolean <- code-point-utf8-stack-empty? right
   return result
 }
 
-fn gap-right _self: (addr gap-buffer) -> _/eax: grapheme {
+fn gap-right _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
-  var g/eax: grapheme <- copy 0
-  var right/ecx: (addr grapheme-stack) <- get self, right
-  g <- pop-grapheme-stack right
+  var g/eax: code-point-utf8 <- copy 0
+  var right/ecx: (addr code-point-utf8-stack) <- get self, right
+  g <- pop-code-point-utf8-stack right
   compare g, -1
   {
     break-if-=
-    var left/ecx: (addr grapheme-stack) <- get self, left
-    push-grapheme-stack left, g
+    var left/ecx: (addr code-point-utf8-stack) <- get self, left
+    push-code-point-utf8-stack left, g
   }
   return g
 }
 
-fn gap-left _self: (addr gap-buffer) -> _/eax: grapheme {
+fn gap-left _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
-  var g/eax: grapheme <- copy 0
+  var g/eax: code-point-utf8 <- copy 0
   {
-    var left/ecx: (addr grapheme-stack) <- get self, left
-    g <- pop-grapheme-stack left
+    var left/ecx: (addr code-point-utf8-stack) <- get self, left
+    g <- pop-code-point-utf8-stack left
   }
   compare g, -1
   {
     break-if-=
-    var right/ecx: (addr grapheme-stack) <- get self, right
-    push-grapheme-stack right, g
+    var right/ecx: (addr code-point-utf8-stack) <- get self, right
+    push-code-point-utf8-stack right, g
   }
   return g
 }
 
 fn gap-index _self: (addr gap-buffer) -> _/eax: int {
   var self/eax: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
   var top-addr/eax: (addr int) <- get left, top
   var result/eax: int <- copy *top-addr
   return result
 }
 
-fn first-grapheme-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
+fn first-code-point-utf8-in-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   # try to read from left
-  var left/eax: (addr grapheme-stack) <- get self, left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
   var top-addr/ecx: (addr int) <- get left, top
   compare *top-addr, 0
   {
     break-if-<=
-    var data-ah/eax: (addr handle array grapheme) <- get left, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
-    var result-addr/eax: (addr grapheme) <- index data, 0
+    var data-ah/eax: (addr handle array code-point-utf8) <- get left, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
+    var result-addr/eax: (addr code-point-utf8) <- index data, 0
     return *result-addr
   }
   # try to read from right
-  var right/eax: (addr grapheme-stack) <- get self, right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
   top-addr <- get right, top
   compare *top-addr, 0
   {
     break-if-<=
-    var data-ah/eax: (addr handle array grapheme) <- get right, data
-    var data/eax: (addr array grapheme) <- lookup *data-ah
+    var data-ah/eax: (addr handle array code-point-utf8) <- get right, data
+    var data/eax: (addr array code-point-utf8) <- lookup *data-ah
     var top/ecx: int <- copy *top-addr
     top <- decrement
-    var result-addr/eax: (addr grapheme) <- index data, top
+    var result-addr/eax: (addr code-point-utf8) <- index data, top
     return *result-addr
   }
   # give up
   return -1
 }
 
-fn grapheme-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
+fn code-point-utf8-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/esi: (addr gap-buffer) <- copy _self
   # try to read from left
-  var left/ecx: (addr grapheme-stack) <- get self, left
+  var left/ecx: (addr code-point-utf8-stack) <- get self, left
   var top-addr/edx: (addr int) <- get left, top
   compare *top-addr, 0
   {
     break-if-<=
-    var result/eax: grapheme <- pop-grapheme-stack left
-    push-grapheme-stack left, result
+    var result/eax: code-point-utf8 <- pop-code-point-utf8-stack left
+    push-code-point-utf8-stack left, result
     return result
   }
   # give up
@@ -222,27 +222,27 @@ fn grapheme-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: graph
 
 fn delete-before-gap _self: (addr gap-buffer) {
   var self/eax: (addr gap-buffer) <- copy _self
-  var left/eax: (addr grapheme-stack) <- get self, left
-  var dummy/eax: grapheme <- pop-grapheme-stack left
+  var left/eax: (addr code-point-utf8-stack) <- get self, left
+  var dummy/eax: code-point-utf8 <- pop-code-point-utf8-stack left
 }
 
-fn pop-after-gap _self: (addr gap-buffer) -> _/eax: grapheme {
+fn pop-after-gap _self: (addr gap-buffer) -> _/eax: code-point-utf8 {
   var self/eax: (addr gap-buffer) <- copy _self
-  var right/eax: (addr grapheme-stack) <- get self, right
-  var result/eax: grapheme <- pop-grapheme-stack right
+  var right/eax: (addr code-point-utf8-stack) <- get self, right
+  var result/eax: code-point-utf8 <- pop-code-point-utf8-stack right
   return result
 }
 
 fn gap-buffer-equal? _self: (addr gap-buffer), s: (addr array byte) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  # complication: graphemes may be multiple bytes
+  # complication: code-point-utf8s may be multiple bytes
   # so don't rely on length
   # instead turn the expected result into a stream and arrange to read from it in order
   var stream-storage: (stream byte 0x10/max-word-size)
   var expected-stream/ecx: (addr stream byte) <- address stream-storage
   write expected-stream, s
   # compare left
-  var left/edx: (addr grapheme-stack) <- get self, left
+  var left/edx: (addr code-point-utf8-stack) <- get self, left
   var result/eax: boolean <- prefix-match? left, expected-stream
   compare result, 0/false
   {
@@ -250,7 +250,7 @@ fn gap-buffer-equal? _self: (addr gap-buffer), s: (addr array byte) -> _/eax: bo
     return result
   }
   # compare right
-  var right/edx: (addr grapheme-stack) <- get self, right
+  var right/edx: (addr code-point-utf8-stack) <- get self, right
   result <- suffix-match? right, expected-stream
   compare result, 0/false
   {
@@ -267,10 +267,10 @@ fn test-gap-buffer-equal-from-end? {
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer g
   #
-  var c/eax: grapheme <- copy 0x61/a
-  add-grapheme-at-gap g, c
-  add-grapheme-at-gap g, c
-  add-grapheme-at-gap g, c
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  add-code-point-utf8-at-gap g, c
+  add-code-point-utf8-at-gap g, c
+  add-code-point-utf8-at-gap g, c
   # gap is at end (right is empty)
   var _result/eax: boolean <- gap-buffer-equal? g, "aaa"
   var result/eax: int <- copy _result
@@ -282,11 +282,11 @@ fn test-gap-buffer-equal-from-middle? {
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer g
   #
-  var c/eax: grapheme <- copy 0x61/a
-  add-grapheme-at-gap g, c
-  add-grapheme-at-gap g, c
-  add-grapheme-at-gap g, c
-  var dummy/eax: grapheme <- gap-left g
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  add-code-point-utf8-at-gap g, c
+  add-code-point-utf8-at-gap g, c
+  add-code-point-utf8-at-gap g, c
+  var dummy/eax: code-point-utf8 <- gap-left g
   # gap is in the middle
   var _result/eax: boolean <- gap-buffer-equal? g, "aaa"
   var result/eax: int <- copy _result
@@ -298,11 +298,11 @@ fn test-gap-buffer-equal-from-start? {
   var g/esi: (addr gap-buffer) <- address _g
   initialize-gap-buffer g
   #
-  var c/eax: grapheme <- copy 0x61/a
-  add-grapheme-at-gap g, c
-  add-grapheme-at-gap g, c
-  add-grapheme-at-gap g, c
-  var dummy/eax: grapheme <- gap-left g
+  var c/eax: code-point-utf8 <- copy 0x61/a
+  add-code-point-utf8-at-gap g, c
+  add-code-point-utf8-at-gap g, c
+  add-code-point-utf8-at-gap g, c
+  var dummy/eax: code-point-utf8 <- gap-left g
   dummy <- gap-left g
   dummy <- gap-left g
   # gap is at the start
@@ -319,25 +319,25 @@ fn copy-gap-buffer _src-ah: (addr handle gap-buffer), _dest-ah: (addr handle gap
   var dest-ah/eax: (addr handle gap-buffer) <- copy _dest-ah
   var _dest-a/eax: (addr gap-buffer) <- lookup *dest-ah
   var dest-a/edi: (addr gap-buffer) <- copy _dest-a
-  # copy left grapheme-stack
-  var src/ecx: (addr grapheme-stack) <- get src-a, left
-  var dest/edx: (addr grapheme-stack) <- get dest-a, left
-  copy-grapheme-stack src, dest
-  # copy right grapheme-stack
+  # copy left code-point-utf8-stack
+  var src/ecx: (addr code-point-utf8-stack) <- get src-a, left
+  var dest/edx: (addr code-point-utf8-stack) <- get dest-a, left
+  copy-code-point-utf8-stack src, dest
+  # copy right code-point-utf8-stack
   src <- get src-a, right
   dest <- get dest-a, right
-  copy-grapheme-stack src, dest
+  copy-code-point-utf8-stack src, dest
 }
 
 fn gap-buffer-is-decimal-integer? _self: (addr gap-buffer) -> _/eax: boolean {
   var self/esi: (addr gap-buffer) <- copy _self
-  var curr/ecx: (addr grapheme-stack) <- get self, left
-  var result/eax: boolean <- grapheme-stack-is-decimal-integer? curr
+  var curr/ecx: (addr code-point-utf8-stack) <- get self, left
+  var result/eax: boolean <- code-point-utf8-stack-is-decimal-integer? curr
   {
     compare result, 0/false
     break-if-=
     curr <- get self, right
-    result <- grapheme-stack-is-decimal-integer? curr
+    result <- code-point-utf8-stack-is-decimal-integer? curr
   }
   return result
 }
diff --git a/linux/tile/grapheme-stack.mu b/linux/tile/grapheme-stack.mu
index 0ea59ae5..c7565a1c 100644
--- a/linux/tile/grapheme-stack.mu
+++ b/linux/tile/grapheme-stack.mu
@@ -1,24 +1,24 @@
-type grapheme-stack {
-  data: (handle array grapheme)
+type code-point-utf8-stack {
+  data: (handle array code-point-utf8)
   top: int
 }
 
-fn initialize-grapheme-stack _self: (addr grapheme-stack), n: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var d/edi: (addr handle array grapheme) <- get self, data
+fn initialize-code-point-utf8-stack _self: (addr code-point-utf8-stack), n: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var d/edi: (addr handle array code-point-utf8) <- get self, data
   populate d, n
   var top/eax: (addr int) <- get self, top
   copy-to *top, 0
 }
 
-fn clear-grapheme-stack _self: (addr grapheme-stack) {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn clear-code-point-utf8-stack _self: (addr code-point-utf8-stack) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   copy-to *top, 0
 }
 
-fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn code-point-utf8-stack-empty? _self: (addr code-point-utf8-stack) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   compare *top, 0
   {
@@ -28,20 +28,20 @@ fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
   return 0/false
 }
 
-fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn push-code-point-utf8-stack _self: (addr code-point-utf8-stack), _val: code-point-utf8 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
-  var data-ah/edx: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/edx: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
-  var dest-addr/edx: (addr grapheme) <- index data, top
-  var val/eax: grapheme <- copy _val
+  var dest-addr/edx: (addr code-point-utf8) <- index data, top
+  var val/eax: code-point-utf8 <- copy _val
   copy-to *dest-addr, val
   add-to *top-addr, 1
 }
 
-fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn pop-code-point-utf8-stack _self: (addr code-point-utf8-stack) -> _/eax: code-point-utf8 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
   {
     compare *top-addr, 0
@@ -49,25 +49,25 @@ fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
     return -1
   }
   subtract-from *top-addr, 1
-  var data-ah/edx: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/edx: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
-  var result-addr/eax: (addr grapheme) <- index data, top
+  var result-addr/eax: (addr code-point-utf8) <- index data, top
   return *result-addr
 }
 
-fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) {
-  var src/esi: (addr grapheme-stack) <- copy _src
-  var data-ah/edi: (addr handle array grapheme) <- get src, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn copy-code-point-utf8-stack _src: (addr code-point-utf8-stack), dest: (addr code-point-utf8-stack) {
+  var src/esi: (addr code-point-utf8-stack) <- copy _src
+  var data-ah/edi: (addr handle array code-point-utf8) <- get src, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get src, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    push-grapheme-stack dest, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    push-code-point-utf8-stack dest, *g
     i <- increment
     loop
   }
@@ -75,18 +75,18 @@ fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack)
 
 # dump stack to screen from bottom to top
 # don't move the cursor or anything
-fn render-stack-from-bottom _self: (addr grapheme-stack), screen: (addr screen) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn render-stack-from-bottom _self: (addr code-point-utf8-stack), screen: (addr screen) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    print-grapheme screen, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    print-code-point-utf8 screen, *g
     i <- increment
     loop
   }
@@ -94,19 +94,19 @@ fn render-stack-from-bottom _self: (addr grapheme-stack), screen: (addr screen)
 
 # dump stack to screen from top to bottom
 # don't move the cursor or anything
-fn render-stack-from-top _self: (addr grapheme-stack), screen: (addr screen) {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn render-stack-from-top _self: (addr code-point-utf8-stack), screen: (addr screen) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/eax: int <- copy *top-addr
   i <- decrement
   {
     compare i, 0
     break-if-<
-    var g/edx: (addr grapheme) <- index data, i
-    print-grapheme screen, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    print-code-point-utf8 screen, *g
     i <- decrement
     loop
   }
@@ -114,11 +114,11 @@ fn render-stack-from-top _self: (addr grapheme-stack), screen: (addr screen) {
 
 # compare from bottom
 # beware: modifies 'stream', which must be disposed of after a false result
-fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn prefix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy 0
   {
@@ -126,8 +126,8 @@ fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
     break-if->=
     # if curr != expected, return false
     {
-      var curr-a/edx: (addr grapheme) <- index data, i
-      var expected/eax: grapheme <- read-grapheme s
+      var curr-a/edx: (addr code-point-utf8) <- index data, i
+      var expected/eax: code-point-utf8 <- read-code-point-utf8 s
       {
         compare expected, *curr-a
         break-if-=
@@ -142,11 +142,11 @@ fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
 
 # compare from bottom
 # beware: modifies 'stream', which must be disposed of after a false result
-fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn suffix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/eax: (addr int) <- get self, top
   var i/ebx: int <- copy *top-addr
   i <- decrement
@@ -154,8 +154,8 @@ fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
     compare i, 0
     break-if-<
     {
-      var curr-a/edx: (addr grapheme) <- index data, i
-      var expected/eax: grapheme <- read-grapheme s
+      var curr-a/edx: (addr code-point-utf8) <- index data, i
+      var expected/eax: code-point-utf8 <- read-code-point-utf8 s
       # if curr != expected, return false
       {
         compare expected, *curr-a
@@ -169,18 +169,18 @@ fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
   return 1   # true
 }
 
-fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edx: (addr array grapheme) <- copy _data
+fn code-point-utf8-stack-is-decimal-integer? _self: (addr code-point-utf8-stack) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edx: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy 0
   var result/eax: boolean <- copy 1/true
-  $grapheme-stack-is-integer?:loop: {
+  $code-point-utf8-stack-is-integer?:loop: {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
+    var g/edx: (addr code-point-utf8) <- index data, i
     result <- decimal-digit? *g
     compare result, 0/false
     break-if-=
diff --git a/linux/tile/main.mu b/linux/tile/main.mu
index e0daaf1b..f2561a28 100644
--- a/linux/tile/main.mu
+++ b/linux/tile/main.mu
@@ -54,7 +54,7 @@ fn interactive {
   initialize-environment env
   {
     render env
-    var key/eax: grapheme <- read-key-from-real-keyboard
+    var key/eax: code-point-utf8 <- read-key-from-real-keyboard
     compare key, 0x11/ctrl-q
     break-if-=
     process env, key
@@ -79,7 +79,7 @@ fn process-all env: (addr environment), cmds: (addr array byte) {
     var done?/eax: boolean <- stream-empty? cmds-stream-a
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme cmds-stream-a
+    var g/eax: code-point-utf8 <- read-code-point-utf8 cmds-stream-a
     process env, g
     loop
   }
@@ -105,7 +105,7 @@ fn repl {
       var done?/eax: boolean <- stream-empty? line
       compare done?, 0/false
       break-if-!=
-      var g/eax: grapheme <- read-grapheme line
+      var g/eax: code-point-utf8 <- read-code-point-utf8 line
       process env, g
       loop
     }
diff --git a/linux/tile/surface.mu b/linux/tile/surface.mu
index 2e353022..e86e22b9 100644
--- a/linux/tile/surface.mu
+++ b/linux/tile/surface.mu
@@ -111,10 +111,10 @@ fn print-surface-cell-at _self: (addr surface), screen-row: int, screen-col: int
   compare idx, 0
   {
     break-if->=
-    var space/ecx: grapheme <- copy 0x20
+    var space/ecx: code-point-utf8 <- copy 0x20
     var screen-ah/edi: (addr handle screen) <- get self, screen
     var screen/eax: (addr screen) <- lookup *screen-ah
-    print-grapheme screen, space
+    print-code-point-utf8 screen, space
     return
   }
   # otherwise print the appropriate screen-cell
@@ -156,9 +156,9 @@ fn print-screen-cell screen: (addr screen), _cell: (addr screen-cell) {
     break-if-=
     start-blinking screen
   }
-  var g/eax: (addr grapheme) <- get cell, data
-  print-grapheme screen, *g
-#?   var g2/eax: grapheme <- copy *g
+  var g/eax: (addr code-point-utf8) <- get cell, data
+  print-code-point-utf8 screen, *g
+#?   var g2/eax: code-point-utf8 <- copy *g
 #?   var g3/eax: int <- copy g2
 #?   print-int32-hex-to-real-screen g3
 #?   print-string-to-real-screen "\n"
@@ -264,7 +264,7 @@ fn num-lines in: (addr array byte) -> _/ecx: int {
     var done?/eax: boolean <- stream-empty? s-addr
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s-addr
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s-addr
     compare g, 0xa/newline
     loop-if-!=
     result <- increment
@@ -282,7 +282,7 @@ fn first-line-length in: (addr array byte) -> _/edx: int {
     var done?/eax: boolean <- stream-empty? s-addr
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s-addr
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s-addr
     compare g, 0xa/newline
     break-if-=
     result <- increment
@@ -301,12 +301,12 @@ fn fill-in _out: (addr array screen-cell), in: (addr array byte) {
     var done?/eax: boolean <- stream-empty? s-addr
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme s-addr
+    var g/eax: code-point-utf8 <- read-code-point-utf8 s-addr
     compare g, 0xa/newline
     loop-if-=
     var offset/edx: (offset screen-cell) <- compute-offset out, idx
     var dest/edx: (addr screen-cell) <- index out, offset
-    var dest2/edx: (addr grapheme) <- get dest, data
+    var dest2/edx: (addr code-point-utf8) <- get dest, data
     copy-to *dest2, g
     idx <- increment
     loop
diff --git a/linux/tile/value.mu b/linux/tile/value.mu
index 8bd01676..0eacd8be 100644
--- a/linux/tile/value.mu
+++ b/linux/tile/value.mu
@@ -90,15 +90,15 @@ fn render-number screen: (addr screen), val: float, top-level?: boolean {
     fg <- copy 0
   }
   start-color screen, fg, bg
-  print-grapheme screen, 0x20/space
+  print-code-point-utf8 screen, 0x20/space
   print-float-decimal-approximate screen, val, 3
-  print-grapheme screen, 0x20/space
+  print-code-point-utf8 screen, 0x20/space
 }
 
 fn render-array-at screen: (addr screen), row: int, col: int, _a: (addr array value) {
   start-color screen, 0xf2, 7
   # don't surround in spaces
-  print-grapheme screen, 0x5b/[
+  print-code-point-utf8 screen, 0x5b/[
   increment col
   var a/esi: (addr array value) <- copy _a
   var max/ecx: int <- length a
@@ -122,7 +122,7 @@ fn render-array-at screen: (addr screen), row: int, col: int, _a: (addr array va
     i <- increment
     loop
   }
-  print-grapheme screen, 0x5d/]
+  print-code-point-utf8 screen, 0x5d/]
 }
 
 fn render-screen screen: (addr screen), row: int, col: int, _target-screen: (addr screen) {
@@ -179,13 +179,13 @@ fn print-screen-cell-of-fake-screen screen: (addr screen), _target: (addr screen
     start-blinking screen
     start-color screen, 0, 1
   }
-  var g/eax: grapheme <- screen-grapheme-at target, row, col
+  var g/eax: code-point-utf8 <- screen-code-point-utf8-at target, row, col
   {
     compare g, 0
     break-if-!=
     g <- copy 0x20/space
   }
-  print-grapheme screen, g
+  print-code-point-utf8 screen, g
   reset-formatting screen
 }
 
diff --git a/linux/tile/word.mu b/linux/tile/word.mu
index b4f5000b..3b4851f0 100644
--- a/linux/tile/word.mu
+++ b/linux/tile/word.mu
@@ -58,15 +58,15 @@ fn move-word-contents _src-ah: (addr handle word), _dest-ah: (addr handle word)
   cursor-to-start src
   var src-data-ah/eax: (addr handle gap-buffer) <- get src, scalar-data
   var src-data/eax: (addr gap-buffer) <- lookup *src-data-ah
-  var src-stack/ecx: (addr grapheme-stack) <- get src-data, right
+  var src-stack/ecx: (addr code-point-utf8-stack) <- get src-data, right
   {
-    var done?/eax: boolean <- grapheme-stack-empty? src-stack
+    var done?/eax: boolean <- code-point-utf8-stack-empty? src-stack
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- pop-grapheme-stack src-stack
-#?     print-grapheme 0, g
+    var g/eax: code-point-utf8 <- pop-code-point-utf8-stack src-stack
+#?     print-code-point-utf8 0, g
 #?     print-string 0, "\n"
-    add-grapheme-to-word dest, g
+    add-code-point-utf8-to-word dest, g
     loop
   }
 }
@@ -79,17 +79,17 @@ fn copy-word-contents-before-cursor _src-ah: (addr handle word), _dest-ah: (addr
   var src/eax: (addr word) <- lookup *src-ah
   var src-data-ah/eax: (addr handle gap-buffer) <- get src, scalar-data
   var src-data/eax: (addr gap-buffer) <- lookup *src-data-ah
-  var src-stack/ecx: (addr grapheme-stack) <- get src-data, left
-  var src-stack-data-ah/eax: (addr handle array grapheme) <- get src-stack, data
-  var _src-stack-data/eax: (addr array grapheme) <- lookup *src-stack-data-ah
-  var src-stack-data/edx: (addr array grapheme) <- copy _src-stack-data
+  var src-stack/ecx: (addr code-point-utf8-stack) <- get src-data, left
+  var src-stack-data-ah/eax: (addr handle array code-point-utf8) <- get src-stack, data
+  var _src-stack-data/eax: (addr array code-point-utf8) <- lookup *src-stack-data-ah
+  var src-stack-data/edx: (addr array code-point-utf8) <- copy _src-stack-data
   var top-addr/ecx: (addr int) <- get src-stack, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index src-stack-data, i
-    add-grapheme-to-word dest, *g
+    var g/edx: (addr code-point-utf8) <- index src-stack-data, i
+    add-code-point-utf8-to-word dest, *g
     i <- increment
     loop
   }
@@ -129,27 +129,27 @@ fn final-word _in: (addr handle word), out: (addr handle word) {
   copy-object curr-ah, out  # modify 'out' right at the end, just in case it's same as 'in'
 }
 
-fn first-grapheme _self: (addr word) -> _/eax: grapheme {
+fn first-code-point-utf8 _self: (addr word) -> _/eax: code-point-utf8 {
   var self/esi: (addr word) <- copy _self
   var data-ah/eax: (addr handle gap-buffer) <- get self, scalar-data
   var data/eax: (addr gap-buffer) <- lookup *data-ah
-  var result/eax: grapheme <- first-grapheme-in-gap-buffer data
+  var result/eax: code-point-utf8 <- first-code-point-utf8-in-gap-buffer data
   return result
 }
 
-fn grapheme-before-cursor _self: (addr word) -> _/eax: grapheme {
+fn code-point-utf8-before-cursor _self: (addr word) -> _/eax: code-point-utf8 {
   var self/esi: (addr word) <- copy _self
   var data-ah/eax: (addr handle gap-buffer) <- get self, scalar-data
   var data/eax: (addr gap-buffer) <- lookup *data-ah
-  var result/eax: grapheme <- grapheme-before-cursor-in-gap-buffer data
+  var result/eax: code-point-utf8 <- code-point-utf8-before-cursor-in-gap-buffer data
   return result
 }
 
-fn add-grapheme-to-word _self: (addr word), c: grapheme {
+fn add-code-point-utf8-to-word _self: (addr word), c: code-point-utf8 {
   var self/esi: (addr word) <- copy _self
   var data-ah/eax: (addr handle gap-buffer) <- get self, scalar-data
   var data/eax: (addr gap-buffer) <- lookup *data-ah
-  add-grapheme-at-gap data, c
+  add-code-point-utf8-at-gap data, c
 }
 
 fn cursor-at-start? _self: (addr word) -> _/eax: boolean {
@@ -172,14 +172,14 @@ fn cursor-left _self: (addr word) {
   var self/esi: (addr word) <- copy _self
   var data-ah/eax: (addr handle gap-buffer) <- get self, scalar-data
   var data/eax: (addr gap-buffer) <- lookup *data-ah
-  var dummy/eax: grapheme <- gap-left data
+  var dummy/eax: code-point-utf8 <- gap-left data
 }
 
 fn cursor-right _self: (addr word) {
   var self/esi: (addr word) <- copy _self
   var data-ah/eax: (addr handle gap-buffer) <- get self, scalar-data
   var data/eax: (addr gap-buffer) <- lookup *data-ah
-  var dummy/eax: grapheme <- gap-right data
+  var dummy/eax: code-point-utf8 <- gap-right data
 }
 
 fn cursor-to-start _self: (addr word) {
@@ -211,11 +211,11 @@ fn delete-before-cursor _self: (addr word) {
   delete-before-gap data
 }
 
-fn pop-after-cursor _self: (addr word) -> _/eax: grapheme {
+fn pop-after-cursor _self: (addr word) -> _/eax: code-point-utf8 {
   var self/esi: (addr word) <- copy _self
   var data-ah/eax: (addr handle gap-buffer) <- get self, scalar-data
   var data/eax: (addr gap-buffer) <- lookup *data-ah
-  var result/eax: grapheme <- pop-after-gap data
+  var result/eax: code-point-utf8 <- pop-after-gap data
   return result
 }
 
@@ -553,14 +553,14 @@ fn parse-words in: (addr array byte), out-ah: (addr handle word) {
     var done?/eax: boolean <- stream-empty? in-stream-a
     compare done?, 0/false
     break-if-!=
-    var _g/eax: grapheme <- read-grapheme in-stream-a
-    var g/ecx: grapheme <- copy _g
+    var _g/eax: code-point-utf8 <- read-code-point-utf8 in-stream-a
+    var g/ecx: code-point-utf8 <- copy _g
     # if not space, insert
     compare g, 0x20/space
     {
       break-if-=
       var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
-      add-grapheme-to-word cursor-word, g
+      add-code-point-utf8-to-word cursor-word, g
       loop $parse-words:loop
     }
     # otherwise insert word after and move cursor to it
diff --git a/linux/vocabulary.md b/linux/vocabulary.md
index f1c6e3a5..2eefae33 100644
--- a/linux/vocabulary.md
+++ b/linux/vocabulary.md
@@ -206,8 +206,8 @@ doesn't yet parse floating-point literals:
 - `print-int32-buffered`: int -> buffered-file
   - textual representation in hex, including '0x' prefix
 
-- `write-grapheme`: grapheme -> stream
-- `to-grapheme`: code-point -> grapheme
+- `write-code-point-utf8`: code-point-utf8 -> stream
+- `to-utf8`: code-point -> code-point-utf8
 
 - `write-float-decimal-approximate`: float, precision: int -> stream
 
@@ -226,8 +226,8 @@ there isn't enough room in the destination stream.
 - `read-line-buffered`: buffered-file -> stream
   - Will abort the entire program if there isn't enough room.
 
-- `read-grapheme`: stream -> grapheme
-- `read-grapheme-buffered`: buffered-file -> grapheme
+- `read-code-point-utf8`: stream -> code-point-utf8
+- `read-code-point-utf8-buffered`: buffered-file -> code-point-utf8
 
 - `read-lines`: buffered-file -> array of strings
 
@@ -268,7 +268,7 @@ Unix terminal properties supported by almost all modern terminal emulators.
 
 - `print-string`: string -> screen
 - `print-stream`
-- `print-grapheme`
+- `print-code-point-utf8`
 - `print-code-point`
 - `print-int32-hex`
 - `print-int32-decimal`
@@ -290,7 +290,7 @@ manipulated.
 
 Assertions for tests:
 
-- `screen-grapheme-at`
+- `screen-code-point-utf8-at`
 - `screen-color-at`
 - `screen-background-color-at`
 - `screen-bold-at?`
diff --git a/mu.md b/mu.md
index cfecadf0..428a28d0 100644
--- a/mu.md
+++ b/mu.md
@@ -80,7 +80,7 @@ You can store several types in these registers:
   - (addr T) (address into memory)
   - byte (uses only 8 bits)
   - code-point (Unicode)
-  - grapheme (code-point encoded in UTF-8)
+  - code-point-utf8 (code-point encoded in UTF-8)
 
 There's one 32-bit type you _cannot_ store in these registers:
   - float
@@ -579,9 +579,9 @@ are a few functions to help with them:
   # bytes
   append-byte s: (addr stream byte), var: int  # write lower byte of var
   var/eax: byte <- read-byte s: (addr stream byte)
-  # 32-bit graphemes encoded in UTF-8
-  write-grapheme out: (addr stream byte), g: grapheme
-  g/eax: grapheme <- read-grapheme in: (addr stream byte)
+  # 32-bit code-point-utf8s encoded in UTF-8
+  write-code-point-utf8 out: (addr stream byte), g: code-point-utf8
+  g/eax: code-point-utf8 <- read-code-point-utf8 in: (addr stream byte)
 ```
 
 You can check if a stream is empty or full:
diff --git a/shell/README.md b/shell/README.md
index 3a9cdf3c..180782eb 100644
--- a/shell/README.md
+++ b/shell/README.md
@@ -150,7 +150,7 @@ def (a <> b)
 ```
 
 To permit arbitrary infix operators, the Mu shell partitions the space of
-graphemes between operators and regular symbols. As a result, you can't define
+code-point-utf8s between operators and regular symbols. As a result, you can't define
 symbols mixing the two.
 ```
 '*global*
diff --git a/shell/environment.mu b/shell/environment.mu
index c3d78d86..439d5423 100644
--- a/shell/environment.mu
+++ b/shell/environment.mu
@@ -2,7 +2,7 @@
 #
 # vim:textwidth&
 # It would be nice for tests to use a narrower screen than the standard 0x80 of
-# 1024 pixels with 8px-wide graphemes. But it complicates rendering logic to
+# 1024 pixels with 8px-wide code-point-utf8s. But it complicates rendering logic to
 # make width configurable, so we just use longer lines than usual.
 
 type environment {
@@ -93,7 +93,7 @@ fn type-in self: (addr environment), screen: (addr screen), keys: (addr array by
     var done?/eax: boolean <- stream-empty? input-stream
     compare done?, 0/false
     break-if-!=
-    var key/eax: grapheme <- read-grapheme input-stream
+    var key/eax: code-point-utf8 <- read-code-point-utf8 input-stream
     edit-environment self, key, 0/no-disk
     render-environment screen, self
     loop
@@ -145,7 +145,7 @@ fn render-environment screen: (addr screen), _self: (addr environment) {
   render-sandbox-menu screen, sandbox
 }
 
-fn edit-environment _self: (addr environment), key: grapheme, data-disk: (addr disk) {
+fn edit-environment _self: (addr environment), key: code-point-utf8, data-disk: (addr disk) {
   var self/esi: (addr environment) <- copy _self
   var globals/edi: (addr global-table) <- get self, globals
   var sandbox/ecx: (addr sandbox) <- get self, sandbox
diff --git a/shell/global.mu b/shell/global.mu
index f6a779f9..329556c1 100644
--- a/shell/global.mu
+++ b/shell/global.mu
@@ -230,7 +230,7 @@ fn render-globals-menu screen: (addr screen), _self: (addr global-table) {
   draw-text-rightward-from-cursor screen, " >>  ", width, 7/fg, 0xc5/bg=blue-bg
 }
 
-fn edit-globals _self: (addr global-table), key: grapheme {
+fn edit-globals _self: (addr global-table), key: code-point-utf8 {
   var self/esi: (addr global-table) <- copy _self
   # ctrl-s
   {
diff --git a/shell/infix.mu b/shell/infix.mu
index 41e8fa5d..2ca1b875 100644
--- a/shell/infix.mu
+++ b/shell/infix.mu
@@ -312,8 +312,8 @@ fn tokenize-infix _sym-ah: (addr handle cell), trace: (addr trace) {
   var buffer/edi: (addr gap-buffer) <- address buffer-storage
   initialize-gap-buffer buffer, 0x40/max-symbol-size
   # scan for first non-$
-  var g/eax: grapheme <- read-grapheme sym-data
-  add-grapheme-at-gap buffer, g
+  var g/eax: code-point-utf8 <- read-code-point-utf8 sym-data
+  add-code-point-utf8-at-gap buffer, g
   {
     compare g, 0x24/dollar
     break-if-!=
@@ -323,28 +323,28 @@ fn tokenize-infix _sym-ah: (addr handle cell), trace: (addr trace) {
       break-if-=
       return  # symbol is all '$'s; do nothing
     }
-    g <- read-grapheme sym-data
-    add-grapheme-at-gap buffer, g
+    g <- read-code-point-utf8 sym-data
+    add-code-point-utf8-at-gap buffer, g
     loop
   }
   var tokenization-needed?: boolean
-  var _operator-so-far?/eax: boolean <- operator-grapheme? g
+  var _operator-so-far?/eax: boolean <- operator-code-point-utf8? g
   var operator-so-far?/ecx: boolean <- copy _operator-so-far?
   {
     var done?/eax: boolean <- stream-empty? sym-data
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme sym-data
+    var g/eax: code-point-utf8 <- read-code-point-utf8 sym-data
     {
-      var curr-operator?/eax: boolean <- operator-grapheme? g
+      var curr-operator?/eax: boolean <- operator-code-point-utf8? g
       compare curr-operator?, operator-so-far?
       break-if-=
       # state change; insert a space
-      add-grapheme-at-gap buffer, 0x20/space
+      add-code-point-utf8-at-gap buffer, 0x20/space
       operator-so-far? <- copy curr-operator?
       copy-to tokenization-needed?, 1/true
     }
-    add-grapheme-at-gap buffer, g
+    add-code-point-utf8-at-gap buffer, g
     loop
   }
   compare tokenization-needed?, 0/false
@@ -406,7 +406,7 @@ fn test-infix {
 
 # helpers
 
-# return true if x is composed entirely of operator graphemes, optionally prefixed with some '$'s
+# return true if x is composed entirely of operator code-point-utf8s, optionally prefixed with some '$'s
 # some operator, some non-operator => pre-tokenized symbol; return false
 # all '$'s => return false
 fn operator-symbol? _x: (addr cell) -> _/eax: boolean {
@@ -421,7 +421,7 @@ fn operator-symbol? _x: (addr cell) -> _/eax: boolean {
   var _x-data/eax: (addr stream byte) <- lookup *x-data-ah
   var x-data/esi: (addr stream byte) <- copy _x-data
   rewind-stream x-data
-  var g/eax: grapheme <- read-grapheme x-data
+  var g/eax: code-point-utf8 <- read-code-point-utf8 x-data
   # special case: '$' is reserved for gensyms, and can work with either
   # operator or non-operator symbols.
   {
@@ -434,12 +434,12 @@ fn operator-symbol? _x: (addr cell) -> _/eax: boolean {
       # '$', '$$', '$$$', etc. are regular symbols
       return 0/false
     }
-    g <- read-grapheme x-data
+    g <- read-code-point-utf8 x-data
     loop
   }
   {
     {
-      var result/eax: boolean <- operator-grapheme? g
+      var result/eax: boolean <- operator-code-point-utf8? g
       compare result, 0/false
       break-if-!=
       return 0/false
@@ -449,13 +449,13 @@ fn operator-symbol? _x: (addr cell) -> _/eax: boolean {
       compare done?, 0/false
     }
     break-if-!=
-    g <- read-grapheme x-data
+    g <- read-code-point-utf8 x-data
     loop
   }
   return 1/true
 }
 
-fn operator-grapheme? g: grapheme -> _/eax: boolean {
+fn operator-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
   # '$' is special and can be in either a symbol or operator; here we treat it as a symbol
   compare g, 0x25/percent
   {
diff --git a/shell/main.mu b/shell/main.mu
index 1f0e2de9..a588324a 100644
--- a/shell/main.mu
+++ b/shell/main.mu
@@ -13,7 +13,7 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
       var key/eax: byte <- read-key keyboard
       compare key, 0
       loop-if-=
-      var key/eax: grapheme <- copy key
+      var key/eax: code-point-utf8 <- copy key
       edit-environment env, key, data-disk
     }
     loop
diff --git a/shell/primitives.mu b/shell/primitives.mu
index e955b531..a87009d3 100644
--- a/shell/primitives.mu
+++ b/shell/primitives.mu
@@ -172,7 +172,7 @@ fn render-primitives screen: (addr screen), xmin: int, xmax: int, ymax: int {
   y <- increment
   var tmpx/eax: int <- copy xmin
   tmpx <- draw-text-rightward screen, "  key", tmpx, left-max, y, 0x2a/fg=orange, 0xdc/bg=green-bg
-  tmpx <- draw-text-rightward screen, ": keyboard -> grapheme?", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
+  tmpx <- draw-text-rightward screen, ": keyboard -> code-point-utf8?", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
   y <- increment
   var tmpx/eax: int <- copy xmin
   tmpx <- draw-text-rightward screen, "streams", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
@@ -183,7 +183,7 @@ fn render-primitives screen: (addr screen), xmin: int, xmax: int, ymax: int {
   y <- increment
   var tmpx/eax: int <- copy xmin
   tmpx <- draw-text-rightward screen, "  write", tmpx, left-max, y, 0x2a/fg=orange, 0xdc/bg=green-bg
-  tmpx <- draw-text-rightward screen, ": stream grapheme -> stream", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
+  tmpx <- draw-text-rightward screen, ": stream code-point-utf8 -> stream", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
   y <- increment
   var tmpx/eax: int <- copy xmin
   tmpx <- draw-text-rightward screen, "  rewind clear", tmpx, left-max, y, 0x2a/fg=orange, 0xdc/bg=green-bg
@@ -191,7 +191,7 @@ fn render-primitives screen: (addr screen), xmin: int, xmax: int, ymax: int {
   y <- increment
   var tmpx/eax: int <- copy xmin
   tmpx <- draw-text-rightward screen, "  read", tmpx, left-max, y, 0x2a/fg=orange, 0xdc/bg=green-bg
-  tmpx <- draw-text-rightward screen, ": stream -> grapheme", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
+  tmpx <- draw-text-rightward screen, ": stream -> code-point-utf8", tmpx, left-max, y, 7/fg=grey, 0xdc/bg=green-bg
 }
 
 fn primitive-global? _x: (addr global) -> _/eax: boolean {
@@ -3056,7 +3056,7 @@ fn wait-for-key keyboard: (addr gap-buffer) -> _/eax: int {
     return result
   }
   # otherwise read from fake keyboard
-  var g/eax: grapheme <- read-from-gap-buffer keyboard
+  var g/eax: code-point-utf8 <- read-from-gap-buffer keyboard
   var result/eax: int <- copy g
   return result
 }
@@ -3121,14 +3121,14 @@ fn apply-write _args-ah: (addr handle cell), out: (addr handle cell), trace: (ad
     var second-type/eax: (addr int) <- get second, type
     compare *second-type, 1/number
     break-if-=
-    error trace, "second arg for 'write' is not a number/grapheme"
+    error trace, "second arg for 'write' is not a number/code-point-utf8"
     return
   }
   var second-value/eax: (addr float) <- get second, number-data
   var x-float/xmm0: float <- copy *second-value
   var x/eax: int <- convert x-float
-  var x-grapheme/eax: grapheme <- copy x
-  write-grapheme stream-data, x-grapheme
+  var x-code-point-utf8/eax: code-point-utf8 <- copy x
+  write-code-point-utf8 stream-data, x-code-point-utf8
   # return the stream
   copy-object first-ah, out
 }
@@ -3202,8 +3202,8 @@ fn apply-read _args-ah: (addr handle cell), out: (addr handle cell), trace: (add
   var _stream-data/eax: (addr stream byte) <- lookup *stream-data-ah
   var stream-data/ebx: (addr stream byte) <- copy _stream-data
 #?   rewind-stream stream-data
-  var result-grapheme/eax: grapheme <- read-grapheme stream-data
-  var result/eax: int <- copy result-grapheme
+  var result-code-point-utf8/eax: code-point-utf8 <- read-code-point-utf8 stream-data
+  var result/eax: int <- copy result-code-point-utf8
   new-integer out, result
 }
 
diff --git a/shell/sandbox.mu b/shell/sandbox.mu
index d50f47f0..20471115 100644
--- a/shell/sandbox.mu
+++ b/shell/sandbox.mu
@@ -449,7 +449,7 @@ fn render-keyboard-menu screen: (addr screen) {
   draw-text-rightward-from-cursor screen, " to sandbox  ", width, 7/fg, 0xc5/bg=blue-bg
 }
 
-fn edit-sandbox _self: (addr sandbox), key: grapheme, globals: (addr global-table), data-disk: (addr disk) {
+fn edit-sandbox _self: (addr sandbox), key: code-point-utf8, globals: (addr global-table), data-disk: (addr disk) {
   var self/esi: (addr sandbox) <- copy _self
   # ctrl-s
   {
diff --git a/shell/tokenize.mu b/shell/tokenize.mu
index fba26b74..dc392a34 100644
--- a/shell/tokenize.mu
+++ b/shell/tokenize.mu
@@ -429,13 +429,13 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     next-indent-token in, out, trace  # might not be returned
   }
   skip-spaces-from-gap-buffer in
-  var g/eax: grapheme <- peek-from-gap-buffer in
+  var g/eax: code-point-utf8 <- peek-from-gap-buffer in
   {
     compare g, 0x23/comment
     break-if-!=
     skip-rest-of-line in
   }
-  var g/eax: grapheme <- peek-from-gap-buffer in
+  var g/eax: code-point-utf8 <- peek-from-gap-buffer in
   {
     compare g, 0xa/newline
     break-if-!=
@@ -461,8 +461,8 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     trace-higher trace
     return 1/at-start-of-line
   }
-  var _g/eax: grapheme <- peek-from-gap-buffer in
-  var g/ecx: grapheme <- copy _g
+  var _g/eax: code-point-utf8 <- peek-from-gap-buffer in
+  var g/ecx: code-point-utf8 <- copy _g
   {
     var should-trace?/eax: boolean <- should-trace? trace
     compare should-trace?, 0/false
@@ -479,7 +479,7 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     {
       compare g, 0x22/double-quote
       break-if-!=
-      var dummy/eax: grapheme <- read-from-gap-buffer in  # skip
+      var dummy/eax: code-point-utf8 <- read-from-gap-buffer in  # skip
       next-stream-token in, out, trace
       break $next-token:case
     }
@@ -487,13 +487,13 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     {
       compare g, 0x5b/open-square-bracket
       break-if-!=
-      var dummy/eax: grapheme <- read-from-gap-buffer in  # skip open bracket
+      var dummy/eax: code-point-utf8 <- read-from-gap-buffer in  # skip open bracket
       next-balanced-stream-token in, out, trace
       break $next-token:case
     }
     # other symbol char
     {
-      var symbol?/eax: boolean <- symbol-grapheme? g
+      var symbol?/eax: boolean <- symbol-code-point-utf8? g
       compare symbol?, 0/false
       break-if-=
       next-symbol-token in, out, trace
@@ -508,10 +508,10 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     }
     # other brackets are always single-char tokens
     {
-      var bracket?/eax: boolean <- bracket-grapheme? g
+      var bracket?/eax: boolean <- bracket-code-point-utf8? g
       compare bracket?, 0/false
       break-if-=
-      var g/eax: grapheme <- read-from-gap-buffer in
+      var g/eax: code-point-utf8 <- read-from-gap-buffer in
       next-bracket-token g, out, trace
       break $next-token:case
     }
@@ -519,7 +519,7 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     {
       compare g, 0x27/single-quote
       break-if-!=
-      var g/eax: grapheme <- read-from-gap-buffer in  # consume
+      var g/eax: code-point-utf8 <- read-from-gap-buffer in  # consume
       initialize-token out, "'"
       break $next-token:case
     }
@@ -527,7 +527,7 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     {
       compare g, 0x60/backquote
       break-if-!=
-      var g/eax: grapheme <- read-from-gap-buffer in  # consume
+      var g/eax: code-point-utf8 <- read-from-gap-buffer in  # consume
       initialize-token out, "`"
       break $next-token:case
     }
@@ -535,7 +535,7 @@ fn next-token in: (addr gap-buffer), out: (addr token), start-of-line?: boolean,
     {
       compare g, 0x2c/comma
       break-if-!=
-      var g/eax: grapheme <- read-from-gap-buffer in  # consume
+      var g/eax: code-point-utf8 <- read-from-gap-buffer in  # consume
       # check for unquote-splice
       {
         g <- peek-from-gap-buffer in
@@ -581,7 +581,7 @@ fn next-symbol-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
     var done?/eax: boolean <- gap-buffer-scan-done? in
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- peek-from-gap-buffer in
+    var g/eax: code-point-utf8 <- peek-from-gap-buffer in
     {
       {
         var should-trace?/eax: boolean <- should-trace? trace
@@ -597,14 +597,14 @@ fn next-symbol-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
     }
     # if non-symbol, return
     {
-      var symbol-grapheme?/eax: boolean <- symbol-grapheme? g
-      compare symbol-grapheme?, 0/false
+      var symbol-code-point-utf8?/eax: boolean <- symbol-code-point-utf8? g
+      compare symbol-code-point-utf8?, 0/false
       break-if-!=
       trace-text trace, "tokenize", "stop"
       break $next-symbol-token:loop
     }
-    var g/eax: grapheme <- read-from-gap-buffer in
-    write-grapheme out-data, g
+    var g/eax: code-point-utf8 <- read-from-gap-buffer in
+    write-code-point-utf8 out-data, g
     loop
   }
   trace-higher trace
@@ -630,16 +630,16 @@ fn next-number-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
   var _out-data/eax: (addr stream byte) <- lookup *out-data-ah
   var out-data/edi: (addr stream byte) <- copy _out-data
   $next-number-token:check-minus: {
-    var g/eax: grapheme <- peek-from-gap-buffer in
+    var g/eax: code-point-utf8 <- peek-from-gap-buffer in
     compare g, 0x2d/minus
     g <- read-from-gap-buffer in  # consume
-    write-grapheme out-data, g
+    write-code-point-utf8 out-data, g
   }
   $next-number-token:loop: {
     var done?/eax: boolean <- gap-buffer-scan-done? in
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- peek-from-gap-buffer in
+    var g/eax: code-point-utf8 <- peek-from-gap-buffer in
     {
       {
         var should-trace?/eax: boolean <- should-trace? trace
@@ -653,15 +653,15 @@ fn next-number-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
       write-int32-hex stream, gval
       trace trace, "tokenize", stream
     }
-    # if not symbol grapheme, return
+    # if not symbol code-point-utf8, return
     {
-      var symbol-grapheme?/eax: boolean <- symbol-grapheme? g
-      compare symbol-grapheme?, 0/false
+      var symbol-code-point-utf8?/eax: boolean <- symbol-code-point-utf8? g
+      compare symbol-code-point-utf8?, 0/false
       break-if-!=
       trace-text trace, "tokenize", "stop"
       break $next-number-token:loop
     }
-    # if not digit grapheme, abort
+    # if not digit code-point-utf8, abort
     {
       var digit?/eax: boolean <- decimal-digit? g
       compare digit?, 0/false
@@ -670,8 +670,8 @@ fn next-number-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
       return
     }
     trace-text trace, "tokenize", "append"
-    var g/eax: grapheme <- read-from-gap-buffer in
-    write-grapheme out-data, g
+    var g/eax: code-point-utf8 <- read-from-gap-buffer in
+    write-code-point-utf8 out-data, g
     loop
   }
   trace-higher trace
@@ -696,10 +696,10 @@ fn next-stream-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
       error trace, "unbalanced '\"'"
       return
     }
-    var g/eax: grapheme <- read-from-gap-buffer in
+    var g/eax: code-point-utf8 <- read-from-gap-buffer in
     compare g, 0x22/double-quote
     break-if-=
-    write-grapheme out-data, g
+    write-code-point-utf8 out-data, g
     loop
   }
   {
@@ -735,7 +735,7 @@ fn next-balanced-stream-token in: (addr gap-buffer), _out: (addr token), trace:
       error trace, "unbalanced '['"
       return
     }
-    var g/eax: grapheme <- read-from-gap-buffer in
+    var g/eax: code-point-utf8 <- read-from-gap-buffer in
     {
       compare g, 0x5b/open-square-bracket
       break-if-!=
@@ -748,7 +748,7 @@ fn next-balanced-stream-token in: (addr gap-buffer), _out: (addr token), trace:
       break-if-= $next-balanced-stream-token:loop
       decrement bracket-count
     }
-    write-grapheme out-data, g
+    write-code-point-utf8 out-data, g
     loop
   }
   {
@@ -764,14 +764,14 @@ fn next-balanced-stream-token in: (addr gap-buffer), _out: (addr token), trace:
   }
 }
 
-fn next-bracket-token g: grapheme, _out: (addr token), trace: (addr trace) {
+fn next-bracket-token g: code-point-utf8, _out: (addr token), trace: (addr trace) {
   trace-text trace, "tokenize", "bracket"
   var out/eax: (addr token) <- copy _out
   var out-data-ah/eax: (addr handle stream byte) <- get out, text-data
   populate-stream out-data-ah, 0x40
   var _out-data/eax: (addr stream byte) <- lookup *out-data-ah
   var out-data/edi: (addr stream byte) <- copy _out-data
-  write-grapheme out-data, g
+  write-code-point-utf8 out-data, g
   {
     var should-trace?/eax: boolean <- should-trace? trace
     compare should-trace?, 0/false
@@ -790,7 +790,7 @@ fn skip-rest-of-line in: (addr gap-buffer) {
     var done?/eax: boolean <- gap-buffer-scan-done? in
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- peek-from-gap-buffer in
+    var g/eax: code-point-utf8 <- peek-from-gap-buffer in
     compare g, 0xa/newline
     break-if-=
     g <- read-from-gap-buffer in  # consume
@@ -810,7 +810,7 @@ fn next-indent-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
     var done?/eax: boolean <- gap-buffer-scan-done? in
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- peek-from-gap-buffer in
+    var g/eax: code-point-utf8 <- peek-from-gap-buffer in
     {
       {
         var should-trace?/eax: boolean <- should-trace? trace
@@ -844,7 +844,7 @@ fn next-indent-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
   }
 }
 
-# Mu carves up the space of graphemes into 4 categories:
+# Mu carves up the space of code-point-utf8s into 4 categories:
 #   whitespace
 #   quotes and unquotes (from a Lisp perspective; doesn't include double
 #                        quotes or other Unicode quotes)
@@ -856,20 +856,20 @@ fn next-indent-token in: (addr gap-buffer), _out: (addr token), trace: (addr tra
 # During tokenization operators and symbols are treated identically.
 # A later phase digs into that nuance.
 
-fn symbol-grapheme? g: grapheme -> _/eax: boolean {
-  var whitespace?/eax: boolean <- whitespace-grapheme? g
+fn symbol-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
+  var whitespace?/eax: boolean <- whitespace-code-point-utf8? g
   compare whitespace?, 0/false
   {
     break-if-=
     return 0/false
   }
-  var quote-or-unquote?/eax: boolean <- quote-or-unquote-grapheme? g
+  var quote-or-unquote?/eax: boolean <- quote-or-unquote-code-point-utf8? g
   compare quote-or-unquote?, 0/false
   {
     break-if-=
     return 0/false
   }
-  var bracket?/eax: boolean <- bracket-grapheme? g
+  var bracket?/eax: boolean <- bracket-code-point-utf8? g
   compare bracket?, 0/false
   {
     break-if-=
@@ -888,7 +888,7 @@ fn symbol-grapheme? g: grapheme -> _/eax: boolean {
   return 1/true
 }
 
-fn whitespace-grapheme? g: grapheme -> _/eax: boolean {
+fn whitespace-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
   compare g, 9/tab
   {
     break-if-!=
@@ -907,7 +907,7 @@ fn whitespace-grapheme? g: grapheme -> _/eax: boolean {
   return 0/false
 }
 
-fn quote-or-unquote-grapheme? g: grapheme -> _/eax: boolean {
+fn quote-or-unquote-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
   compare g, 0x27/single-quote
   {
     break-if-!=
@@ -931,7 +931,7 @@ fn quote-or-unquote-grapheme? g: grapheme -> _/eax: boolean {
   return 0/false
 }
 
-fn bracket-grapheme? g: grapheme -> _/eax: boolean {
+fn bracket-code-point-utf8? g: code-point-utf8 -> _/eax: boolean {
   compare g, 0x28/open-paren
   {
     break-if-!=
@@ -971,12 +971,12 @@ fn number-token? _self: (addr token) -> _/eax: boolean {
   var _in-data/eax: (addr stream byte) <- lookup *in-data-ah
   var in-data/ecx: (addr stream byte) <- copy _in-data
   rewind-stream in-data
-  var g/eax: grapheme <- read-grapheme in-data
+  var g/eax: code-point-utf8 <- read-code-point-utf8 in-data
   # if '-', read another
   {
     compare g, 0x2d/minus
     break-if-!=
-    g <- read-grapheme in-data
+    g <- read-code-point-utf8 in-data
   }
   {
     {
@@ -990,7 +990,7 @@ fn number-token? _self: (addr token) -> _/eax: boolean {
       compare done?, 0/false
     }
     break-if-!=
-    g <- read-grapheme in-data
+    g <- read-code-point-utf8 in-data
     loop
   }
   return 1/true
@@ -1008,8 +1008,8 @@ fn bracket-token? _self: (addr token) -> _/eax: boolean {
   var in-data-ah/eax: (addr handle stream byte) <- get self, text-data
   var in-data/eax: (addr stream byte) <- lookup *in-data-ah
   rewind-stream in-data
-  var g/eax: grapheme <- read-grapheme in-data
-  var result/eax: boolean <- bracket-grapheme? g
+  var g/eax: code-point-utf8 <- read-code-point-utf8 in-data
+  var result/eax: boolean <- bracket-code-point-utf8? g
   return result
 }
 
@@ -1055,7 +1055,7 @@ fn open-paren-token? _self: (addr token) -> _/eax: boolean {
   var _in-data/eax: (addr stream byte) <- lookup *in-data-ah
   var in-data/ecx: (addr stream byte) <- copy _in-data
   rewind-stream in-data
-  var g/eax: grapheme <- read-grapheme in-data
+  var g/eax: code-point-utf8 <- read-code-point-utf8 in-data
   compare g, 0x28/open-paren
   {
     break-if-!=
@@ -1071,7 +1071,7 @@ fn close-paren-token? _self: (addr token) -> _/eax: boolean {
   var _in-data/eax: (addr stream byte) <- lookup *in-data-ah
   var in-data/ecx: (addr stream byte) <- copy _in-data
   rewind-stream in-data
-  var g/eax: grapheme <- read-grapheme in-data
+  var g/eax: code-point-utf8 <- read-code-point-utf8 in-data
   compare g, 0x29/close-paren
   {
     break-if-!=
@@ -1087,7 +1087,7 @@ fn dot-token? _self: (addr token) -> _/eax: boolean {
   var _in-data/eax: (addr stream byte) <- lookup *in-data-ah
   var in-data/ecx: (addr stream byte) <- copy _in-data
   rewind-stream in-data
-  var g/eax: grapheme <- read-grapheme in-data
+  var g/eax: code-point-utf8 <- read-code-point-utf8 in-data
   compare g, 0x2e/dot
   {
     break-if-!=
diff --git a/shell/trace.mu b/shell/trace.mu
index 298b7e23..e4c9ec5e 100644
--- a/shell/trace.mu
+++ b/shell/trace.mu
@@ -904,7 +904,7 @@ fn render-trace-menu screen: (addr screen) {
   draw-text-rightward-from-cursor screen, " show whole line  ", width, 7/fg, 0xc5/bg=blue-bg
 }
 
-fn edit-trace _self: (addr trace), key: grapheme {
+fn edit-trace _self: (addr trace), key: code-point-utf8 {
   var self/esi: (addr trace) <- copy _self
   # cursor down
   {
diff --git a/signatures.mu b/signatures.mu
index c867ff32..ee8ea5dd 100644
--- a/signatures.mu
+++ b/signatures.mu
@@ -69,8 +69,8 @@ sig slice-starts-with? s: (addr slice), head: (addr array byte) -> _/eax: boolea
 sig write-slice out: (addr stream byte), s: (addr slice)
 sig slice-to-string ad: (addr allocation-descriptor), in: (addr slice), out: (addr handle array byte)
 sig write-int32-decimal out: (addr stream byte), n: int
-sig decimal-digit? c: grapheme -> _/eax: boolean
-sig to-decimal-digit in: grapheme -> _/eax: int
+sig decimal-digit? c: code-point-utf8 -> _/eax: boolean
+sig to-decimal-digit in: code-point-utf8 -> _/eax: int
 sig next-word line: (addr stream byte), out: (addr slice)  # merges '#' comments into a single word
 sig next-raw-word line: (addr stream byte), out: (addr slice)  # does not merge '#' comments
 sig skip-chars-matching in: (addr stream byte), delimiter: byte
@@ -89,18 +89,18 @@ sig parse-array-of-ints s: (addr array byte), out: (addr handle array int)
 sig parse-array-of-decimal-ints s: (addr array byte), out: (addr handle array int)
 sig check-array-equal a: (addr array int), expected: (addr array byte), msg: (addr array byte)
 sig integer-divide a: int, b: int -> _/eax: int, _/edx: int
-sig to-code-point in: grapheme -> _/eax: code-point
-sig to-grapheme in: code-point -> _/eax: grapheme
-sig read-grapheme in: (addr stream byte) -> _/eax: grapheme
-sig grapheme-length g: grapheme -> _/edx: int
+sig to-code-point in: code-point-utf8 -> _/eax: code-point
+sig to-utf8 in: code-point -> _/eax: code-point-utf8
+sig read-code-point-utf8 in: (addr stream byte) -> _/eax: code-point-utf8
+sig utf8-length g: code-point-utf8 -> _/edx: int
 sig shift-left-bytes n: int, k: int -> _/eax: int
-sig write-grapheme out: (addr stream byte), g: grapheme
+sig write-code-point-utf8 out: (addr stream byte), g: code-point-utf8
 sig fill-in-rational _out: (addr float), nr: int, dr: int
 sig fill-in-sqrt _out: (addr float), n: int
 sig rational nr: int, dr: int -> _/xmm0: float
 sig scale-down-and-round-up n: int, m: int -> _/ecx: int
 sig substring in: (addr array byte), start: int, len: int, out-ah: (addr handle array byte)
-sig split-string in: (addr array byte), delim: grapheme, out: (addr handle array (handle array byte))
+sig split-string in: (addr array byte), delim: code-point-utf8, out: (addr handle array (handle array byte))
 sig render-float-decimal screen: (addr screen), in: float, precision: int, x: int, y: int, color: int, background-color: int -> _/eax: int
 sig write-float-decimal-approximate out: (addr stream byte), in: float, precision: int
 sig decimal-digits n: int, _buf: (addr array byte) -> _/eax: int
@@ -242,22 +242,22 @@ sig slide-down _a: (addr array int), start: int, end: int, target: int
 sig find-slide-down-slot-in-array _a: (addr array int), _val: int -> _/ecx: int
 sig check-slide-up before: (addr array byte), start: int, end: int, target: int, after: (addr array byte), msg: (addr array byte)
 sig check-slide-down before: (addr array byte), start: int, end: int, target: int, after: (addr array byte), msg: (addr array byte)
-sig initialize-grapheme-stack _self: (addr grapheme-stack), n: int
-sig clear-grapheme-stack _self: (addr grapheme-stack)
-sig grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean
-sig grapheme-stack-length _self: (addr grapheme-stack) -> _/eax: int
-sig push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme
-sig pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme
-sig copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack)
-sig render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _self: (addr grapheme-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int, color: int, background-color: int -> _/eax: int, _/ecx: int
-sig render-stack-from-bottom screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int -> _/eax: int
-sig render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self: (addr grapheme-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int
-sig render-stack-from-top screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int
-sig get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?: boolean -> _/edx: int
-sig get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean, depth: int -> _/edx: int
-sig prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean
-sig suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean
-sig grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean
+sig initialize-code-point-utf8-stack _self: (addr code-point-utf8-stack), n: int
+sig clear-code-point-utf8-stack _self: (addr code-point-utf8-stack)
+sig code-point-utf8-stack-empty? _self: (addr code-point-utf8-stack) -> _/eax: boolean
+sig code-point-utf8-stack-length _self: (addr code-point-utf8-stack) -> _/eax: int
+sig push-code-point-utf8-stack _self: (addr code-point-utf8-stack), _val: code-point-utf8
+sig pop-code-point-utf8-stack _self: (addr code-point-utf8-stack) -> _/eax: code-point-utf8
+sig copy-code-point-utf8-stack _src: (addr code-point-utf8-stack), dest: (addr code-point-utf8-stack)
+sig render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _self: (addr code-point-utf8-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int, color: int, background-color: int -> _/eax: int, _/ecx: int
+sig render-stack-from-bottom screen: (addr screen), self: (addr code-point-utf8-stack), x: int, y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int -> _/eax: int
+sig render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self: (addr code-point-utf8-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int
+sig render-stack-from-top screen: (addr screen), self: (addr code-point-utf8-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int
+sig get-matching-close-paren-index _self: (addr code-point-utf8-stack), render-cursor?: boolean -> _/edx: int
+sig get-matching-open-paren-index _self: (addr code-point-utf8-stack), control: boolean, depth: int -> _/edx: int
+sig prefix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean
+sig suffix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean
+sig code-point-utf8-stack-is-decimal-integer? _self: (addr code-point-utf8-stack) -> _/eax: boolean
 sig initialize-gap-buffer _self: (addr gap-buffer), capacity: int
 sig clear-gap-buffer _self: (addr gap-buffer)
 sig gap-buffer-empty? _self: (addr gap-buffer) -> _/eax: boolean
@@ -266,43 +266,43 @@ sig initialize-gap-buffer-with self: (addr gap-buffer), keys: (addr array byte)
 sig load-gap-buffer-from-stream self: (addr gap-buffer), in: (addr stream byte)
 sig emit-gap-buffer self: (addr gap-buffer), out: (addr stream byte)
 sig append-gap-buffer _self: (addr gap-buffer), out: (addr stream byte)
-sig emit-stack-from-bottom _self: (addr grapheme-stack), out: (addr stream byte)
-sig emit-stack-from-top _self: (addr grapheme-stack), out: (addr stream byte)
+sig emit-stack-from-bottom _self: (addr code-point-utf8-stack), out: (addr stream byte)
+sig emit-stack-from-top _self: (addr code-point-utf8-stack), out: (addr stream byte)
 sig word-at-gap _self: (addr gap-buffer), out: (addr stream byte)
-sig grapheme-at-gap _self: (addr gap-buffer) -> _/eax: grapheme
-sig top-most-word _self: (addr grapheme-stack) -> _/eax: int
-sig emit-stack-from-index _self: (addr grapheme-stack), start: int, out: (addr stream byte)
-sig emit-stack-to-index _self: (addr grapheme-stack), end: int, out: (addr stream byte)
-sig is-ascii-word-grapheme? g: grapheme -> _/eax: boolean
+sig code-point-utf8-at-gap _self: (addr gap-buffer) -> _/eax: code-point-utf8
+sig top-most-word _self: (addr code-point-utf8-stack) -> _/eax: int
+sig emit-stack-from-index _self: (addr code-point-utf8-stack), start: int, out: (addr stream byte)
+sig emit-stack-to-index _self: (addr code-point-utf8-stack), end: int, out: (addr stream byte)
+sig is-ascii-word-code-point-utf8? g: code-point-utf8 -> _/eax: boolean
 sig render-gap-buffer-wrapping-right-then-down screen: (addr screen), _gap: (addr gap-buffer), xmin: int, ymin: int, xmax: int, ymax: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int
 sig render-gap-buffer screen: (addr screen), gap: (addr gap-buffer), x: int, y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int
 sig gap-buffer-length _gap: (addr gap-buffer) -> _/eax: int
-sig add-grapheme-at-gap _self: (addr gap-buffer), g: grapheme
+sig add-code-point-utf8-at-gap _self: (addr gap-buffer), g: code-point-utf8
 sig add-code-point-at-gap self: (addr gap-buffer), c: code-point
 sig gap-to-start self: (addr gap-buffer)
 sig gap-to-end self: (addr gap-buffer)
 sig gap-at-start? _self: (addr gap-buffer) -> _/eax: boolean
 sig gap-at-end? _self: (addr gap-buffer) -> _/eax: boolean
-sig gap-right _self: (addr gap-buffer) -> _/eax: grapheme
-sig gap-left _self: (addr gap-buffer) -> _/eax: grapheme
+sig gap-right _self: (addr gap-buffer) -> _/eax: code-point-utf8
+sig gap-left _self: (addr gap-buffer) -> _/eax: code-point-utf8
 sig index-of-gap _self: (addr gap-buffer) -> _/eax: int
-sig first-grapheme-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme
-sig grapheme-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme
+sig first-code-point-utf8-in-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8
+sig code-point-utf8-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8
 sig delete-before-gap _self: (addr gap-buffer)
-sig pop-after-gap _self: (addr gap-buffer) -> _/eax: grapheme
+sig pop-after-gap _self: (addr gap-buffer) -> _/eax: code-point-utf8
 sig gap-buffer-equal? _self: (addr gap-buffer), s: (addr array byte) -> _/eax: boolean
 sig gap-buffers-equal? self: (addr gap-buffer), g: (addr gap-buffer) -> _/eax: boolean
-sig gap-index _self: (addr gap-buffer), _n: int -> _/eax: grapheme
+sig gap-index _self: (addr gap-buffer), _n: int -> _/eax: code-point-utf8
 sig copy-gap-buffer _src-ah: (addr handle gap-buffer), _dest-ah: (addr handle gap-buffer)
 sig gap-buffer-is-decimal-integer? _self: (addr gap-buffer) -> _/eax: boolean
 sig highlight-matching-open-paren? _gap: (addr gap-buffer), render-cursor?: boolean -> _/ebx: boolean, _/edi: int
 sig rewind-gap-buffer _self: (addr gap-buffer)
 sig gap-buffer-scan-done? _self: (addr gap-buffer) -> _/eax: boolean
-sig peek-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme
-sig read-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme
+sig peek-from-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8
+sig read-from-gap-buffer _self: (addr gap-buffer) -> _/eax: code-point-utf8
 sig put-back-from-gap-buffer _self: (addr gap-buffer)
 sig skip-spaces-from-gap-buffer self: (addr gap-buffer)
-sig edit-gap-buffer self: (addr gap-buffer), key: grapheme
+sig edit-gap-buffer self: (addr gap-buffer), key: code-point-utf8
 sig gap-to-start-of-next-word self: (addr gap-buffer)
 sig gap-to-end-of-previous-word self: (addr gap-buffer)
 sig gap-to-previous-start-of-line self: (addr gap-buffer)
diff --git a/tutorial/converter.mu b/tutorial/converter.mu
index a8aa26e3..b101fbdd 100644
--- a/tutorial/converter.mu
+++ b/tutorial/converter.mu
@@ -55,7 +55,7 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
     # process a single keystroke
     $main:input: {
       var key/eax: byte <- read-key keyboard
-      var key/eax: grapheme <- copy key
+      var key/eax: code-point-utf8 <- copy key
       compare key, 0
       loop-if-=
       # tab = switch cursor between input areas
diff --git a/tutorial/converter2.mu b/tutorial/converter2.mu
index ae445239..5e338647 100644
--- a/tutorial/converter2.mu
+++ b/tutorial/converter2.mu
@@ -37,7 +37,7 @@ fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk)
     # process a single keystroke
     $main:input: {
       var key/eax: byte <- read-key keyboard
-      var key/eax: grapheme <- copy key
+      var key/eax: code-point-utf8 <- copy key
       compare key, 0
       loop-if-=
       # tab = switch cursor between input areas
diff --git a/tutorial/index.md b/tutorial/index.md
index 48173fbb..3c7f781f 100644
--- a/tutorial/index.md
+++ b/tutorial/index.md
@@ -541,7 +541,7 @@ fn main screen: (addr screen), keyboard: (addr keyboard) {
     var done?/eax: boolean <- stream-empty? in
     compare done?, 0/false
     break-if-!=
-    var g/eax: grapheme <- read-grapheme in
+    var g/eax: code-point-utf8 <- read-code-point-utf8 in
     # do stuff with g here
     loop
   }
@@ -550,8 +550,8 @@ fn main screen: (addr screen), keyboard: (addr keyboard) {
 
 `read-line-from-keyboard` reads keystrokes from the keyboard until you press
 the `Enter` (also called `newline`) key, and accumulates them into a _stream_
-of bytes. The loop then repeatedly reads _graphemes_ from the stream. A
-grapheme can consist of multiple bytes, particularly outside of the Latin
+of bytes. The loop then repeatedly reads _code-point-utf8s_ from the stream. A
+code-point-utf8 can consist of multiple bytes, particularly outside of the Latin
 alphabet and Arabic digits most prevalent in the West. Mu doesn't yet support
 non-Qwerty keyboards, but support for other keyboards should be easy to add.
 
@@ -561,12 +561,12 @@ give yourself a sense of what you can do with them. Does the above program
 make sense now?  Feel free to experiment to make sense of it.
 
 Can you modify it to print out the line a second time, after you've typed it
-out until the `Enter` key? Can you print a space after every grapheme when you
+out until the `Enter` key? Can you print a space after every code-point-utf8 when you
 print the line out a second time? You'll need to skim the section on
 [printing to screen](https://github.com/akkartik/mu/blob/main/vocabulary.md#printing-to-screen)
 from Mu's vocabulary. Pay particular attention to the difference between a
-grapheme and a _code-point_. Mu programs often read characters in units of
-graphemes, but they must draw in units of code-points that the font manages.
+code-point-utf8 and a _code-point_. Mu programs often read characters in units of
+code-point-utf8s, but they must draw in units of code-points that the font manages.
 (This adds some complexity but helps combine multiple code-points into a
 single glyph as needed for some languages.)
 
diff --git a/vocabulary.md b/vocabulary.md
index 931df057..9047a2fd 100644
--- a/vocabulary.md
+++ b/vocabulary.md
@@ -43,7 +43,7 @@ how they work under the hood.
 - Code-points: integer representing a Unicode character. Must be representable
   in 32 bits as utf-8; largest supported value is 0x10000.
 
-Mu will let you convert between bytes, graphemes and code-points using `copy`,
+Mu will let you convert between bytes, code-point-utf8s and code-points using `copy`,
 and trust that you know what you're doing. Be aware that doing so is only
 correct for English/Latin characters, digits and symbols.
 
@@ -120,7 +120,7 @@ signatures.mu for their full type signatures.
 - `append-byte-hex`: writes textual representation of lowest byte in hex to
   a stream of bytes. Does not write a '0x' prefix.
 - `read-byte`: reads a single byte from a stream of bytes.
-- `read-grapheme`: reads a single unicode grapheme (up to 4 bytes) from a
+- `read-code-point-utf8`: reads a single unicode code-point-utf8 (up to 4 bytes) from a
   stream of bytes.
 
 #### reading/writing hex representations of integers
@@ -137,7 +137,7 @@ signatures.mu for their full type signatures.
 - `parse-decimal-int-from-slice`
 - `parse-decimal-int-from-stream`
 - `parse-array-of-decimal-ints`
-- `decimal-digit?`: checks if a grapheme is in [0, 9]
+- `decimal-digit?`: checks if a code-point-utf8 is in [0, 9]
 
 #### printing to screen
 
@@ -197,7 +197,7 @@ automatically read and update the cursor position in various ways.
   These primitives always silently fail if the desired movement would go out
   of screen bounds.
 - `move-cursor-to-left-margin-of-next-line`
-- `move-cursor-rightward-and-downward`: move cursor one grapheme to the right
+- `move-cursor-rightward-and-downward`: move cursor one code-point-utf8 to the right
 
 - `draw-text-rightward-from-cursor`: truncate at some right margin.
 - `draw-text-rightward-from-cursor-over-full-screen`: truncate at right edge
@@ -255,7 +255,7 @@ Assertions for tests:
 
 `read-key` reads a single key from the keyboard and returns it if it exists.
 Returns 0 if no key has been pressed. Currently only support single-byte keys,
-which are identical to their code-point and grapheme representations.
+which are identical to their code-point and code-point-utf8 representations.
 
 `read-line-from-keyboard` reads keys from keyboard, echoes them to screen
 (with given fg/bg colors) and accumulates them in a stream until it encounters