Index: uspace/lib/bithenge/src/helenos/common.h
===================================================================
--- uspace/lib/bithenge/src/helenos/common.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/bithenge/src/helenos/common.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -47,5 +47,5 @@
 	const char *string;
 	size_t offset;
-	wchar_t ch;
+	char32_t ch;
 } string_iterator_t;
 
@@ -64,5 +64,5 @@
 }
 
-static inline errno_t string_iterator_next(string_iterator_t *i, wchar_t *out)
+static inline errno_t string_iterator_next(string_iterator_t *i, char32_t *out)
 {
 	*out = i->ch;
Index: uspace/lib/bithenge/src/linux/common.h
===================================================================
--- uspace/lib/bithenge/src/linux/common.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/bithenge/src/linux/common.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -37,5 +37,5 @@
 #include <stdlib.h>
 #include <string.h>
-#include <wchar.h>
+#include <uchar.h>
 
 #define max(aleph, bet) ((aleph) > (bet) ? (aleph) : (bet))
@@ -55,8 +55,8 @@
 }
 
-static inline errno_t string_iterator_next(string_iterator_t *i, wchar_t *out)
+static inline errno_t string_iterator_next(string_iterator_t *i, char32_t *out)
 {
 	wint_t rc = btowc(*(*i)++); // TODO
-	*out = (wchar_t) rc;
+	*out = (char32_t) rc;
 	return rc == WEOF ? EILSEQ : EOK;
 }
@@ -72,5 +72,5 @@
 }
 
-static inline const char *str_chr(const char *string, wchar_t ch)
+static inline const char *str_chr(const char *string, char32_t ch)
 {
 	return strchr(string, wctob(ch)); // TODO
Index: uspace/lib/bithenge/src/print.c
===================================================================
--- uspace/lib/bithenge/src/print.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/bithenge/src/print.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -40,5 +40,5 @@
 #include <stdarg.h>
 #include <stdio.h>
-#include <wchar.h>
+#include <uchar.h>
 #include <bithenge/blob.h>
 #include <bithenge/print.h>
@@ -164,5 +164,5 @@
 	string_iterator_t i = string_iterator(value);
 	while (!string_iterator_done(&i)) {
-		wchar_t ch;
+		char32_t ch;
 		errno_t rc = string_iterator_next(&i, &ch);
 		if (rc != EOK)
Index: uspace/lib/c/generic/io/asprintf.c
===================================================================
--- uspace/lib/c/generic/io/asprintf.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/asprintf.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -46,5 +46,5 @@
 }
 
-static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused)
+static int asprintf_wstr_write(const char32_t *str, size_t count, void *unused)
 {
 	return wstr_nlength(str, count);
Index: uspace/lib/c/generic/io/chargrid.c
===================================================================
--- uspace/lib/c/generic/io/chargrid.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/chargrid.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -140,5 +140,5 @@
  *
  */
-sysarg_t chargrid_putwchar(chargrid_t *scrbuf, wchar_t ch, bool update)
+sysarg_t chargrid_putuchar(chargrid_t *scrbuf, char32_t ch, bool update)
 {
 	assert(scrbuf->col < scrbuf->cols);
@@ -199,5 +199,5 @@
 
 	for (sysarg_t i = 0; i < spaces; i++)
-		flush += chargrid_putwchar(scrbuf, ' ', true) - 1;
+		flush += chargrid_putuchar(scrbuf, ' ', true) - 1;
 
 	return flush;
@@ -228,10 +228,10 @@
 		scrbuf->row--;
 
-		chargrid_putwchar(scrbuf, ' ', false);
+		chargrid_putuchar(scrbuf, ' ', false);
 		return 2;
 	}
 
 	scrbuf->col--;
-	chargrid_putwchar(scrbuf, ' ', false);
+	chargrid_putuchar(scrbuf, ' ', false);
 	return 1;
 }
Index: uspace/lib/c/generic/io/input.c
===================================================================
--- uspace/lib/c/generic/io/input.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/input.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -109,5 +109,5 @@
 	keycode_t key;
 	keymod_t mods;
-	wchar_t c;
+	char32_t c;
 	errno_t rc;
 
Index: uspace/lib/c/generic/io/io.c
===================================================================
--- uspace/lib/c/generic/io/io.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/io.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -48,4 +48,5 @@
 #include <adt/list.h>
 #include <wchar.h>
+#include <uchar.h>
 #include "../private/io.h"
 #include "../private/stdio.h"
@@ -749,7 +750,29 @@
 }
 
+wint_t fputuc(char32_t wc, FILE *stream)
+{
+	char buf[STR_BOUNDS(1)];
+	size_t sz = 0;
+
+	if (chr_encode(wc, buf, &sz, STR_BOUNDS(1)) != EOK) {
+		errno = EILSEQ;
+		return WEOF;
+	}
+
+	size_t wr = fwrite(buf, 1, sz, stream);
+	if (wr < sz)
+		return WEOF;
+
+	return wc;
+}
+
 wint_t putwchar(wchar_t wc)
 {
 	return fputwc(wc, stdout);
+}
+
+wint_t putuchar(char32_t wc)
+{
+	return fputuc(wc, stdout);
 }
 
Index: uspace/lib/c/generic/io/kio.c
===================================================================
--- uspace/lib/c/generic/io/kio.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/kio.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -140,5 +140,5 @@
 }
 
-static int kio_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
+static int kio_vprintf_wstr_write(const char32_t *str, size_t size, void *data)
 {
 	size_t offset = 0;
@@ -154,5 +154,5 @@
 
 		chars++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
Index: uspace/lib/c/generic/io/printf_core.c
===================================================================
--- uspace/lib/c/generic/io/printf_core.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/printf_core.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -47,5 +47,5 @@
 #include <assert.h>
 #include <macros.h>
-#include <wchar.h>
+#include <uchar.h>
 
 /** show prefixes 0x or 0 */
@@ -187,5 +187,5 @@
  *
  */
-static int printf_wputnchars(const wchar_t *buf, size_t size,
+static int printf_wputnchars(const char32_t *buf, size_t size,
     printf_spec_t *ps)
 {
@@ -233,10 +233,10 @@
  *
  */
-static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
+static int printf_putuchar(const char32_t ch, printf_spec_t *ps)
 {
 	if (!chr_check(ch))
 		return ps->str_write((void *) &invalch, 1, ps->data);
 
-	return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
+	return ps->wstr_write(&ch, sizeof(char32_t), ps->data);
 }
 
@@ -288,5 +288,5 @@
  *
  */
-static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
+static int print_wchar(const char32_t ch, int width, uint32_t flags, printf_spec_t *ps)
 {
 	size_t counter = 0;
@@ -302,5 +302,5 @@
 	}
 
-	if (printf_putwchar(ch, ps) > 0)
+	if (printf_putuchar(ch, ps) > 0)
 		counter++;
 
@@ -375,5 +375,5 @@
  * @return Number of wide characters printed, negative value on failure.
  */
-static int print_wstr(wchar_t *str, int width, unsigned int precision,
+static int print_wstr(char32_t *str, int width, unsigned int precision,
     uint32_t flags, printf_spec_t *ps)
 {
@@ -1276,5 +1276,5 @@
  *  - "l"  Signed or unsigned long int.@n
  *         If conversion is "c", the character is wint_t (wide character).@n
- *         If conversion is "s", the string is wchar_t * (wide string).@n
+ *         If conversion is "s", the string is char32_t * (wide string).@n
  *  - "ll" Signed or unsigned long long int.@n
  *  - "z"  Signed or unsigned ssize_t or site_t.@n
@@ -1330,5 +1330,5 @@
 	while (true) {
 		i = nxt;
-		wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+		char32_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
 
 		if (uc == 0)
@@ -1493,5 +1493,5 @@
 
 				if (qualifier == PrintfQualifierLong)
-					retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
+					retval = print_wstr(va_arg(ap, char32_t *), width, precision, flags, ps);
 				else
 					retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
Index: uspace/lib/c/generic/io/vprintf.c
===================================================================
--- uspace/lib/c/generic/io/vprintf.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/vprintf.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -48,5 +48,5 @@
 }
 
-static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream)
+static int vprintf_wstr_write(const char32_t *str, size_t size, void *stream)
 {
 	size_t offset = 0;
@@ -54,9 +54,9 @@
 
 	while (offset < size) {
-		if (fputwc(str[chars], (FILE *) stream) <= 0)
+		if (fputuc(str[chars], (FILE *) stream) <= 0)
 			break;
 
 		chars++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
Index: uspace/lib/c/generic/io/vsnprintf.c
===================================================================
--- uspace/lib/c/generic/io/vsnprintf.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/io/vsnprintf.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -88,5 +88,5 @@
 
 		while (index < size) {
-			wchar_t uc = str_decode(str, &index, size);
+			char32_t uc = str_decode(str, &index, size);
 
 			if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK)
@@ -133,9 +133,9 @@
  *
  */
-static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
+static int vsnprintf_wstr_write(const char32_t *str, size_t size, vsnprintf_data_t *data)
 {
 	size_t index = 0;
 
-	while (index < (size / sizeof(wchar_t))) {
+	while (index < (size / sizeof(char32_t))) {
 		size_t left = data->size - data->len;
 
@@ -177,5 +177,5 @@
 	printf_spec_t ps = {
 		(int (*) (const char *, size_t, void *)) vsnprintf_str_write,
-		(int (*) (const wchar_t *, size_t, void *)) vsnprintf_wstr_write,
+		(int (*) (const char32_t *, size_t, void *)) vsnprintf_wstr_write,
 		&data
 	};
Index: uspace/lib/c/generic/stdio/sstream.c
===================================================================
--- uspace/lib/c/generic/stdio/sstream.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/stdio/sstream.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -37,5 +37,5 @@
 #include <errno.h>
 #include <adt/list.h>
-#include <wchar.h>
+#include <uchar.h>
 #include "../private/stdio.h"
 #include "../private/sstream.h"
Index: uspace/lib/c/generic/str.c
===================================================================
--- uspace/lib/c/generic/str.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/generic/str.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -42,5 +42,5 @@
  * strings, called just strings are encoded in UTF-8. Wide strings (encoded
  * in UTF-32) are supported to a limited degree. A single character is
- * represented as wchar_t.@n
+ * represented as char32_t.@n
  *
  * Overview of the terminology:@n
@@ -50,6 +50,6 @@
  *  byte                  8 bits stored in uint8_t (unsigned 8 bit integer)
  *
- *  character             UTF-32 encoded Unicode character, stored in wchar_t
- *                        (signed 32 bit integer), code points 0 .. 1114111
+ *  character             UTF-32 encoded Unicode character, stored in char32_t
+ *                        (unsigned 32 bit integer), code points 0 .. 1114111
  *                        are valid
  *
@@ -61,5 +61,5 @@
  *
  *  wide string           UTF-32 encoded NULL-terminated Unicode string,
- *                        wchar_t *
+ *                        char32_t *
  *
  *  [wide] string size    number of BYTES in a [wide] string (excluding
@@ -100,5 +100,5 @@
  * A specific character inside a [wide] string can be referred to by:@n
  *
- *  pointer (char *, wchar_t *)
+ *  pointer (char *, char32_t *)
  *  byte offset (size_t)
  *  character index (size_t)
@@ -119,11 +119,4 @@
 #include <mem.h>
 
-/** Check the condition if wchar_t is signed */
-#ifdef __WCHAR_UNSIGNED__
-#define WCHAR_SIGNED_CHECK(cond)  (true)
-#else
-#define WCHAR_SIGNED_CHECK(cond)  (cond)
-#endif
-
 /** Byte mask consisting of lowest @n bits (out of 8) */
 #define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
@@ -153,5 +146,5 @@
  *
  */
-wchar_t str_decode(const char *str, size_t *offset, size_t size)
+char32_t str_decode(const char *str, size_t *offset, size_t size)
 {
 	if (*offset + 1 > size)
@@ -190,5 +183,5 @@
 		return U_SPECIAL;
 
-	wchar_t ch = b0 & LO_MASK_8(b0_bits);
+	char32_t ch = b0 & LO_MASK_8(b0_bits);
 
 	/* Decode continuation bytes */
@@ -201,5 +194,5 @@
 
 		/* Shift data bits to ch */
-		ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
+		ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
 		cbytes--;
 	}
@@ -223,5 +216,5 @@
  *
  */
-wchar_t str_decode_reverse(const char *str, size_t *offset, size_t size)
+char32_t str_decode_reverse(const char *str, size_t *offset, size_t size)
 {
 	if (*offset == 0)
@@ -266,5 +259,5 @@
  *         code was invalid.
  */
-errno_t chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
+errno_t chr_encode(const char32_t ch, char *str, size_t *offset, size_t size)
 {
 	if (*offset >= size)
@@ -352,7 +345,7 @@
  *
  */
-size_t wstr_size(const wchar_t *str)
-{
-	return (wstr_length(str) * sizeof(wchar_t));
+size_t wstr_size(const char32_t *str)
+{
+	return (wstr_length(str) * sizeof(char32_t));
 }
 
@@ -417,7 +410,7 @@
  *
  */
-size_t wstr_nsize(const wchar_t *str, size_t max_size)
-{
-	return (wstr_nlength(str, max_size) * sizeof(wchar_t));
+size_t wstr_nsize(const char32_t *str, size_t max_size)
+{
+	return (wstr_nlength(str, max_size) * sizeof(char32_t));
 }
 
@@ -435,7 +428,7 @@
  *
  */
-size_t wstr_lsize(const wchar_t *str, size_t max_len)
-{
-	return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
+size_t wstr_lsize(const char32_t *str, size_t max_len)
+{
+	return (wstr_nlength(str, max_len * sizeof(char32_t)) * sizeof(char32_t));
 }
 
@@ -465,5 +458,5 @@
  *
  */
-size_t wstr_length(const wchar_t *wstr)
+size_t wstr_length(const char32_t *wstr)
 {
 	size_t len = 0;
@@ -502,13 +495,13 @@
  *
  */
-size_t wstr_nlength(const wchar_t *str, size_t size)
+size_t wstr_nlength(const char32_t *str, size_t size)
 {
 	size_t len = 0;
-	size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
+	size_t limit = ALIGN_DOWN(size, sizeof(char32_t));
 	size_t offset = 0;
 
 	while ((offset < limit) && (*str++ != 0)) {
 		len++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
@@ -521,5 +514,5 @@
  * @return	Width of character in cells.
  */
-size_t chr_width(wchar_t ch)
+size_t chr_width(char32_t ch)
 {
 	return 1;
@@ -535,5 +528,5 @@
 	size_t width = 0;
 	size_t offset = 0;
-	wchar_t ch;
+	char32_t ch;
 
 	while ((ch = str_decode(str, &offset, STR_NO_LIMIT)) != 0)
@@ -548,7 +541,7 @@
  *
  */
-bool ascii_check(wchar_t ch)
-{
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
+bool ascii_check(char32_t ch)
+{
+	if (ch <= 127)
 		return true;
 
@@ -561,7 +554,7 @@
  *
  */
-bool chr_check(wchar_t ch)
-{
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
+bool chr_check(char32_t ch)
+{
+	if (ch <= 1114111)
 		return true;
 
@@ -589,6 +582,6 @@
 int str_cmp(const char *s1, const char *s2)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -636,6 +629,6 @@
 int str_lcmp(const char *s1, const char *s2, size_t max_len)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -688,6 +681,6 @@
 int str_casecmp(const char *s1, const char *s2)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -736,6 +729,6 @@
 int str_lcasecmp(const char *s1, const char *s2, size_t max_len)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -780,6 +773,6 @@
 bool str_test_prefix(const char *s, const char *p)
 {
-	wchar_t c1 = 0;
-	wchar_t c2 = 0;
+	char32_t c1 = 0;
+	char32_t c2 = 0;
 
 	size_t off1 = 0;
@@ -850,5 +843,5 @@
 	size_t dest_off = 0;
 
-	wchar_t ch;
+	char32_t ch;
 	while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
 		if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
@@ -883,5 +876,5 @@
 	size_t dest_off = 0;
 
-	wchar_t ch;
+	char32_t ch;
 	while ((ch = str_decode(src, &src_off, n)) != 0) {
 		if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
@@ -987,7 +980,7 @@
  * @param src	Source wide string.
  */
-void wstr_to_str(char *dest, size_t size, const wchar_t *src)
-{
-	wchar_t ch;
+void wstr_to_str(char *dest, size_t size, const char32_t *src)
+{
+	char32_t ch;
 	size_t src_idx;
 	size_t dest_off;
@@ -1022,5 +1015,5 @@
 {
 	size_t idx = 0, dest_off = 0;
-	wchar_t ch;
+	char32_t ch;
 	errno_t rc = EOK;
 
@@ -1066,5 +1059,5 @@
 	size_t offset = 0;
 	size_t idx = 0;
-	wchar_t c;
+	char32_t c;
 
 	assert(dlen > 0);
@@ -1123,9 +1116,9 @@
  * @return	New string.
  */
-char *wstr_to_astr(const wchar_t *src)
+char *wstr_to_astr(const char32_t *src)
 {
 	char dbuf[STR_BOUNDS(1)];
 	char *str;
-	wchar_t ch;
+	char32_t ch;
 
 	size_t src_idx;
@@ -1173,9 +1166,9 @@
  * @param src	Source string.
  */
-void str_to_wstr(wchar_t *dest, size_t dlen, const char *src)
+void str_to_wstr(char32_t *dest, size_t dlen, const char *src)
 {
 	size_t offset;
 	size_t di;
-	wchar_t c;
+	char32_t c;
 
 	assert(dlen > 0);
@@ -1202,9 +1195,9 @@
  * @param src	Source string.
  */
-wchar_t *str_to_awstr(const char *str)
+char32_t *str_to_awstr(const char *str)
 {
 	size_t len = str_length(str);
 
-	wchar_t *wstr = calloc(len + 1, sizeof(wchar_t));
+	char32_t *wstr = calloc(len + 1, sizeof(char32_t));
 	if (wstr == NULL)
 		return NULL;
@@ -1221,7 +1214,7 @@
  * @return Pointer to character in @a str or NULL if not found.
  */
-char *str_chr(const char *str, wchar_t ch)
-{
-	wchar_t acc;
+char *str_chr(const char *str, char32_t ch)
+{
+	char32_t acc;
 	size_t off = 0;
 	size_t last = 0;
@@ -1263,9 +1256,9 @@
  * @param ch  Character to remove.
  */
-void str_rtrim(char *str, wchar_t ch)
+void str_rtrim(char *str, char32_t ch)
 {
 	size_t off = 0;
 	size_t pos = 0;
-	wchar_t c;
+	char32_t c;
 	bool update_last_chunk = true;
 	char *last_chunk = NULL;
@@ -1291,7 +1284,7 @@
  * @param ch  Character to remove.
  */
-void str_ltrim(char *str, wchar_t ch)
-{
-	wchar_t acc;
+void str_ltrim(char *str, char32_t ch)
+{
+	char32_t acc;
 	size_t off = 0;
 	size_t pos = 0;
@@ -1319,7 +1312,7 @@
  * @return Pointer to character in @a str or NULL if not found.
  */
-char *str_rchr(const char *str, wchar_t ch)
-{
-	wchar_t acc;
+char *str_rchr(const char *str, char32_t ch)
+{
+	char32_t acc;
 	size_t off = 0;
 	size_t last = 0;
@@ -1349,5 +1342,5 @@
  *
  */
-bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
+bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos)
 {
 	size_t len = wstr_length(str);
@@ -1377,5 +1370,5 @@
  *
  */
-bool wstr_remove(wchar_t *str, size_t pos)
+bool wstr_remove(char32_t *str, size_t pos)
 {
 	size_t len = wstr_length(str);
@@ -1474,5 +1467,5 @@
 	size_t cur;
 	size_t tmp;
-	wchar_t ch;
+	char32_t ch;
 
 	/* Skip over leading delimiters. */
Index: uspace/lib/c/include/io/charfield.h
===================================================================
--- uspace/lib/c/include/io/charfield.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/io/charfield.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -38,5 +38,5 @@
 
 #include <stdbool.h>
-#include <wchar.h>
+#include <uchar.h>
 #include <io/color.h>
 #include <io/style.h>
@@ -77,5 +77,5 @@
 
 typedef struct {
-	wchar_t ch;
+	char32_t ch;
 	char_attrs_t attrs;
 	char_flags_t flags;
Index: uspace/lib/c/include/io/chargrid.h
===================================================================
--- uspace/lib/c/include/io/chargrid.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/io/chargrid.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -79,5 +79,5 @@
 extern sysarg_t chargrid_get_top_row(chargrid_t *);
 
-extern sysarg_t chargrid_putwchar(chargrid_t *, wchar_t, bool);
+extern sysarg_t chargrid_putuchar(chargrid_t *, char32_t, bool);
 extern sysarg_t chargrid_newline(chargrid_t *);
 extern sysarg_t chargrid_tabstop(chargrid_t *, sysarg_t);
Index: uspace/lib/c/include/io/input.h
===================================================================
--- uspace/lib/c/include/io/input.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/io/input.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -50,5 +50,5 @@
 	errno_t (*active)(input_t *);
 	errno_t (*deactive)(input_t *);
-	errno_t (*key)(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
+	errno_t (*key)(input_t *, kbd_event_type_t, keycode_t, keymod_t, char32_t);
 	errno_t (*move)(input_t *, int, int);
 	errno_t (*abs_move)(input_t *, unsigned, unsigned, unsigned, unsigned);
Index: uspace/lib/c/include/io/kbd_event.h
===================================================================
--- uspace/lib/c/include/io/kbd_event.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/io/kbd_event.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -59,5 +59,5 @@
 
 	/** The character that was generated or '\0' for none. */
-	wchar_t c;
+	char32_t c;
 } kbd_event_t;
 
Index: uspace/lib/c/include/io/printf_core.h
===================================================================
--- uspace/lib/c/include/io/printf_core.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/io/printf_core.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -38,4 +38,5 @@
 #include <stddef.h>
 #include <stdarg.h>
+#include <uchar.h>
 
 /** Structure for specifying output methods for different printf clones. */
@@ -45,5 +46,5 @@
 
 	/* Wide string output function, returns number of printed characters or EOF */
-	int (*wstr_write)(const wchar_t *, size_t, void *);
+	int (*wstr_write)(const char32_t *, size_t, void *);
 
 	/* User data - output stream specification, state, locks, etc. */
Index: uspace/lib/c/include/stdio.h
===================================================================
--- uspace/lib/c/include/stdio.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/stdio.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -42,4 +42,5 @@
 #include <_bits/size_t.h>
 #include <_bits/wchar_t.h>
+#include <_bits/uchar.h>
 #include <_bits/wint_t.h>
 #include <_bits/decls.h>
@@ -123,4 +124,7 @@
 extern wint_t fputwc(wchar_t, FILE *);
 extern wint_t putwchar(wchar_t);
+
+extern wint_t fputuc(char32_t, FILE *);
+extern wint_t putuchar(char32_t);
 
 /* Formatted string output functions */
Index: uspace/lib/c/include/stdlib.h
===================================================================
--- uspace/lib/c/include/stdlib.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/stdlib.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -38,4 +38,5 @@
 #include <_bits/size_t.h>
 #include <_bits/wchar_t.h>
+#include <_bits/uchar.h>
 #include <_bits/decls.h>
 #include <bsearch.h>
Index: uspace/lib/c/include/str.h
===================================================================
--- uspace/lib/c/include/str.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/include/str.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -67,28 +67,28 @@
 __HELENOS_DECLS_BEGIN;
 
-extern wchar_t str_decode(const char *str, size_t *offset, size_t sz);
-extern wchar_t str_decode_reverse(const char *str, size_t *offset, size_t sz);
-extern errno_t chr_encode(wchar_t ch, char *str, size_t *offset, size_t sz);
+extern char32_t str_decode(const char *str, size_t *offset, size_t sz);
+extern char32_t str_decode_reverse(const char *str, size_t *offset, size_t sz);
+extern errno_t chr_encode(char32_t ch, char *str, size_t *offset, size_t sz);
 
 extern size_t str_size(const char *str);
-extern size_t wstr_size(const wchar_t *str);
+extern size_t wstr_size(const char32_t *str);
 
 extern size_t str_nsize(const char *str, size_t max_size);
-extern size_t wstr_nsize(const wchar_t *str, size_t max_size);
+extern size_t wstr_nsize(const char32_t *str, size_t max_size);
 
 extern size_t str_lsize(const char *str, size_t max_len);
-extern size_t wstr_lsize(const wchar_t *str, size_t max_len);
+extern size_t wstr_lsize(const char32_t *str, size_t max_len);
 
 extern size_t str_length(const char *str);
-extern size_t wstr_length(const wchar_t *wstr);
+extern size_t wstr_length(const char32_t *wstr);
 
 extern size_t str_nlength(const char *str, size_t size);
-extern size_t wstr_nlength(const wchar_t *str, size_t size);
+extern size_t wstr_nlength(const char32_t *str, size_t size);
 
-extern size_t chr_width(wchar_t ch);
+extern size_t chr_width(char32_t ch);
 extern size_t str_width(const char *str);
 
-extern bool ascii_check(wchar_t ch);
-extern bool chr_check(wchar_t ch);
+extern bool ascii_check(char32_t ch);
+extern bool chr_check(char32_t ch);
 
 extern int str_cmp(const char *s1, const char *s2);
@@ -105,21 +105,21 @@
 
 extern errno_t spascii_to_str(char *dest, size_t size, const uint8_t *src, size_t n);
-extern void wstr_to_str(char *dest, size_t size, const wchar_t *src);
-extern char *wstr_to_astr(const wchar_t *src);
-extern void str_to_wstr(wchar_t *dest, size_t dlen, const char *src);
-extern wchar_t *str_to_awstr(const char *src);
+extern void wstr_to_str(char *dest, size_t size, const char32_t *src);
+extern char *wstr_to_astr(const char32_t *src);
+extern void str_to_wstr(char32_t *dest, size_t dlen, const char *src);
+extern char32_t *str_to_awstr(const char *src);
 extern errno_t utf16_to_str(char *dest, size_t size, const uint16_t *src);
 extern errno_t str_to_utf16(uint16_t *dest, size_t dlen, const char *src);
 extern size_t utf16_wsize(const uint16_t *ustr);
 
-extern char *str_chr(const char *str, wchar_t ch);
-extern char *str_rchr(const char *str, wchar_t ch);
+extern char *str_chr(const char *str, char32_t ch);
+extern char *str_rchr(const char *str, char32_t ch);
 extern char *str_str(const char *hs, const char *n);
 
-extern void str_rtrim(char *str, wchar_t ch);
-extern void str_ltrim(char *str, wchar_t ch);
+extern void str_rtrim(char *str, char32_t ch);
+extern void str_ltrim(char *str, char32_t ch);
 
-extern bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos);
-extern bool wstr_remove(wchar_t *str, size_t pos);
+extern bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos);
+extern bool wstr_remove(char32_t *str, size_t pos);
 
 extern char *str_dup(const char *src);
Index: uspace/lib/c/include/uchar.h
===================================================================
--- uspace/lib/c/include/uchar.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
+++ uspace/lib/c/include/uchar.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#ifndef _LIBC_UCHAR_H_
+#define _LIBC_UCHAR_H_
+
+#include <_bits/uchar.h>
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/test/stdlib.c
===================================================================
--- uspace/lib/c/test/stdlib.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/c/test/stdlib.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -48,6 +48,6 @@
 	(void) sz;
 
-	/* Make sure wchar_t is defined */
-	wchar_t wc = L'\0';
+	/* Make sure char32_t is defined */
+	char32_t wc = L'\0';
 	(void) wc;
 
Index: uspace/lib/clui/tinput.c
===================================================================
--- uspace/lib/clui/tinput.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/clui/tinput.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -113,5 +113,5 @@
 static void tinput_display_tail(tinput_t *ti, size_t start, size_t pad)
 {
-	wchar_t *dbuf = malloc((INPUT_MAX_SIZE + 1) * sizeof(wchar_t));
+	char32_t *dbuf = malloc((INPUT_MAX_SIZE + 1) * sizeof(char32_t));
 	if (!dbuf)
 		return;
@@ -126,5 +126,5 @@
 	size_t p = start;
 	if (p < sa) {
-		memcpy(dbuf, ti->buffer + p, (sa - p) * sizeof(wchar_t));
+		memcpy(dbuf, ti->buffer + p, (sa - p) * sizeof(char32_t));
 		dbuf[sa - p] = '\0';
 		printf("%ls", dbuf);
@@ -137,5 +137,5 @@
 
 		memcpy(dbuf, ti->buffer + p,
-		    (sb - p) * sizeof(wchar_t));
+		    (sb - p) * sizeof(char32_t));
 		dbuf[sb - p] = '\0';
 		printf("%ls", dbuf);
@@ -148,5 +148,5 @@
 	if (p < ti->nc) {
 		memcpy(dbuf, ti->buffer + p,
-		    (ti->nc - p) * sizeof(wchar_t));
+		    (ti->nc - p) * sizeof(char32_t));
 		dbuf[ti->nc - p] = '\0';
 		printf("%ls", dbuf);
@@ -154,5 +154,5 @@
 
 	for (p = 0; p < pad; p++)
-		putwchar(' ');
+		putuchar(' ');
 
 	console_flush(ti->console);
@@ -192,5 +192,5 @@
 	tinput_console_set_lpos(ti, ti->text_coord + ti->nc);
 	console_flush(ti->console);
-	putwchar('\n');
+	putuchar('\n');
 }
 
@@ -212,5 +212,5 @@
 }
 
-static void tinput_insert_char(tinput_t *ti, wchar_t c)
+static void tinput_insert_char(tinput_t *ti, char32_t c)
 {
 	if (ti->nc == INPUT_MAX_SIZE)
@@ -263,5 +263,5 @@
 	size_t i = 0;
 	while (i < ilen) {
-		wchar_t c = str_decode(str, &off, STR_NO_LIMIT);
+		char32_t c = str_decode(str, &off, STR_NO_LIMIT);
 		if (c == '\0')
 			break;
@@ -506,5 +506,5 @@
 
 	memmove(ti->buffer + sa, ti->buffer + sb,
-	    (ti->nc - sb) * sizeof(wchar_t));
+	    (ti->nc - sb) * sizeof(char32_t));
 
 	ti->pos = ti->sel_start = sa;
@@ -526,5 +526,5 @@
 
 	if (sb < ti->nc) {
-		wchar_t tmp_c = ti->buffer[sb];
+		char32_t tmp_c = ti->buffer[sb];
 		ti->buffer[sb] = '\0';
 		str = wstr_to_astr(ti->buffer + sa);
@@ -602,5 +602,5 @@
 	size_t i;
 	size_t a_off, b_off;
-	wchar_t ca, cb;
+	char32_t ca, cb;
 
 	i = 0;
Index: uspace/lib/clui/tinput.h
===================================================================
--- uspace/lib/clui/tinput.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/clui/tinput.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -63,5 +63,5 @@
  * @return		EOK on success, error code on failure.
  */
-typedef errno_t (*tinput_compl_init_fn)(wchar_t *text, size_t pos, size_t *cstart,
+typedef errno_t (*tinput_compl_init_fn)(char32_t *text, size_t pos, size_t *cstart,
     void **state);
 
@@ -111,5 +111,5 @@
 
 	/** Buffer holding text currently being edited */
-	wchar_t buffer[INPUT_MAX_SIZE + 1];
+	char32_t buffer[INPUT_MAX_SIZE + 1];
 
 	/** Linear position on screen where the prompt starts */
Index: uspace/lib/draw/font.c
===================================================================
--- uspace/lib/draw/font.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/font.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -64,5 +64,5 @@
 }
 
-errno_t font_resolve_glyph(font_t *font, wchar_t c, glyph_id_t *glyph_id)
+errno_t font_resolve_glyph(font_t *font, char32_t c, glyph_id_t *glyph_id)
 {
 	return font->backend->resolve_glyph(font->backend_data, c, glyph_id);
@@ -95,5 +95,5 @@
 	size_t off = 0;
 	while (true) {
-		wchar_t c = str_decode(text, &off, STR_NO_LIMIT);
+		char32_t c = str_decode(text, &off, STR_NO_LIMIT);
 		if (c == 0)
 			break;
@@ -138,5 +138,5 @@
 	size_t off = 0;
 	while (true) {
-		wchar_t c = str_decode(text, &off, STR_NO_LIMIT);
+		char32_t c = str_decode(text, &off, STR_NO_LIMIT);
 		if (c == 0)
 			break;
Index: uspace/lib/draw/font/bitmap_backend.c
===================================================================
--- uspace/lib/draw/font/bitmap_backend.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/font/bitmap_backend.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -67,5 +67,5 @@
 }
 
-static errno_t bb_resolve_glyph(void *backend_data, wchar_t c, glyph_id_t *glyph_id)
+static errno_t bb_resolve_glyph(void *backend_data, char32_t c, glyph_id_t *glyph_id)
 {
 	bitmap_backend_data_t *data = (bitmap_backend_data_t *) backend_data;
Index: uspace/lib/draw/font/embedded.c
===================================================================
--- uspace/lib/draw/font/embedded.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/font/embedded.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -43,5 +43,5 @@
 #include <draw/drawctx.h>
 
-static errno_t fde_resolve_glyph(void *unused, const wchar_t chr,
+static errno_t fde_resolve_glyph(void *unused, const char32_t chr,
     glyph_id_t *glyph_id)
 {
Index: uspace/lib/draw/font/pcf.c
===================================================================
--- uspace/lib/draw/font/pcf.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/font/pcf.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -143,5 +143,5 @@
 }
 
-static errno_t pcf_resolve_glyph(void *opaque_data, const wchar_t chr,
+static errno_t pcf_resolve_glyph(void *opaque_data, const char32_t chr,
     glyph_id_t *glyph_id)
 {
Index: uspace/lib/draw/gfx/font-8x16.c
===================================================================
--- uspace/lib/draw/gfx/font-8x16.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/gfx/font-8x16.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -47,5 +47,5 @@
  *
  */
-uint16_t fb_font_glyph(const wchar_t ch, bool *found)
+uint16_t fb_font_glyph(const char32_t ch, bool *found)
 {
 	if (found)
Index: uspace/lib/draw/include/draw/font.h
===================================================================
--- uspace/lib/draw/include/draw/font.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/include/draw/font.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -97,5 +97,5 @@
 typedef struct {
 	errno_t (*get_font_metrics)(void *, font_metrics_t *);
-	errno_t (*resolve_glyph)(void *, wchar_t, glyph_id_t *);
+	errno_t (*resolve_glyph)(void *, char32_t, glyph_id_t *);
 	errno_t (*get_glyph_metrics)(void *, glyph_id_t, glyph_metrics_t *);
 	errno_t (*render_glyph)(void *, drawctx_t *, source_t *, sysarg_t,
@@ -110,5 +110,5 @@
 
 typedef struct {
-	errno_t (*resolve_glyph)(void *, const wchar_t, glyph_id_t *);
+	errno_t (*resolve_glyph)(void *, const char32_t, glyph_id_t *);
 	errno_t (*load_glyph_surface)(void *, glyph_id_t, surface_t **);
 	errno_t (*load_glyph_metrics)(void *, glyph_id_t, glyph_metrics_t *);
@@ -118,5 +118,5 @@
 extern font_t *font_create(font_backend_t *, void *);
 extern errno_t font_get_metrics(font_t *, font_metrics_t *);
-extern errno_t font_resolve_glyph(font_t *, wchar_t, glyph_id_t *);
+extern errno_t font_resolve_glyph(font_t *, char32_t, glyph_id_t *);
 extern errno_t font_get_glyph_metrics(font_t *, glyph_id_t, glyph_metrics_t *);
 extern errno_t font_render_glyph(font_t *, drawctx_t *, source_t *,
Index: uspace/lib/draw/include/draw/gfx.h
===================================================================
--- uspace/lib/draw/include/draw/gfx.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/draw/include/draw/gfx.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -40,4 +40,5 @@
 #include <stdbool.h>
 #include <stddef.h>
+#include <uchar.h>
 
 #define CURSOR_WIDTH   11
@@ -52,5 +53,5 @@
 extern uint8_t cursor_mask[];
 
-extern uint16_t fb_font_glyph(const wchar_t, bool *);
+extern uint16_t fb_font_glyph(const char32_t, bool *);
 extern uint8_t fb_font[FONT_GLYPHS][FONT_SCANLINES];
 
Index: uspace/lib/ext4/src/superblock.c
===================================================================
--- uspace/lib/ext4/src/superblock.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/ext4/src/superblock.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -889,5 +889,5 @@
 	size_t i;
 	size_t wi;
-	wchar_t ch;
+	char32_t ch;
 	errno_t rc;
 
@@ -896,5 +896,5 @@
 	while (sb->volume_name[i] != '\0' && i < sizeof(sb->volume_name)) {
 		/* ISO 8859-1 codes map to identical Unicode code points */
-		ch = (wchar_t)(uint8_t)sb->volume_name[i];
+		ch = (char32_t)(uint8_t)sb->volume_name[i];
 		rc = chr_encode(ch, buf, &wi, bufsz - 1);
 		if (rc != EOK)
@@ -917,5 +917,5 @@
 {
 	size_t off;
-	wchar_t ch;
+	char32_t ch;
 	size_t wi;
 
Index: uspace/lib/fmtutil/fmtutil.c
===================================================================
--- uspace/lib/fmtutil/fmtutil.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/fmtutil/fmtutil.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -62,8 +62,8 @@
 
 /** Line consumer that prints the lines aligned according to spec */
-static errno_t print_line(wchar_t *wstr, size_t chars, bool last, void *data)
+static errno_t print_line(char32_t *wstr, size_t chars, bool last, void *data)
 {
 	printmode_t *pm = (printmode_t *) data;
-	wchar_t old_char = wstr[chars];
+	char32_t old_char = wstr[chars];
 	wstr[chars] = 0;
 	errno_t rc = print_aligned_w(wstr, pm->width, last, pm->alignment);
@@ -78,5 +78,5 @@
 	pm.newline_always = false;
 	pm.width = width;
-	wchar_t *wstr = str_to_awstr(str);
+	char32_t *wstr = str_to_awstr(str);
 	if (wstr == NULL) {
 		return ENOMEM;
@@ -87,5 +87,5 @@
 }
 
-errno_t print_aligned_w(const wchar_t *wstr, size_t width, bool last,
+errno_t print_aligned_w(const char32_t *wstr, size_t width, bool last,
     align_mode_t mode)
 {
@@ -95,14 +95,14 @@
 		for (i = 0; i < width; i++) {
 			if (i < len)
-				putwchar(wstr[i]);
+				putuchar(wstr[i]);
 			else
-				putwchar(' ');
+				putuchar(' ');
 		}
 	} else if (mode == ALIGN_RIGHT) {
 		for (i = 0; i < width; i++) {
 			if (i < width - len)
-				putwchar(' ');
+				putuchar(' ');
 			else
-				putwchar(wstr[i - (width - len)]);
+				putuchar(wstr[i - (width - len)]);
 		}
 	} else if (mode == ALIGN_CENTER) {
@@ -110,7 +110,7 @@
 		for (i = 0; i < width; i++) {
 			if ((i < padding) || ((i - padding) >= len))
-				putwchar(' ');
+				putuchar(' ');
 			else
-				putwchar(wstr[i - padding]);
+				putuchar(wstr[i - padding]);
 		}
 	} else if (mode == ALIGN_JUSTIFY) {
@@ -146,10 +146,10 @@
 				    (words - 1)));
 				for (j = 0; j < spaces; j++) {
-					putwchar(' ');
+					putuchar(' ');
 				}
 				done_chars += spaces;
 			}
 			while (i < len && wstr[i] != ' ') {
-				putwchar(wstr[i++]);
+				putuchar(wstr[i++]);
 				done_chars++;
 			}
@@ -158,5 +158,5 @@
 	skip_words:
 		while (done_chars < width) {
-			putwchar(' ');
+			putuchar(' ');
 			done_chars++;
 		}
@@ -169,5 +169,5 @@
 errno_t print_aligned(const char *str, size_t width, bool last, align_mode_t mode)
 {
-	wchar_t *wstr = str_to_awstr(str);
+	char32_t *wstr = str_to_awstr(str);
 	if (wstr == NULL) {
 		return ENOMEM;
@@ -178,5 +178,5 @@
 }
 
-errno_t wrap(wchar_t *wstr, size_t width, line_consumer_fn consumer, void *data)
+errno_t wrap(char32_t *wstr, size_t width, line_consumer_fn consumer, void *data)
 {
 	size_t word_start = 0;
Index: uspace/lib/fmtutil/fmtutil.h
===================================================================
--- uspace/lib/fmtutil/fmtutil.h	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/fmtutil/fmtutil.h	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -44,7 +44,7 @@
  * @returns EOK on success or an error code on failure
  */
-typedef errno_t (*line_consumer_fn)(wchar_t *, size_t, bool, void *);
+typedef errno_t (*line_consumer_fn)(char32_t *, size_t, bool, void *);
 
-extern errno_t print_aligned_w(const wchar_t *, size_t, bool, align_mode_t);
+extern errno_t print_aligned_w(const char32_t *, size_t, bool, align_mode_t);
 extern errno_t print_aligned(const char *, size_t, bool, align_mode_t);
 extern errno_t print_wrapped(const char *, size_t, align_mode_t);
@@ -58,3 +58,3 @@
  * @param data user data to pass to the consumer function
  */
-extern errno_t wrap(wchar_t *, size_t, line_consumer_fn, void *);
+extern errno_t wrap(char32_t *, size_t, line_consumer_fn, void *);
Index: uspace/lib/gui/terminal.c
===================================================================
--- uspace/lib/gui/terminal.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/gui/terminal.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -419,5 +419,5 @@
 			if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS &&
 			    event->ev.key.c != 0) {
-				wchar_t tmp[2] = {
+				char32_t tmp[2] = {
 					event->ev.key.c,
 					0
@@ -436,5 +436,5 @@
 }
 
-static void term_write_char(terminal_t *term, wchar_t ch)
+static void term_write_char(terminal_t *term, char32_t ch)
 {
 	sysarg_t updated = 0;
@@ -455,5 +455,5 @@
 		break;
 	default:
-		updated = chargrid_putwchar(term->frontbuf, ch, true);
+		updated = chargrid_putuchar(term->frontbuf, ch, true);
 	}
 
Index: uspace/lib/posix/src/stdio.c
===================================================================
--- uspace/lib/posix/src/stdio.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/posix/src/stdio.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -249,5 +249,5 @@
  * @return The number of written characters.
  */
-static int _dprintf_wstr_write(const wchar_t *str, size_t size, void *fd)
+static int _dprintf_wstr_write(const char32_t *str, size_t size, void *fd)
 {
 	size_t offset = 0;
@@ -268,5 +268,5 @@
 
 		chars++;
-		offset += sizeof(wchar_t);
+		offset += sizeof(char32_t);
 	}
 
Index: uspace/lib/usbdev/src/request.c
===================================================================
--- uspace/lib/usbdev/src/request.c	(revision ffccdff0fd3f49751202889e457bdf900721bfad)
+++ uspace/lib/usbdev/src/request.c	(revision 663f445f6ae6d51eff8cb7bcc345d4a411d3ff7e)
@@ -756,5 +756,5 @@
 	/* Prepare dynamically allocated variables. */
 	uint8_t *string = NULL;
-	wchar_t *string_chars = NULL;
+	char32_t *string_chars = NULL;
 
 	/* Get the actual descriptor. */
@@ -783,5 +783,5 @@
 
 	const size_t string_char_count = string_size / 2;
-	string_chars = malloc(sizeof(wchar_t) * (string_char_count + 1));
+	string_chars = malloc(sizeof(char32_t) * (string_char_count + 1));
 	if (string_chars == NULL) {
 		rc = ENOMEM;