diff --git a/AffinityPanel.c b/AffinityPanel.c
index e491b524..767e849a 100644
--- a/AffinityPanel.c
+++ b/AffinityPanel.c
@@ -59,25 +59,25 @@ static void MaskItem_delete(Object* cast) {
 static void MaskItem_display(const Object* cast, RichString* out) {
    const MaskItem* this = (const MaskItem*)cast;
    assert (this != NULL);
-   RichString_append(out, CRT_colors[CHECK_BOX], "[");
+   RichString_appendAscii(out, CRT_colors[CHECK_BOX], "[");
    if (this->value == 2) {
-      RichString_append(out, CRT_colors[CHECK_MARK], "x");
+      RichString_appendAscii(out, CRT_colors[CHECK_MARK], "x");
    } else if (this->value == 1) {
-      RichString_append(out, CRT_colors[CHECK_MARK], "o");
+      RichString_appendAscii(out, CRT_colors[CHECK_MARK], "o");
    } else {
-      RichString_append(out, CRT_colors[CHECK_MARK], " ");
+      RichString_appendAscii(out, CRT_colors[CHECK_MARK], " ");
    }
-   RichString_append(out, CRT_colors[CHECK_BOX], "]");
-   RichString_append(out, CRT_colors[CHECK_TEXT], " ");
+   RichString_appendAscii(out, CRT_colors[CHECK_BOX], "]");
+   RichString_appendAscii(out, CRT_colors[CHECK_TEXT], " ");
    if (this->indent) {
-      RichString_append(out, CRT_colors[PROCESS_TREE], this->indent);
-      RichString_append(out, CRT_colors[PROCESS_TREE],
-                        this->sub_tree == 2
-                        ? CRT_treeStr[TREE_STR_OPEN]
-                        : CRT_treeStr[TREE_STR_SHUT]);
-      RichString_append(out, CRT_colors[CHECK_TEXT], " ");
+      RichString_appendWide(out, CRT_colors[PROCESS_TREE], this->indent);
+      RichString_appendWide(out, CRT_colors[PROCESS_TREE],
+                            this->sub_tree == 2
+                            ? CRT_treeStr[TREE_STR_OPEN]
+                            : CRT_treeStr[TREE_STR_SHUT]);
+      RichString_appendAscii(out, CRT_colors[CHECK_TEXT], " ");
    }
-   RichString_append(out, CRT_colors[CHECK_TEXT], this->text);
+   RichString_appendWide(out, CRT_colors[CHECK_TEXT], this->text);
 }
 
 static const ObjectClass MaskItem_class = {
diff --git a/CPUMeter.c b/CPUMeter.c
index 97fc3f0b..cf5b9ed5 100644
--- a/CPUMeter.c
+++ b/CPUMeter.c
@@ -104,49 +104,49 @@ static void CPUMeter_display(const Object* cast, RichString* out) {
    const Meter* this = (const Meter*)cast;
    RichString_prune(out);
    if (this->param > this->pl->cpuCount) {
-      RichString_append(out, CRT_colors[METER_TEXT], "absent");
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "absent");
       return;
    }
    xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_NORMAL]);
-   RichString_append(out, CRT_colors[METER_TEXT], ":");
-   RichString_append(out, CRT_colors[CPU_NORMAL], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], ":");
+   RichString_appendAscii(out, CRT_colors[CPU_NORMAL], buffer);
    if (this->pl->settings->detailedCPUTime) {
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_KERNEL]);
-      RichString_append(out, CRT_colors[METER_TEXT], "sy:");
-      RichString_append(out, CRT_colors[CPU_SYSTEM], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "sy:");
+      RichString_appendAscii(out, CRT_colors[CPU_SYSTEM], buffer);
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_NICE]);
-      RichString_append(out, CRT_colors[METER_TEXT], "ni:");
-      RichString_append(out, CRT_colors[CPU_NICE_TEXT], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "ni:");
+      RichString_appendAscii(out, CRT_colors[CPU_NICE_TEXT], buffer);
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_IRQ]);
-      RichString_append(out, CRT_colors[METER_TEXT], "hi:");
-      RichString_append(out, CRT_colors[CPU_IRQ], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "hi:");
+      RichString_appendAscii(out, CRT_colors[CPU_IRQ], buffer);
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_SOFTIRQ]);
-      RichString_append(out, CRT_colors[METER_TEXT], "si:");
-      RichString_append(out, CRT_colors[CPU_SOFTIRQ], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "si:");
+      RichString_appendAscii(out, CRT_colors[CPU_SOFTIRQ], buffer);
       if (!isnan(this->values[CPU_METER_STEAL])) {
          xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_STEAL]);
-         RichString_append(out, CRT_colors[METER_TEXT], "st:");
-         RichString_append(out, CRT_colors[CPU_STEAL], buffer);
+         RichString_appendAscii(out, CRT_colors[METER_TEXT], "st:");
+         RichString_appendAscii(out, CRT_colors[CPU_STEAL], buffer);
       }
       if (!isnan(this->values[CPU_METER_GUEST])) {
          xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_GUEST]);
-         RichString_append(out, CRT_colors[METER_TEXT], "gu:");
-         RichString_append(out, CRT_colors[CPU_GUEST], buffer);
+         RichString_appendAscii(out, CRT_colors[METER_TEXT], "gu:");
+         RichString_appendAscii(out, CRT_colors[CPU_GUEST], buffer);
       }
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_IOWAIT]);
-      RichString_append(out, CRT_colors[METER_TEXT], "wa:");
-      RichString_append(out, CRT_colors[CPU_IOWAIT], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "wa:");
+      RichString_appendAscii(out, CRT_colors[CPU_IOWAIT], buffer);
    } else {
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_KERNEL]);
-      RichString_append(out, CRT_colors[METER_TEXT], "sys:");
-      RichString_append(out, CRT_colors[CPU_SYSTEM], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "sys:");
+      RichString_appendAscii(out, CRT_colors[CPU_SYSTEM], buffer);
       xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_NICE]);
-      RichString_append(out, CRT_colors[METER_TEXT], "low:");
-      RichString_append(out, CRT_colors[CPU_NICE_TEXT], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "low:");
+      RichString_appendAscii(out, CRT_colors[CPU_NICE_TEXT], buffer);
       if (!isnan(this->values[CPU_METER_IRQ])) {
          xSnprintf(buffer, sizeof(buffer), "%5.1f%% ", this->values[CPU_METER_IRQ]);
-         RichString_append(out, CRT_colors[METER_TEXT], "vir:");
-         RichString_append(out, CRT_colors[CPU_GUEST], buffer);
+         RichString_appendAscii(out, CRT_colors[METER_TEXT], "vir:");
+         RichString_appendAscii(out, CRT_colors[CPU_GUEST], buffer);
       }
    }
 
@@ -161,8 +161,8 @@ static void CPUMeter_display(const Object* cast, RichString* out) {
       } else {
          xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%5.1f%sC", cpuTemperature, CRT_degreeSign);
       }
-      RichString_append(out, CRT_colors[METER_TEXT], "temp:");
-      RichString_append(out, CRT_colors[METER_VALUE], cpuTemperatureBuffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], "temp:");
+      RichString_appendWide(out, CRT_colors[METER_VALUE], cpuTemperatureBuffer);
    }
    #endif
 }
diff --git a/DiskIOMeter.c b/DiskIOMeter.c
index 0105ce35..04ca5a76 100644
--- a/DiskIOMeter.c
+++ b/DiskIOMeter.c
@@ -88,7 +88,7 @@ static void DiskIOMeter_updateValues(Meter* this, char* buffer, size_t len) {
 
 static void DIskIOMeter_display(ATTR_UNUSED const Object* cast, RichString* out) {
    if (!hasData) {
-      RichString_write(out, CRT_colors[METER_VALUE_ERROR], "no data");
+      RichString_writeAscii(out, CRT_colors[METER_VALUE_ERROR], "no data");
       return;
    }
 
@@ -96,15 +96,15 @@ static void DIskIOMeter_display(ATTR_UNUSED const Object* cast, RichString* out)
 
    int color = cached_utilisation_diff > 40.0 ? METER_VALUE_NOTICE : METER_VALUE;
    xSnprintf(buffer, sizeof(buffer), "%.1f%%", cached_utilisation_diff);
-   RichString_write(out, CRT_colors[color], buffer);
+   RichString_writeAscii(out, CRT_colors[color], buffer);
 
-   RichString_append(out, CRT_colors[METER_TEXT], " read: ");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " read: ");
    Meter_humanUnit(buffer, cached_read_diff, sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_VALUE_IOREAD], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE_IOREAD], buffer);
 
-   RichString_append(out, CRT_colors[METER_TEXT], " write: ");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " write: ");
    Meter_humanUnit(buffer, cached_write_diff, sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_VALUE_IOWRITE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE_IOWRITE], buffer);
 }
 
 const MeterClass DiskIOMeter_class = {
diff --git a/ListItem.c b/ListItem.c
index c3c1a7d3..8d962aef 100644
--- a/ListItem.c
+++ b/ListItem.c
@@ -29,7 +29,7 @@ static void ListItem_display(const Object* cast, RichString* out) {
    assert (this != NULL);
 
    if (this->moving) {
-      RichString_write(out, CRT_colors[DEFAULT_COLOR],
+      RichString_writeWide(out, CRT_colors[DEFAULT_COLOR],
 #ifdef HAVE_LIBNCURSESW
                        CRT_utf8 ? "↕ " :
 #endif
@@ -37,7 +37,7 @@ static void ListItem_display(const Object* cast, RichString* out) {
    } else {
       RichString_prune(out);
    }
-   RichString_append(out, CRT_colors[DEFAULT_COLOR], this->value);
+   RichString_appendWide(out, CRT_colors[DEFAULT_COLOR], this->value);
 }
 
 ListItem* ListItem_new(const char* value, int key) {
diff --git a/LoadAverageMeter.c b/LoadAverageMeter.c
index d5424cd2..248d65cd 100644
--- a/LoadAverageMeter.c
+++ b/LoadAverageMeter.c
@@ -33,11 +33,11 @@ static void LoadAverageMeter_display(const Object* cast, RichString* out) {
    const Meter* this = (const Meter*)cast;
    char buffer[20];
    xSnprintf(buffer, sizeof(buffer), "%.2f ", this->values[0]);
-   RichString_write(out, CRT_colors[LOAD_AVERAGE_ONE], buffer);
+   RichString_writeAscii(out, CRT_colors[LOAD_AVERAGE_ONE], buffer);
    xSnprintf(buffer, sizeof(buffer), "%.2f ", this->values[1]);
-   RichString_append(out, CRT_colors[LOAD_AVERAGE_FIVE], buffer);
+   RichString_appendAscii(out, CRT_colors[LOAD_AVERAGE_FIVE], buffer);
    xSnprintf(buffer, sizeof(buffer), "%.2f ", this->values[2]);
-   RichString_append(out, CRT_colors[LOAD_AVERAGE_FIFTEEN], buffer);
+   RichString_appendAscii(out, CRT_colors[LOAD_AVERAGE_FIFTEEN], buffer);
 }
 
 static void LoadMeter_updateValues(Meter* this, char* buffer, size_t size) {
@@ -53,7 +53,7 @@ static void LoadMeter_display(const Object* cast, RichString* out) {
    const Meter* this = (const Meter*)cast;
    char buffer[20];
    xSnprintf(buffer, sizeof(buffer), "%.2f ", this->values[0]);
-   RichString_write(out, CRT_colors[LOAD], buffer);
+   RichString_writeAscii(out, CRT_colors[LOAD], buffer);
 }
 
 const MeterClass LoadAverageMeter_class = {
diff --git a/MemoryMeter.c b/MemoryMeter.c
index ad846527..e4754427 100644
--- a/MemoryMeter.c
+++ b/MemoryMeter.c
@@ -34,18 +34,18 @@ static void MemoryMeter_updateValues(Meter* this, char* buffer, size_t size) {
 static void MemoryMeter_display(const Object* cast, RichString* out) {
    char buffer[50];
    const Meter* this = (const Meter*)cast;
-   RichString_write(out, CRT_colors[METER_TEXT], ":");
+   RichString_writeAscii(out, CRT_colors[METER_TEXT], ":");
    Meter_humanUnit(buffer, this->total, sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_VALUE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
    Meter_humanUnit(buffer, this->values[0], sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_TEXT], " used:");
-   RichString_append(out, CRT_colors[MEMORY_USED], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " used:");
+   RichString_appendAscii(out, CRT_colors[MEMORY_USED], buffer);
    Meter_humanUnit(buffer, this->values[1], sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_TEXT], " buffers:");
-   RichString_append(out, CRT_colors[MEMORY_BUFFERS_TEXT], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " buffers:");
+   RichString_appendAscii(out, CRT_colors[MEMORY_BUFFERS_TEXT], buffer);
    Meter_humanUnit(buffer, this->values[2], sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_TEXT], " cache:");
-   RichString_append(out, CRT_colors[MEMORY_CACHE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " cache:");
+   RichString_appendAscii(out, CRT_colors[MEMORY_CACHE], buffer);
 }
 
 const MeterClass MemoryMeter_class = {
diff --git a/Meter.c b/Meter.c
index 945911c9..b006a584 100644
--- a/Meter.c
+++ b/Meter.c
@@ -100,7 +100,7 @@ static inline void Meter_displayBuffer(const Meter* this, const char* buffer, Ri
    if (Object_displayFn(this)) {
       Object_display(this, out);
    } else {
-      RichString_write(out, CRT_colors[Meter_attributes(this)[0]], buffer);
+      RichString_writeWide(out, CRT_colors[Meter_attributes(this)[0]], buffer);
    }
 }
 
@@ -201,7 +201,7 @@ static void BarMeterMode_draw(Meter* this, int x, int y, int w) {
 
    RichString_begin(bar);
    RichString_appendChr(&bar, ' ', padding);
-   RichString_append(&bar, 0, buffer);
+   RichString_appendWide(&bar, 0, buffer);
    assert(RichString_sizeVal(bar) >= w);
 
    int blockSizes[10];
diff --git a/NetworkIOMeter.c b/NetworkIOMeter.c
index 90ec9909..a898b311 100644
--- a/NetworkIOMeter.c
+++ b/NetworkIOMeter.c
@@ -88,24 +88,24 @@ static void NetworkIOMeter_updateValues(ATTR_UNUSED Meter* this, char* buffer, s
 
 static void NetworkIOMeter_display(ATTR_UNUSED const Object* cast, RichString* out) {
    if (!hasData) {
-      RichString_write(out, CRT_colors[METER_VALUE_ERROR], "no data");
+      RichString_writeAscii(out, CRT_colors[METER_VALUE_ERROR], "no data");
       return;
    }
 
    char buffer[64];
 
-   RichString_write(out, CRT_colors[METER_TEXT], "rx: ");
+   RichString_writeAscii(out, CRT_colors[METER_TEXT], "rx: ");
    Meter_humanUnit(buffer, cached_rxb_diff, sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_VALUE_IOREAD], buffer);
-   RichString_append(out, CRT_colors[METER_VALUE_IOREAD], "iB/s");
+   RichString_appendAscii(out, CRT_colors[METER_VALUE_IOREAD], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE_IOREAD], "iB/s");
 
-   RichString_append(out, CRT_colors[METER_TEXT], " tx: ");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " tx: ");
    Meter_humanUnit(buffer, cached_txb_diff, sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_VALUE_IOWRITE], buffer);
-   RichString_append(out, CRT_colors[METER_VALUE_IOWRITE], "iB/s");
+   RichString_appendAscii(out, CRT_colors[METER_VALUE_IOWRITE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE_IOWRITE], "iB/s");
 
    xSnprintf(buffer, sizeof(buffer), " (%lu/%lu packets) ", cached_rxp_diff, cached_txp_diff);
-   RichString_append(out, CRT_colors[METER_TEXT], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], buffer);
 }
 
 const MeterClass NetworkIOMeter_class = {
diff --git a/OptionItem.c b/OptionItem.c
index 00001fce..688fab8f 100644
--- a/OptionItem.c
+++ b/OptionItem.c
@@ -29,14 +29,14 @@ static void CheckItem_display(const Object* cast, RichString* out) {
    const CheckItem* this = (const CheckItem*)cast;
    assert (this != NULL);
 
-   RichString_write(out, CRT_colors[CHECK_BOX], "[");
+   RichString_writeAscii(out, CRT_colors[CHECK_BOX], "[");
    if (CheckItem_get(this)) {
-      RichString_append(out, CRT_colors[CHECK_MARK], "x");
+      RichString_appendAscii(out, CRT_colors[CHECK_MARK], "x");
    } else {
-      RichString_append(out, CRT_colors[CHECK_MARK], " ");
+      RichString_appendAscii(out, CRT_colors[CHECK_MARK], " ");
    }
-   RichString_append(out, CRT_colors[CHECK_BOX], "]    ");
-   RichString_append(out, CRT_colors[CHECK_TEXT], this->super.text);
+   RichString_appendAscii(out, CRT_colors[CHECK_BOX], "]    ");
+   RichString_appendWide(out, CRT_colors[CHECK_TEXT], this->super.text);
 }
 
 static void NumberItem_display(const Object* cast, RichString* out) {
@@ -44,7 +44,7 @@ static void NumberItem_display(const Object* cast, RichString* out) {
    assert (this != NULL);
 
    char buffer[12];
-   RichString_write(out, CRT_colors[CHECK_BOX], "[");
+   RichString_writeAscii(out, CRT_colors[CHECK_BOX], "[");
    int written;
    if (this->scale < 0) {
       written = xSnprintf(buffer, sizeof(buffer), "%.*f", -this->scale, pow(10, this->scale) * NumberItem_get(this));
@@ -53,12 +53,12 @@ static void NumberItem_display(const Object* cast, RichString* out) {
    } else {
       written = xSnprintf(buffer, sizeof(buffer), "%d", NumberItem_get(this));
    }
-   RichString_append(out, CRT_colors[CHECK_MARK], buffer);
-   RichString_append(out, CRT_colors[CHECK_BOX], "]");
+   RichString_appendAscii(out, CRT_colors[CHECK_MARK], buffer);
+   RichString_appendAscii(out, CRT_colors[CHECK_BOX], "]");
    for (int i = written; i < 5; i++) {
-      RichString_append(out, CRT_colors[CHECK_BOX], " ");
+      RichString_appendAscii(out, CRT_colors[CHECK_BOX], " ");
    }
-   RichString_append(out, CRT_colors[CHECK_TEXT], this->super.text);
+   RichString_appendWide(out, CRT_colors[CHECK_TEXT], this->super.text);
 }
 
 const OptionItemClass OptionItem_class = {
diff --git a/Panel.c b/Panel.c
index 21dfbe22..37b9c4ef 100644
--- a/Panel.c
+++ b/Panel.c
@@ -82,7 +82,7 @@ RichString* Panel_getHeader(Panel* this) {
 }
 
 inline void Panel_setHeader(Panel* this, const char* header) {
-   RichString_write(&(this->header), CRT_colors[PANEL_HEADER_FOCUS], header);
+   RichString_writeWide(&(this->header), CRT_colors[PANEL_HEADER_FOCUS], header);
    this->needsRedraw = true;
 }
 
diff --git a/Process.c b/Process.c
index 8245f86d..e84ac73d 100644
--- a/Process.c
+++ b/Process.c
@@ -74,53 +74,53 @@ void Process_humanNumber(RichString* str, unsigned long long number, bool colori
    if (number < 1000) {
       //Plain number, no markings
       len = xSnprintf(buffer, sizeof(buffer), "%5llu ", number);
-      RichString_appendn(str, processColor, buffer, len);
+      RichString_appendnAscii(str, processColor, buffer, len);
    } else if (number < 100000) {
       //2 digit MB, 3 digit KB
       len = xSnprintf(buffer, sizeof(buffer), "%2llu", number/1000);
-      RichString_appendn(str, processMegabytesColor, buffer, len);
+      RichString_appendnAscii(str, processMegabytesColor, buffer, len);
       number %= 1000;
       len = xSnprintf(buffer, sizeof(buffer), "%03llu ", number);
-      RichString_appendn(str, processColor, buffer, len);
+      RichString_appendnAscii(str, processColor, buffer, len);
    } else if (number < 1000 * ONE_K) {
       //3 digit MB
       number /= ONE_K;
       len = xSnprintf(buffer, sizeof(buffer), "%4lluM ", number);
-      RichString_appendn(str, processMegabytesColor, buffer, len);
+      RichString_appendnAscii(str, processMegabytesColor, buffer, len);
    } else if (number < 10000 * ONE_K) {
       //1 digit GB, 3 digit MB
       number /= ONE_K;
       len = xSnprintf(buffer, sizeof(buffer), "%1llu", number/1000);
-      RichString_appendn(str, processGigabytesColor, buffer, len);
+      RichString_appendnAscii(str, processGigabytesColor, buffer, len);
       number %= 1000;
       len = xSnprintf(buffer, sizeof(buffer), "%03lluM ", number);
-      RichString_appendn(str, processMegabytesColor, buffer, len);
+      RichString_appendnAscii(str, processMegabytesColor, buffer, len);
    } else if (number < 100000 * ONE_K) {
       //2 digit GB, 1 digit MB
       number /= 100 * ONE_K;
       len = xSnprintf(buffer, sizeof(buffer), "%2llu", number/10);
-      RichString_appendn(str, processGigabytesColor, buffer, len);
+      RichString_appendnAscii(str, processGigabytesColor, buffer, len);
       number %= 10;
       len = xSnprintf(buffer, sizeof(buffer), ".%1llu", number);
-      RichString_appendn(str, processMegabytesColor, buffer, len);
-      RichString_append(str, processGigabytesColor, "G ");
+      RichString_appendnAscii(str, processMegabytesColor, buffer, len);
+      RichString_appendAscii(str, processGigabytesColor, "G ");
    } else if (number < 1000 * ONE_M) {
       //3 digit GB
       number /= ONE_M;
       len = xSnprintf(buffer, sizeof(buffer), "%4lluG ", number);
-      RichString_appendn(str, processGigabytesColor, buffer, len);
+      RichString_appendnAscii(str, processGigabytesColor, buffer, len);
    } else if (number < 10000ULL * ONE_M) {
       //1 digit TB, 3 digit GB
       number /= ONE_M;
       len = xSnprintf(buffer, sizeof(buffer), "%1llu", number/1000);
-      RichString_appendn(str, largeNumberColor, buffer, len);
+      RichString_appendnAscii(str, largeNumberColor, buffer, len);
       number %= 1000;
       len = xSnprintf(buffer, sizeof(buffer), "%03lluG ", number);
-      RichString_appendn(str, processGigabytesColor, buffer, len);
+      RichString_appendnAscii(str, processGigabytesColor, buffer, len);
    } else {
       //2 digit TB and above
       len = xSnprintf(buffer, sizeof(buffer), "%4.1lfT ", (double)number/ONE_G);
-      RichString_appendn(str, largeNumberColor, buffer, len);
+      RichString_appendnAscii(str, largeNumberColor, buffer, len);
    }
 }
 
@@ -139,26 +139,25 @@ void Process_colorNumber(RichString* str, unsigned long long number, bool colori
    }
 
    if (number == ULLONG_MAX) {
-      int len = xSnprintf(buffer, sizeof(buffer), "        N/A ");
-      RichString_appendn(str, CRT_colors[PROCESS_SHADOW], buffer, len);
+      RichString_appendAscii(str, CRT_colors[PROCESS_SHADOW], "        N/A ");
    } else if (number >= 100000LL * ONE_DECIMAL_T) {
       xSnprintf(buffer, sizeof(buffer), "%11llu ", number / ONE_DECIMAL_G);
-      RichString_appendn(str, largeNumberColor, buffer, 12);
+      RichString_appendnAscii(str, largeNumberColor, buffer, 12);
    } else if (number >= 100LL * ONE_DECIMAL_T) {
       xSnprintf(buffer, sizeof(buffer), "%11llu ", number / ONE_DECIMAL_M);
-      RichString_appendn(str, largeNumberColor, buffer, 8);
-      RichString_appendn(str, processMegabytesColor, buffer+8, 4);
+      RichString_appendnAscii(str, largeNumberColor, buffer, 8);
+      RichString_appendnAscii(str, processMegabytesColor, buffer+8, 4);
    } else if (number >= 10LL * ONE_DECIMAL_G) {
       xSnprintf(buffer, sizeof(buffer), "%11llu ", number / ONE_DECIMAL_K);
-      RichString_appendn(str, largeNumberColor, buffer, 5);
-      RichString_appendn(str, processMegabytesColor, buffer+5, 3);
-      RichString_appendn(str, processColor, buffer+8, 4);
+      RichString_appendnAscii(str, largeNumberColor, buffer, 5);
+      RichString_appendnAscii(str, processMegabytesColor, buffer+5, 3);
+      RichString_appendnAscii(str, processColor, buffer+8, 4);
    } else {
       xSnprintf(buffer, sizeof(buffer), "%11llu ", number);
-      RichString_appendn(str, largeNumberColor, buffer, 2);
-      RichString_appendn(str, processMegabytesColor, buffer+2, 3);
-      RichString_appendn(str, processColor, buffer+5, 3);
-      RichString_appendn(str, processShadowColor, buffer+8, 4);
+      RichString_appendnAscii(str, largeNumberColor, buffer, 2);
+      RichString_appendnAscii(str, processMegabytesColor, buffer+2, 3);
+      RichString_appendnAscii(str, processColor, buffer+5, 3);
+      RichString_appendnAscii(str, processShadowColor, buffer+8, 4);
    }
 }
 
@@ -172,16 +171,16 @@ void Process_printTime(RichString* str, unsigned long long totalHundredths) {
    char buffer[10];
    if (hours >= 100) {
       xSnprintf(buffer, sizeof(buffer), "%7lluh ", hours);
-      RichString_append(str, CRT_colors[LARGE_NUMBER], buffer);
+      RichString_appendAscii(str, CRT_colors[LARGE_NUMBER], buffer);
    } else {
       if (hours) {
          xSnprintf(buffer, sizeof(buffer), "%2lluh", hours);
-         RichString_append(str, CRT_colors[LARGE_NUMBER], buffer);
+         RichString_appendAscii(str, CRT_colors[LARGE_NUMBER], buffer);
          xSnprintf(buffer, sizeof(buffer), "%02d:%02d ", minutes, seconds);
       } else {
          xSnprintf(buffer, sizeof(buffer), "%2d:%02d.%02d ", minutes, seconds, hundredths);
       }
-      RichString_append(str, CRT_colors[DEFAULT_COLOR], buffer);
+      RichString_appendAscii(str, CRT_colors[DEFAULT_COLOR], buffer);
    }
 }
 
@@ -216,7 +215,7 @@ static inline void Process_writeCommand(const Process* this, int attr, int basea
       finish += start - 1;
    }
 
-   RichString_append(str, attr, comm);
+   RichString_appendWide(str, attr, comm);
 
    if (this->settings->highlightBaseName) {
       RichString_setAttrn(str, baseattr, start, finish);
@@ -234,23 +233,22 @@ void Process_outputRate(RichString* str, char* buffer, size_t n, double rate, in
    }
 
    if (isnan(rate)) {
-      int len = xSnprintf(buffer, n, "        N/A ");
-      RichString_appendn(str, CRT_colors[PROCESS_SHADOW], buffer, len);
+      RichString_appendAscii(str, CRT_colors[PROCESS_SHADOW], "        N/A ");
    } else if (rate < ONE_K) {
       int len = snprintf(buffer, n, "%7.2f B/s ", rate);
-      RichString_appendn(str, processColor, buffer, len);
+      RichString_appendnAscii(str, processColor, buffer, len);
    } else if (rate < ONE_M) {
       int len = snprintf(buffer, n, "%7.2f K/s ", rate / ONE_K);
-      RichString_appendn(str, processColor, buffer, len);
+      RichString_appendnAscii(str, processColor, buffer, len);
    } else if (rate < ONE_G) {
       int len = snprintf(buffer, n, "%7.2f M/s ", rate / ONE_M);
-      RichString_appendn(str, processMegabytesColor, buffer, len);
+      RichString_appendnAscii(str, processMegabytesColor, buffer, len);
    } else if (rate < ONE_T) {
       int len = snprintf(buffer, n, "%7.2f G/s ", rate / ONE_G);
-      RichString_appendn(str, largeNumberColor, buffer, len);
+      RichString_appendnAscii(str, largeNumberColor, buffer, len);
    } else {
       int len = snprintf(buffer, n, "%7.2f T/s ", rate / ONE_T);
-      RichString_appendn(str, largeNumberColor, buffer, len);
+      RichString_appendnAscii(str, largeNumberColor, buffer, len);
    }
 }
 
@@ -322,7 +320,7 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
          }
          const char* draw = CRT_treeStr[lastItem ? (this->settings->direction == 1 ? TREE_STR_BEND : TREE_STR_TEND) : TREE_STR_RTEE];
          xSnprintf(buf, n, "%s%s ", draw, this->showChildren ? CRT_treeStr[TREE_STR_SHUT] : CRT_treeStr[TREE_STR_OPEN] );
-         RichString_append(str, CRT_colors[PROCESS_TREE], buffer);
+         RichString_appendWide(str, CRT_colors[PROCESS_TREE], buffer);
          Process_writeCommand(this, attr, baseattr, str);
          return;
       }
@@ -386,7 +384,7 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
    default:
       xSnprintf(buffer, n, "- ");
    }
-   RichString_append(str, attr, buffer);
+   RichString_appendWide(str, attr, buffer);
 }
 
 void Process_display(const Object* cast, RichString* out) {
diff --git a/ProcessList.c b/ProcessList.c
index 2d273398..dc8f62cb 100644
--- a/ProcessList.c
+++ b/ProcessList.c
@@ -92,9 +92,9 @@ void ProcessList_printHeader(ProcessList* this, RichString* header) {
 
       int color = (this->settings->sortKey == fields[i]) ?
          CRT_colors[PANEL_SELECTION_FOCUS] : CRT_colors[PANEL_HEADER_FOCUS];
-      RichString_append(header, color, field);
+      RichString_appendWide(header, color, field);
       if (COMM == fields[i] && this->settings->showMergedCommand) {
-         RichString_append(header, color, "(merged)");
+         RichString_appendAscii(header, color, "(merged)");
       }
    }
 }
diff --git a/RichString.c b/RichString.c
index 790c15a9..5dc7ada8 100644
--- a/RichString.c
+++ b/RichString.c
@@ -7,6 +7,7 @@ in the source distribution for its full text.
 
 #include "RichString.h"
 
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -47,7 +48,7 @@ static void RichString_setLen(RichString* this, int len) {
 
 #ifdef HAVE_LIBNCURSESW
 
-static inline void RichString_writeFrom(RichString* this, int attrs, const char* data_c, int from, int len) {
+static inline void RichString_writeFromWide(RichString* this, int attrs, const char* data_c, int from, int len) {
    wchar_t data[len + 1];
    len = mbstowcs(data, data_c, len);
    if (len < 0)
@@ -60,6 +61,14 @@ static inline void RichString_writeFrom(RichString* this, int attrs, const char*
    }
 }
 
+static inline void RichString_writeFromAscii(RichString* this, int attrs, const char* data, int from, int len) {
+   int newLen = from + len;
+   RichString_setLen(this, newLen);
+   for (int i = from, j = 0; i < newLen; i++, j++) {
+      this->chptr[i] = (CharType) { .attr = attrs & 0xffffff, .chars = { (isprint(data[j]) ? data[j] : '?') } };
+   }
+}
+
 inline void RichString_setAttrn(RichString* this, int attrs, int start, int finish) {
    cchar_t* ch = this->chptr + start;
    finish = CLAMP(finish, 0, this->chlen - 1);
@@ -82,7 +91,7 @@ int RichString_findChar(RichString* this, char c, int start) {
 
 #else /* HAVE_LIBNCURSESW */
 
-static inline void RichString_writeFrom(RichString* this, int attrs, const char* data_c, int from, int len) {
+static inline void RichString_writeFromWide(RichString* this, int attrs, const char* data_c, int from, int len) {
    int newLen = from + len;
    RichString_setLen(this, newLen);
    for (int i = from, j = 0; i < newLen; i++, j++) {
@@ -91,6 +100,10 @@ static inline void RichString_writeFrom(RichString* this, int attrs, const char*
    this->chptr[newLen] = 0;
 }
 
+static inline void RichString_writeFromAscii(RichString* this, int attrs, const char* data_c, int from, int len) {
+   RichString_writeFromWide(this, attrs, data_c, from, len);
+}
+
 void RichString_setAttrn(RichString* this, int attrs, int start, int finish) {
    chtype* ch = this->chptr + start;
    finish = CLAMP(finish, 0, this->chlen - 1);
@@ -132,14 +145,26 @@ void RichString_setAttr(RichString* this, int attrs) {
    RichString_setAttrn(this, attrs, 0, this->chlen - 1);
 }
 
-void RichString_append(RichString* this, int attrs, const char* data) {
-   RichString_writeFrom(this, attrs, data, this->chlen, strlen(data));
+void RichString_appendWide(RichString* this, int attrs, const char* data) {
+   RichString_writeFromWide(this, attrs, data, this->chlen, strlen(data));
 }
 
-void RichString_appendn(RichString* this, int attrs, const char* data, int len) {
-   RichString_writeFrom(this, attrs, data, this->chlen, len);
+void RichString_appendnWide(RichString* this, int attrs, const char* data, int len) {
+   RichString_writeFromWide(this, attrs, data, this->chlen, len);
 }
 
-void RichString_write(RichString* this, int attrs, const char* data) {
-   RichString_writeFrom(this, attrs, data, 0, strlen(data));
+void RichString_writeWide(RichString* this, int attrs, const char* data) {
+   RichString_writeFromWide(this, attrs, data, 0, strlen(data));
+}
+
+void RichString_appendAscii(RichString* this, int attrs, const char* data) {
+   RichString_writeFromAscii(this, attrs, data, this->chlen, strlen(data));
+}
+
+void RichString_appendnAscii(RichString* this, int attrs, const char* data, int len) {
+   RichString_writeFromAscii(this, attrs, data, this->chlen, len);
+}
+
+void RichString_writeAscii(RichString* this, int attrs, const char* data) {
+   RichString_writeFromAscii(this, attrs, data, 0, strlen(data));
 }
diff --git a/RichString.h b/RichString.h
index 262befc5..163a970d 100644
--- a/RichString.h
+++ b/RichString.h
@@ -52,10 +52,16 @@ void RichString_setAttr(RichString* this, int attrs);
 
 void RichString_appendChr(RichString* this, char c, int count);
 
-void RichString_append(RichString* this, int attrs, const char* data);
+void RichString_appendWide(RichString* this, int attrs, const char* data);
 
-void RichString_appendn(RichString* this, int attrs, const char* data, int len);
+void RichString_appendnWide(RichString* this, int attrs, const char* data, int len);
 
-void RichString_write(RichString* this, int attrs, const char* data);
+void RichString_writeWide(RichString* this, int attrs, const char* data);
+
+void RichString_appendAscii(RichString* this, int attrs, const char* data);
+
+void RichString_appendnAscii(RichString* this, int attrs, const char* data, int len);
+
+void RichString_writeAscii(RichString* this, int attrs, const char* data);
 
 #endif
diff --git a/SwapMeter.c b/SwapMeter.c
index fcc11c54..e39cfd9f 100644
--- a/SwapMeter.c
+++ b/SwapMeter.c
@@ -32,12 +32,12 @@ static void SwapMeter_updateValues(Meter* this, char* buffer, size_t size) {
 static void SwapMeter_display(const Object* cast, RichString* out) {
    char buffer[50];
    const Meter* this = (const Meter*)cast;
-   RichString_write(out, CRT_colors[METER_TEXT], ":");
+   RichString_writeAscii(out, CRT_colors[METER_TEXT], ":");
    Meter_humanUnit(buffer, this->total, sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_VALUE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
    Meter_humanUnit(buffer, this->values[0], sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_TEXT], " used:");
-   RichString_append(out, CRT_colors[METER_VALUE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " used:");
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
 }
 
 const MeterClass SwapMeter_class = {
diff --git a/TasksMeter.c b/TasksMeter.c
index 7696988a..a760ce07 100644
--- a/TasksMeter.c
+++ b/TasksMeter.c
@@ -46,7 +46,7 @@ static void TasksMeter_display(const Object* cast, RichString* out) {
    int processes = (int) this->values[2];
 
    xSnprintf(buffer, sizeof(buffer), "%d", processes);
-   RichString_write(out, CRT_colors[METER_VALUE], buffer);
+   RichString_writeAscii(out, CRT_colors[METER_VALUE], buffer);
    int threadValueColor = CRT_colors[METER_VALUE];
    int threadCaptionColor = CRT_colors[METER_TEXT];
    if (settings->highlightThreads) {
@@ -54,21 +54,21 @@ static void TasksMeter_display(const Object* cast, RichString* out) {
       threadCaptionColor = CRT_colors[PROCESS_THREAD];
    }
    if (!settings->hideUserlandThreads) {
-      RichString_append(out, CRT_colors[METER_TEXT], ", ");
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], ", ");
       xSnprintf(buffer, sizeof(buffer), "%d", (int)this->values[1]);
-      RichString_append(out, threadValueColor, buffer);
-      RichString_append(out, threadCaptionColor, " thr");
+      RichString_appendAscii(out, threadValueColor, buffer);
+      RichString_appendAscii(out, threadCaptionColor, " thr");
    }
    if (!settings->hideKernelThreads) {
-      RichString_append(out, CRT_colors[METER_TEXT], ", ");
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], ", ");
       xSnprintf(buffer, sizeof(buffer), "%d", (int)this->values[0]);
-      RichString_append(out, threadValueColor, buffer);
-      RichString_append(out, threadCaptionColor, " kthr");
+      RichString_appendAscii(out, threadValueColor, buffer);
+      RichString_appendAscii(out, threadCaptionColor, " kthr");
    }
-   RichString_append(out, CRT_colors[METER_TEXT], "; ");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], "; ");
    xSnprintf(buffer, sizeof(buffer), "%d", (int)this->values[3]);
-   RichString_append(out, CRT_colors[TASKS_RUNNING], buffer);
-   RichString_append(out, CRT_colors[METER_TEXT], " running");
+   RichString_appendAscii(out, CRT_colors[TASKS_RUNNING], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " running");
 }
 
 const MeterClass TasksMeter_class = {
diff --git a/dragonflybsd/DragonFlyBSDProcess.c b/dragonflybsd/DragonFlyBSDProcess.c
index 9311f03c..4ea66870 100644
--- a/dragonflybsd/DragonFlyBSDProcess.c
+++ b/dragonflybsd/DragonFlyBSDProcess.c
@@ -105,7 +105,7 @@ void DragonFlyBSDProcess_writeField(const Process* this, RichString* str, Proces
       Process_writeField(this, str, field);
       return;
    }
-   RichString_append(str, attr, buffer);
+   RichString_appendWide(str, attr, buffer);
 }
 
 long DragonFlyBSDProcess_compare(const void* v1, const void* v2) {
diff --git a/freebsd/FreeBSDProcess.c b/freebsd/FreeBSDProcess.c
index d6d67b75..1c670ae3 100644
--- a/freebsd/FreeBSDProcess.c
+++ b/freebsd/FreeBSDProcess.c
@@ -105,7 +105,7 @@ static void FreeBSDProcess_writeField(const Process* this, RichString* str, Proc
       Process_writeField(this, str, field);
       return;
    }
-   RichString_append(str, attr, buffer);
+   RichString_appendWide(str, attr, buffer);
 }
 
 static long FreeBSDProcess_compare(const void* v1, const void* v2) {
diff --git a/linux/LinuxProcess.c b/linux/LinuxProcess.c
index 8298000a..05626065 100644
--- a/linux/LinuxProcess.c
+++ b/linux/LinuxProcess.c
@@ -536,7 +536,7 @@ static void LinuxProcess_writeCommand(const Process* this, int attr, int baseAtt
    if(lp->procExeDeleted)
       baseAttr = CRT_colors[FAILED_READ];
 
-   RichString_append(str, attr, lp->mergedCommand.str);
+   RichString_appendWide(str, attr, lp->mergedCommand.str);
 
    if (lp->mergedCommand.commEnd) {
       if (!lp->mergedCommand.separateComm && commStart == baseStart && highlightBaseName) {
@@ -608,7 +608,7 @@ static void LinuxProcess_writeCommandField(const Process *this, RichString *str,
       n -= (buf - buffer);
       const char* draw = CRT_treeStr[lastItem ? (this->settings->direction == 1 ? TREE_STR_BEND : TREE_STR_TEND) : TREE_STR_RTEE];
       xSnprintf(buf, n, "%s%s ", draw, this->showChildren ? CRT_treeStr[TREE_STR_SHUT] : CRT_treeStr[TREE_STR_OPEN] );
-      RichString_append(str, CRT_colors[PROCESS_TREE], buffer);
+      RichString_appendWide(str, CRT_colors[PROCESS_TREE], buffer);
       LinuxProcess_writeCommand(this, attr, baseattr, str);
    }
 }
@@ -757,7 +757,7 @@ static void LinuxProcess_writeField(const Process* this, RichString* str, Proces
       Process_writeField(this, str, field);
       return;
    }
-   RichString_append(str, attr, buffer);
+   RichString_appendWide(str, attr, buffer);
 }
 
 static long LinuxProcess_compare(const void* v1, const void* v2) {
diff --git a/linux/PressureStallMeter.c b/linux/PressureStallMeter.c
index 745068c9..91ac562b 100644
--- a/linux/PressureStallMeter.c
+++ b/linux/PressureStallMeter.c
@@ -50,11 +50,11 @@ static void PressureStallMeter_display(const Object* cast, RichString* out) {
    const Meter* this = (const Meter*)cast;
    char buffer[20];
    xSnprintf(buffer, sizeof(buffer), "%.2lf%% ", this->values[0]);
-   RichString_write(out, CRT_colors[PRESSURE_STALL_TEN], buffer);
+   RichString_writeAscii(out, CRT_colors[PRESSURE_STALL_TEN], buffer);
    xSnprintf(buffer, sizeof(buffer), "%.2lf%% ", this->values[1]);
-   RichString_append(out, CRT_colors[PRESSURE_STALL_SIXTY], buffer);
+   RichString_appendAscii(out, CRT_colors[PRESSURE_STALL_SIXTY], buffer);
    xSnprintf(buffer, sizeof(buffer), "%.2lf%% ", this->values[2]);
-   RichString_append(out, CRT_colors[PRESSURE_STALL_THREEHUNDRED], buffer);
+   RichString_appendAscii(out, CRT_colors[PRESSURE_STALL_THREEHUNDRED], buffer);
 }
 
 const MeterClass PressureStallCPUSomeMeter_class = {
diff --git a/linux/SystemdMeter.c b/linux/SystemdMeter.c
index 4350d264..61bb59b3 100644
--- a/linux/SystemdMeter.c
+++ b/linux/SystemdMeter.c
@@ -267,9 +267,9 @@ static void SystemdMeter_display(ATTR_UNUSED const Object* cast, RichString* out
    char buffer[16];
 
    int color = (systemState && 0 == strcmp(systemState, "running")) ? METER_VALUE_OK : METER_VALUE_ERROR;
-   RichString_write(out, CRT_colors[color], systemState ? systemState : "???");
+   RichString_writeAscii(out, CRT_colors[color], systemState ? systemState : "N/A");
 
-   RichString_append(out, CRT_colors[METER_TEXT], " (");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " (");
 
    if (nFailedUnits == INVALID_VALUE) {
       buffer[0] = '?';
@@ -277,9 +277,9 @@ static void SystemdMeter_display(ATTR_UNUSED const Object* cast, RichString* out
    } else {
       xSnprintf(buffer, sizeof(buffer), "%u", nFailedUnits);
    }
-   RichString_append(out, zeroDigitColor(nFailedUnits), buffer);
+   RichString_appendAscii(out, zeroDigitColor(nFailedUnits), buffer);
 
-   RichString_append(out, CRT_colors[METER_TEXT], "/");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], "/");
 
    if (nNames == INVALID_VALUE) {
       buffer[0] = '?';
@@ -287,9 +287,9 @@ static void SystemdMeter_display(ATTR_UNUSED const Object* cast, RichString* out
    } else {
       xSnprintf(buffer, sizeof(buffer), "%u", nNames);
    }
-   RichString_append(out, valueDigitColor(nNames), buffer);
+   RichString_appendAscii(out, valueDigitColor(nNames), buffer);
 
-   RichString_append(out, CRT_colors[METER_TEXT], " failed) (");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " failed) (");
 
    if (nJobs == INVALID_VALUE) {
       buffer[0] = '?';
@@ -297,9 +297,9 @@ static void SystemdMeter_display(ATTR_UNUSED const Object* cast, RichString* out
    } else {
       xSnprintf(buffer, sizeof(buffer), "%u", nJobs);
    }
-   RichString_append(out, zeroDigitColor(nJobs), buffer);
+   RichString_appendAscii(out, zeroDigitColor(nJobs), buffer);
 
-   RichString_append(out, CRT_colors[METER_TEXT], "/");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], "/");
 
    if (nInstalledJobs == INVALID_VALUE) {
       buffer[0] = '?';
@@ -307,9 +307,9 @@ static void SystemdMeter_display(ATTR_UNUSED const Object* cast, RichString* out
    } else {
       xSnprintf(buffer, sizeof(buffer), "%u", nInstalledJobs);
    }
-   RichString_append(out, valueDigitColor(nInstalledJobs), buffer);
+   RichString_appendAscii(out, valueDigitColor(nInstalledJobs), buffer);
 
-   RichString_append(out, CRT_colors[METER_TEXT], " jobs)");
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " jobs)");
 }
 
 static const int SystemdMeter_attributes[] = {
diff --git a/linux/ZramMeter.c b/linux/ZramMeter.c
index e6b6937e..723de0ac 100644
--- a/linux/ZramMeter.c
+++ b/linux/ZramMeter.c
@@ -37,17 +37,19 @@ static void ZramMeter_updateValues(Meter* this, char* buffer, size_t size) {
 static void ZramMeter_display(const Object* cast, RichString* out) {
    char buffer[50];
    const Meter* this = (const Meter*)cast;
-   RichString_write(out, CRT_colors[METER_TEXT], ":");
-   Meter_humanUnit(buffer, this->total, sizeof(buffer));
 
-   RichString_append(out, CRT_colors[METER_VALUE], buffer);
+   RichString_writeAscii(out, CRT_colors[METER_TEXT], ":");
+
+   Meter_humanUnit(buffer, this->total, sizeof(buffer));
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+
    Meter_humanUnit(buffer, this->values[0], sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_TEXT], " used:");
-   RichString_append(out, CRT_colors[METER_VALUE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " used:");
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
 
    Meter_humanUnit(buffer, this->values[1], sizeof(buffer));
-   RichString_append(out, CRT_colors[METER_TEXT], " uncompressed:");
-   RichString_append(out, CRT_colors[METER_VALUE], buffer);
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " uncompressed:");
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
 }
 
 const MeterClass ZramMeter_class = {
diff --git a/openbsd/OpenBSDProcess.c b/openbsd/OpenBSDProcess.c
index df5002ac..9aab53e5 100644
--- a/openbsd/OpenBSDProcess.c
+++ b/openbsd/OpenBSDProcess.c
@@ -209,7 +209,7 @@ static void OpenBSDProcess_writeField(const Process* this, RichString* str, Proc
       Process_writeField(this, str, field);
       return;
    }
-   RichString_append(str, attr, buffer);
+   RichString_appendWide(str, attr, buffer);
 }
 
 static long OpenBSDProcess_compare(const void* v1, const void* v2) {
diff --git a/solaris/SolarisProcess.c b/solaris/SolarisProcess.c
index e0a3db24..e69809c2 100644
--- a/solaris/SolarisProcess.c
+++ b/solaris/SolarisProcess.c
@@ -114,7 +114,7 @@ void SolarisProcess_writeField(const Process* this, RichString* str, ProcessFiel
       Process_writeField(this, str, field);
       return;
    }
-   RichString_append(str, attr, buffer);
+   RichString_appendWide(str, attr, buffer);
 }
 
 long SolarisProcess_compare(const void* v1, const void* v2) {
diff --git a/zfs/ZfsArcMeter.c b/zfs/ZfsArcMeter.c
index ddc239e3..91dfc713 100644
--- a/zfs/ZfsArcMeter.c
+++ b/zfs/ZfsArcMeter.c
@@ -51,28 +51,28 @@ static void ZfsArcMeter_display(const Object* cast, RichString* out) {
    if (this->values[5] > 0) {
       char buffer[50];
       Meter_humanUnit(buffer, this->total, sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_VALUE], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
       Meter_humanUnit(buffer, this->values[5], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_TEXT], " Used:");
-      RichString_append(out, CRT_colors[METER_VALUE], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Used:");
+      RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
       Meter_humanUnit(buffer, this->values[0], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_TEXT], " MFU:");
-      RichString_append(out, CRT_colors[ZFS_MFU], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " MFU:");
+      RichString_appendAscii(out, CRT_colors[ZFS_MFU], buffer);
       Meter_humanUnit(buffer, this->values[1], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_TEXT], " MRU:");
-      RichString_append(out, CRT_colors[ZFS_MRU], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " MRU:");
+      RichString_appendAscii(out, CRT_colors[ZFS_MRU], buffer);
       Meter_humanUnit(buffer, this->values[2], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_TEXT], " Anon:");
-      RichString_append(out, CRT_colors[ZFS_ANON], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Anon:");
+      RichString_appendAscii(out, CRT_colors[ZFS_ANON], buffer);
       Meter_humanUnit(buffer, this->values[3], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_TEXT], " Hdr:");
-      RichString_append(out, CRT_colors[ZFS_HEADER], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Hdr:");
+      RichString_appendAscii(out, CRT_colors[ZFS_HEADER], buffer);
       Meter_humanUnit(buffer, this->values[4], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_TEXT], " Oth:");
-      RichString_append(out, CRT_colors[ZFS_OTHER], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Oth:");
+      RichString_appendAscii(out, CRT_colors[ZFS_OTHER], buffer);
    } else {
-      RichString_write(out, CRT_colors[METER_TEXT], " ");
-      RichString_append(out, CRT_colors[FAILED_SEARCH], "Unavailable");
+      RichString_writeAscii(out, CRT_colors[METER_TEXT], " ");
+      RichString_appendAscii(out, CRT_colors[FAILED_SEARCH], "Unavailable");
    }
 }
 
diff --git a/zfs/ZfsCompressedArcMeter.c b/zfs/ZfsCompressedArcMeter.c
index 224c6144..92d82e99 100644
--- a/zfs/ZfsCompressedArcMeter.c
+++ b/zfs/ZfsCompressedArcMeter.c
@@ -48,17 +48,17 @@ static void ZfsCompressedArcMeter_display(const Object* cast, RichString* out) {
    if (this->values[0] > 0) {
       char buffer[50];
       Meter_humanUnit(buffer, this->total, sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_VALUE], buffer);
-      RichString_append(out, CRT_colors[METER_TEXT], " Uncompressed, ");
+      RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Uncompressed, ");
       Meter_humanUnit(buffer, this->values[0], sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_VALUE], buffer);
-      RichString_append(out, CRT_colors[METER_TEXT], " Compressed, ");
+      RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Compressed, ");
       ZfsCompressedArcMeter_printRatioString(this, buffer, sizeof(buffer));
-      RichString_append(out, CRT_colors[METER_VALUE], buffer);
-      RichString_append(out, CRT_colors[METER_TEXT], " Ratio");
+      RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " Ratio");
    } else {
-      RichString_write(out, CRT_colors[METER_TEXT], " ");
-      RichString_append(out, CRT_colors[FAILED_SEARCH], "Compression Unavailable");
+      RichString_writeAscii(out, CRT_colors[METER_TEXT], " ");
+      RichString_appendAscii(out, CRT_colors[FAILED_SEARCH], "Compression Unavailable");
    }
 }