diff --git a/doc/api/util.md b/doc/api/util.md
index 952f01d8aeca..26c8811489f6 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -946,6 +946,46 @@ const callSites = getCallSites({ sourceMap: true });
 // Column Number: 26
 ```
 
+## `util.getStringWidth(str)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+* `str` {string}
+* Returns: {integer} An estimate of the number of columns needed to display
+  `str`.
+
+Returns an estimate of the width of `str` as displayed in a terminal, counted
+in columns. The string is split into grapheme clusters, the units a terminal
+renders as one glyph. Full-width characters, such as CJK ideographs, count as
+two columns. An emoji counts as two columns, including a sequence joined by
+zero-width joiners, a flag, a keycap, or an emoji with a skin tone modifier.
+Clusters without visible characters, such as control characters, zero-width
+spaces and lone combining marks, count as zero. Characters of ambiguous East
+Asian Width, such as `±`, count as one column. ANSI escape sequences, as
+produced by [`util.styleText()`][], are ignored.
+
+```js
+console.log(util.getStringWidth('hello'));
+// Prints: 5
+console.log(util.getStringWidth('你好'));
+// Prints: 4
+console.log(util.getStringWidth('👩\u200D👩\u200D👧'));
+// Prints: 2
+console.log(util.getStringWidth(util.styleText('red', 'hi')));
+// Prints: 2
+```
+
+The result is an estimate because terminals differ in how they render some
+characters. For example, a terminal that does not support an emoji sequence
+displays each emoji of the sequence separately and uses more columns than
+reported. When Node.js is built without ICU, a simpler table of full-width and
+zero-width code points is used, which is less accurate for less common scripts
+and symbols.
+
 ## `util.getSystemErrorName(err)`
 
 <!-- YAML
@@ -4176,6 +4216,7 @@ npx codemod@latest @nodejs/util-is
 [`util.format()`]: #utilformatformat-args
 [`util.inspect()`]: #utilinspectobject-options
 [`util.promisify()`]: #utilpromisifyoriginal
+[`util.styleText()`]: #utilstyletextformat-text-options
 [`util.types.isAnyArrayBuffer()`]: #utiltypesisanyarraybuffervalue
 [`util.types.isArrayBuffer()`]: #utiltypesisarraybuffervalue
 [`util.types.isSharedArrayBuffer()`]: #utiltypesissharedarraybuffervalue
diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
index 622dab4eae8a..2933cc57c02b 100644
--- a/lib/internal/util/inspect.js
+++ b/lib/internal/util/inspect.js
@@ -293,6 +293,7 @@ const ansi = new RegExp(
 );
 
 let getStringWidth;
+let getStringDisplayWidth;
 
 function getUserOptions(ctx, isCrossContext) {
   const ret = {
@@ -2954,6 +2955,117 @@ function isZeroWidthCodePoint(code) {
     (code >= 0xE0100 && code <= 0xE01EF); // Variation Selectors
 }
 
+/**
+ * Returns true if the character represented by a given
+ * Unicode code point is full-width. Otherwise returns false.
+ * @param {string} code
+ * @returns {boolean}
+ */
+function isFullWidthCodePoint(code) {
+  // Code points are partially derived from:
+  // https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt
+  return code >= 0x1100 && (
+    code <= 0x115f ||  // Hangul Jamo
+    code === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+    code === 0x232a || // RIGHT-POINTING ANGLE BRACKET
+    // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+    (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) ||
+    // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+    (code >= 0x3250 && code <= 0x4dbf) ||
+    // CJK Unified Ideographs .. Yi Radicals
+    (code >= 0x4e00 && code <= 0xa4c6) ||
+    // Hangul Jamo Extended-A
+    (code >= 0xa960 && code <= 0xa97c) ||
+    // Hangul Syllables
+    (code >= 0xac00 && code <= 0xd7a3) ||
+    // CJK Compatibility Ideographs
+    (code >= 0xf900 && code <= 0xfaff) ||
+    // Vertical Forms
+    (code >= 0xfe10 && code <= 0xfe19) ||
+    // CJK Compatibility Forms .. Small Form Variants
+    (code >= 0xfe30 && code <= 0xfe6b) ||
+    // Halfwidth and Fullwidth Forms
+    (code >= 0xff01 && code <= 0xff60) ||
+    (code >= 0xffe0 && code <= 0xffe6) ||
+    // Kana Supplement
+    (code >= 0x1b000 && code <= 0x1b001) ||
+    // Enclosed Ideographic Supplement
+    (code >= 0x1f200 && code <= 0x1f251) ||
+    // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff
+    // Emoticons 0x1f600 - 0x1f64f
+    (code >= 0x1f300 && code <= 0x1f64f) ||
+    // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+    (code >= 0x20000 && code <= 0x3fffd)
+  );
+}
+
+// Emoji blocks missing from isFullWidthCodePoint(), which is shared with
+// the cursor movement of readline and is left unchanged.
+function isWideEmojiCodePoint(code) {
+  return (code >= 0x1f680 && code <= 0x1f6c5) ||  // Transport and Map Symbols
+    (code >= 0x1f90c && code <= 0x1f9ff) ||  // Supplemental Symbols and Pictographs
+    (code >= 0x1fa70 && code <= 0x1faff);  // Symbols and Pictographs Extended-A
+}
+
+// Approximation of the grapheme cluster based width of the ICU build, used
+// when Node.js is built without ICU: an emoji or symbol joined to an emoji,
+// a skin tone modifier and a lone surrogate take no columns of their own,
+// and an emoji presentation selector or a combining keycap turns a narrow
+// character into a two column emoji.
+function getStringDisplayWidthFallback(str) {
+  str = StringPrototypeNormalize(stripVTControlCharacters(str), 'NFC');
+  let width = 0;
+  let lastWidth = 0;
+  let lastCode = 0;
+  let lastEmoji = false;
+  let joined = false;
+  for (const char of new SafeStringIterator(str)) {
+    const code = StringPrototypeCodePointAt(char, 0);
+    if (code === 0x200D) {
+      joined = lastEmoji;
+      continue;
+    }
+    const fullWidth = isFullWidthCodePoint(code) || isWideEmojiCodePoint(code);
+    if (joined) {
+      joined = false;
+      // Emoji, and the symbols used in emoji sequences, such as the gender
+      // signs and the heart.
+      if ((fullWidth && code >= 0x1F000) ||
+          (code >= 0x2600 && code <= 0x27BF)) {
+        continue;
+      }
+    }
+    // Text style symbols that become emoji with a presentation selector are
+    // all above U+2000, except COPYRIGHT SIGN and REGISTERED SIGN.
+    if (code === 0x20E3 || (code === 0xFE0F &&
+        (lastCode >= 0x2000 || lastCode === 0xA9 || lastCode === 0xAE))) {
+      if (lastWidth === 1) {
+        width++;
+        lastWidth = 2;
+        lastEmoji = true;
+      }
+      continue;
+    }
+    if ((code >= 0x1F3FB && code <= 0x1F3FF) ||
+        (code >= 0xD800 && code <= 0xDFFF)) {
+      continue;
+    }
+    if (fullWidth) {
+      width += 2;
+      lastWidth = 2;
+      lastEmoji = code >= 0x1F000;
+    } else if (!isZeroWidthCodePoint(code)) {
+      width++;
+      lastWidth = 1;
+      lastEmoji = false;
+    } else {
+      continue;
+    }
+    lastCode = code;
+  }
+  return width;
+}
+
 if (internalBinding('config').hasIntl) {
   const icu = internalBinding('icu');
   // icu.getStringWidth(string, ambiguousAsFullWidth, expandEmojiSequence)
@@ -2979,7 +3091,25 @@ if (internalBinding('config').hasIntl) {
     }
     return width;
   };
+
+  // Width as rendered by a terminal, counted per grapheme cluster so that an
+  // emoji sequence counts as one glyph. Used by util.getStringWidth(). The
+  // function above counts code points and is used for cursor movement.
+  getStringDisplayWidth = function getStringDisplayWidth(str) {
+    str = stripVTControlCharacters(str);
+    let width = 0;
+    for (let i = 0; i < str.length; i++) {
+      const code = StringPrototypeCharCodeAt(str, i);
+      if (code >= 127) {
+        return icu.getGraphemeStringWidth(str);
+      }
+      width += code >= 32 ? 1 : 0;
+    }
+    return width;
+  };
 } else {
+  getStringDisplayWidth = getStringDisplayWidthFallback;
+
   /**
    * @param {string} str
    * @param {boolean} [removeControlChars]
@@ -3003,49 +3133,6 @@ if (internalBinding('config').hasIntl) {
     return width;
   };
 
-  /**
-   * Returns true if the character represented by a given
-   * Unicode code point is full-width. Otherwise returns false.
-   * @param {string} code
-   * @returns {boolean}
-   */
-  const isFullWidthCodePoint = (code) => {
-    // Code points are partially derived from:
-    // https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt
-    return code >= 0x1100 && (
-      code <= 0x115f ||  // Hangul Jamo
-      code === 0x2329 || // LEFT-POINTING ANGLE BRACKET
-      code === 0x232a || // RIGHT-POINTING ANGLE BRACKET
-      // CJK Radicals Supplement .. Enclosed CJK Letters and Months
-      (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) ||
-      // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
-      (code >= 0x3250 && code <= 0x4dbf) ||
-      // CJK Unified Ideographs .. Yi Radicals
-      (code >= 0x4e00 && code <= 0xa4c6) ||
-      // Hangul Jamo Extended-A
-      (code >= 0xa960 && code <= 0xa97c) ||
-      // Hangul Syllables
-      (code >= 0xac00 && code <= 0xd7a3) ||
-      // CJK Compatibility Ideographs
-      (code >= 0xf900 && code <= 0xfaff) ||
-      // Vertical Forms
-      (code >= 0xfe10 && code <= 0xfe19) ||
-      // CJK Compatibility Forms .. Small Form Variants
-      (code >= 0xfe30 && code <= 0xfe6b) ||
-      // Halfwidth and Fullwidth Forms
-      (code >= 0xff01 && code <= 0xff60) ||
-      (code >= 0xffe0 && code <= 0xffe6) ||
-      // Kana Supplement
-      (code >= 0x1b000 && code <= 0x1b001) ||
-      // Enclosed Ideographic Supplement
-      (code >= 0x1f200 && code <= 0x1f251) ||
-      // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff
-      // Emoticons 0x1f600 - 0x1f64f
-      (code >= 0x1f300 && code <= 0x1f64f) ||
-      // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
-      (code >= 0x20000 && code <= 0x3fffd)
-    );
-  };
 
 }
 
@@ -3074,6 +3161,8 @@ module.exports = {
   stylizeWithColor,
   format,
   formatWithOptions,
+  getStringDisplayWidth,
+  getStringDisplayWidthFallback,
   getStringWidth,
   stripVTControlCharacters,
   isZeroWidthCodePoint,
diff --git a/lib/util.js b/lib/util.js
index 02e205c8e16c..1b1ea4d31d0f 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -58,6 +58,7 @@ const { Buffer } = require('buffer');
 const {
   format,
   formatWithOptions,
+  getStringDisplayWidth,
   inspect,
   stripVTControlCharacters,
 } = require('internal/util/inspect');
@@ -236,6 +237,16 @@ function rgbToAnsi24Bit(r, g, b) {
   return `38;2;${r};${g};${b}`;
 }
 
+/**
+ * Returns the number of columns needed to display `str` in a terminal.
+ * @param {string} str
+ * @returns {number}
+ */
+function getStringWidth(str) {
+  validateString(str, 'str');
+  return getStringDisplayWidth(str);
+}
+
 /**
  * @param {string | string[]} format
  * @param {string} text
@@ -612,6 +623,7 @@ module.exports = {
   styleText,
   formatWithOptions,
   getCallSites,
+  getStringWidth,
   getSystemErrorMap,
   getSystemErrorName,
   getSystemErrorMessage,
diff --git a/src/node_i18n.cc b/src/node_i18n.cc
index e743941734a7..a4a0e27e2635 100644
--- a/src/node_i18n.cc
+++ b/src/node_i18n.cc
@@ -57,6 +57,7 @@
 
 #include <unicode/putil.h>
 #include <unicode/timezone.h>
+#include <unicode/ubrk.h>
 #include <unicode/uchar.h>
 #include <unicode/uclean.h>
 #include <unicode/ucnv.h>
@@ -684,11 +685,182 @@ static void GetStringWidth(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(width);
 }
 
+// Returns the East Asian Width of a code point in columns. Ambiguous
+// characters are narrow unless ambiguous_as_full_width is set.
+static int GetEastAsianWidth(UChar32 codepoint, bool ambiguous_as_full_width) {
+  switch (u_getIntPropertyValue(codepoint, UCHAR_EAST_ASIAN_WIDTH)) {
+    case U_EA_FULLWIDTH:
+    case U_EA_WIDE:
+      return 2;
+    case U_EA_AMBIGUOUS:
+      return ambiguous_as_full_width ? 2 : 1;
+    default:
+      return 1;
+  }
+}
+
+// Returns true if the code point takes up columns of its own, i.e. it is not
+// a control, format or default ignorable code point, a nonspacing or
+// enclosing mark, or a surrogate.
+static bool IsVisibleCodePoint(UChar32 codepoint) {
+  if (u_hasBinaryProperty(codepoint, UCHAR_DEFAULT_IGNORABLE_CODE_POINT)) {
+    return false;
+  }
+  switch (u_charType(codepoint)) {
+    case U_CONTROL_CHAR:
+    case U_FORMAT_CHAR:
+    case U_NON_SPACING_MARK:
+    case U_ENCLOSING_MARK:
+    case U_SURROGATE:
+      return false;
+    default:
+      return true;
+  }
+}
+
+static bool IsHangulLeadingJamo(UChar32 c) {
+  return (c >= 0x1100 && c <= 0x115F) || (c >= 0xA960 && c <= 0xA97C);
+}
+
+static bool IsHangulVowelJamo(UChar32 c) {
+  return (c >= 0x1160 && c <= 0x11A7) || (c >= 0xD7B0 && c <= 0xD7C6);
+}
+
+static bool IsHangulTrailingJamo(UChar32 c) {
+  return (c >= 0x11A8 && c <= 0x11FF) || (c >= 0xD7CB && c <= 0xD7FB);
+}
+
+static bool IsHangulJamo(UChar32 c) {
+  return IsHangulLeadingJamo(c) || IsHangulVowelJamo(c) ||
+         IsHangulTrailingJamo(c);
+}
+
+static bool IsKeycapBase(UChar c) {
+  return c == '#' || c == '*' || (c >= '0' && c <= '9');
+}
+
+// Returns the number of columns a terminal uses for one grapheme cluster.
+// The rules match those of the string-width package, which most CLI tools
+// use, so that the results agree with the rest of the ecosystem:
+//  - a cluster without visible code points takes no columns;
+//  - an emoji sequence recommended for general interchange (RGI), such as a
+//    flag, a keycap, a skin tone or a ZWJ sequence, takes two columns, as
+//    does a keycap or ZWJ sequence that is missing its variation selector;
+//  - Hangul jamo are grouped into syllable blocks of two columns;
+//  - otherwise the East Asian Width of the first visible code point is
+//    used, plus that of trailing spacing marks and halfwidth and fullwidth
+//    forms, such as a halfwidth dakuten.
+static int GetClusterWidth(const UChar* str,
+                           int32_t length,
+                           bool ambiguous_as_full_width) {
+  if (length == 1) {
+    return IsVisibleCodePoint(str[0])
+               ? GetEastAsianWidth(str[0], ambiguous_as_full_width)
+               : 0;
+  }
+
+  if (u_stringHasBinaryProperty(str, length, UCHAR_RGI_EMOJI)) return 2;
+
+  MaybeStackBuffer<UChar32, 32> visible(length);
+  size_t visible_count = 0;
+  bool has_zwj = false;
+  int pictographic_count = 0;
+  int32_t n = 0;
+  UChar32 c;
+  while (n < length) {
+    U16_NEXT(str, n, length, c);
+    if (c == 0x200D) has_zwj = true;
+    if (u_hasBinaryProperty(c, UCHAR_EXTENDED_PICTOGRAPHIC)) {
+      pictographic_count++;
+    }
+    if (IsVisibleCodePoint(c)) visible[visible_count++] = c;
+  }
+  if (visible_count == 0) return 0;
+
+  if (has_zwj && pictographic_count >= 2) return 2;
+  if (length == 2 && IsKeycapBase(str[0]) && str[1] == 0x20E3) return 2;
+
+  int width = 0;
+  if (IsHangulJamo(visible[0])) {
+    for (size_t i = 0; i < visible_count; i++) {
+      if (!IsHangulJamo(visible[i])) {
+        for (; i < visible_count; i++) {
+          width += GetEastAsianWidth(visible[i], ambiguous_as_full_width);
+        }
+        break;
+      }
+      if (IsHangulLeadingJamo(visible[i]) && i + 1 < visible_count &&
+          IsHangulVowelJamo(visible[i + 1])) {
+        width += 2;
+        i += (i + 2 < visible_count && IsHangulTrailingJamo(visible[i + 2]))
+                 ? 2
+                 : 1;
+        continue;
+      }
+      width += GetEastAsianWidth(visible[i], ambiguous_as_full_width);
+    }
+    return width;
+  }
+
+  width = GetEastAsianWidth(visible[0], ambiguous_as_full_width);
+  for (size_t i = 1; i < visible_count; i++) {
+    if (u_charType(visible[i]) == U_COMBINING_SPACING_MARK ||
+        (visible[i] >= 0xFF00 && visible[i] <= 0xFFEF)) {
+      width += GetEastAsianWidth(visible[i], ambiguous_as_full_width);
+    }
+  }
+  return width;
+}
+
+struct CharacterBreakIterator {
+  UBreakIterator* iterator = nullptr;
+  ~CharacterBreakIterator() { ubrk_close(iterator); }
+};
+
+// Returns the column width of the given string, counted per grapheme cluster
+// so that an emoji sequence rendered as one glyph counts once. This is what
+// util.getStringWidth() uses. GetStringWidth() above counts code points and
+// is used for cursor movement in readline.
+static void GetGraphemeStringWidth(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args[0]->IsString());
+
+  bool ambiguous_as_full_width = args[1]->IsTrue();
+
+  TwoByteValue value(args.GetIsolate(), args[0]);
+  const UChar* str = reinterpret_cast<const UChar*>(*value);
+  int32_t length = static_cast<int32_t>(value.length());
+
+  // Opening a break iterator costs more than iterating a short string, so
+  // one iterator per thread is reused. It holds no state between calls and
+  // can be shared by the Environments of a thread.
+  // NOLINTNEXTLINE(runtime/thread_local)
+  static thread_local CharacterBreakIterator cached;
+  UErrorCode status = U_ZERO_ERROR;
+  if (cached.iterator == nullptr) {
+    cached.iterator = ubrk_open(UBRK_CHARACTER, nullptr, nullptr, 0, &status);
+    // The character break rules are part of the ICU data that Node.js ships.
+    CHECK(U_SUCCESS(status));
+  }
+  UBreakIterator* iterator = cached.iterator;
+  ubrk_setText(iterator, str, length, &status);
+  CHECK(U_SUCCESS(status));
+
+  uint32_t width = 0;
+  int32_t start = ubrk_first(iterator);
+  for (int32_t end = ubrk_next(iterator); end != UBRK_DONE;
+       start = end, end = ubrk_next(iterator)) {
+    width += GetClusterWidth(str + start, end - start, ambiguous_as_full_width);
+  }
+
+  args.GetReturnValue().Set(width);
+}
+
 static void CreatePerIsolateProperties(IsolateData* isolate_data,
                                        Local<ObjectTemplate> target) {
   Isolate* isolate = isolate_data->isolate();
 
   SetMethod(isolate, target, "getStringWidth", GetStringWidth);
+  SetMethod(isolate, target, "getGraphemeStringWidth", GetGraphemeStringWidth);
 
   // One-shot converters
   SetMethod(isolate, target, "icuErrName", ICUErrorName);
@@ -717,6 +889,7 @@ void CreatePerContextProperties(Local<Object> target,
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetStringWidth);
+  registry->Register(GetGraphemeStringWidth);
   registry->Register(ICUErrorName);
   registry->Register(Transcode);
   registry->Register(ConverterObject::Create);
diff --git a/test/parallel/test-icu-stringwidth.js b/test/parallel/test-icu-stringwidth.js
index 66142a8d6811..2a9121c34daa 100644
--- a/test/parallel/test-icu-stringwidth.js
+++ b/test/parallel/test-icu-stringwidth.js
@@ -93,3 +93,16 @@ if (common.hasIntl) {
   assert.strictEqual(getStringWidth(a), 4);
   assert.strictEqual(getStringWidth(b), 4);
 }
+
+// Grapheme cluster based width, used by util.getStringWidth().
+const { internalBinding } = require('internal/test/binding');
+const { getGraphemeStringWidth } = internalBinding('icu');
+assert.strictEqual(getGraphemeStringWidth(''), 0);
+assert.strictEqual(getGraphemeStringWidth('abc'), 3);
+assert.strictEqual(getGraphemeStringWidth('👩\u200D👩\u200D👧'), 2);
+assert.strictEqual(getGraphemeStringWidth('±'), 1);
+assert.strictEqual(getGraphemeStringWidth('±', true), 2);
+assert.strictEqual(getGraphemeStringWidth('±\u0301', true), 2);
+assert.strictEqual(getGraphemeStringWidth('क\u093F'), 2);
+assert.strictEqual(getGraphemeStringWidth('\u1100±', true), 4);
+assert.strictEqual(getGraphemeStringWidth('\u1100\u1161\u1161'), 3);
diff --git a/test/parallel/test-util-get-string-width-fallback.js b/test/parallel/test-util-get-string-width-fallback.js
new file mode 100644
index 000000000000..4fea5351a258
--- /dev/null
+++ b/test/parallel/test-util-get-string-width-fallback.js
@@ -0,0 +1,47 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { getStringDisplayWidthFallback } = require('internal/util/inspect');
+
+// The width used by util.getStringWidth() when Node.js is built without ICU.
+const cases = [
+  ['', 0],
+  ['hello', 5],
+  ['a你b', 4],
+  ['Ｆ', 2],
+  ['ｶ\uFF9E', 2],
+  ['\u{20000}', 2],
+  ['\u0007', 0],
+  ['あ\tい', 4],
+  ['e\u0301', 1],
+  ['\u200B', 0],
+  ['\uD83D', 0],
+  ['\u001B[31mred\u001B[39m', 3],
+  ['👩\u200D👩\u200D👧\u200D👧', 2],
+  ['a👩\u200D👩\u200D👧b', 4],
+  ['👨\u200D💻', 2],
+  ['🏳\uFE0F\u200D🌈', 2],
+  ['❤\uFE0F\u200D🔥', 2],
+  ['👩\u200D❤\uFE0F\u200D👨', 2],
+  ['\u26F9\uFE0F\u200D\u2642\uFE0F', 2],
+  ['👍🏽', 2],
+  ['🇮🇹', 2],
+  ['🤗🚀', 4],
+  ['❤\uFE0F', 2],
+  ['❤', 1],
+  ['\u00A9\uFE0F', 2],
+  ['a\uFE0F', 1],
+  ['1\uFE0F\u20E3', 2],
+  ['1\u20E3', 2],
+  ['#\u20E3', 2],
+  ['a\u200Db', 2],
+  ['你\u200D你', 4],
+  ['\u1100\u1161', 2],
+  ['क\u093F', 2],
+];
+
+for (const [str, width] of cases) {
+  assert.strictEqual(getStringDisplayWidthFallback(str), width, `width of ${JSON.stringify(str)}`);
+}
diff --git a/test/parallel/test-util-get-string-width.js b/test/parallel/test-util-get-string-width.js
new file mode 100644
index 000000000000..7da733bb12b9
--- /dev/null
+++ b/test/parallel/test-util-get-string-width.js
@@ -0,0 +1,95 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const util = require('util');
+
+const { getStringWidth } = util;
+
+assert.strictEqual(getStringWidth(''), 0);
+assert.strictEqual(getStringWidth('a'), 1);
+assert.strictEqual(getStringWidth('hello'), 5);
+assert.strictEqual(getStringWidth('a你b'), 4);
+
+// Full-width characters count as two columns.
+assert.strictEqual(getStringWidth('丁'), 2);
+assert.strictEqual(getStringWidth('你好'), 4);
+assert.strictEqual(getStringWidth('가'), 2);
+assert.strictEqual(getStringWidth('👅'), 2);
+assert.strictEqual(getStringWidth('Ｆ'), 2);  // Fullwidth Latin letter.
+assert.strictEqual(getStringWidth('ｱ'), 1);  // Halfwidth katakana.
+assert.strictEqual(getStringWidth('ｶ\uFF9E'), 2);  // Halfwidth dakuten.
+assert.strictEqual(getStringWidth('\u{1D49C}'), 1);  // Astral, not wide.
+assert.strictEqual(getStringWidth('\u{20000}'), 2);  // CJK Extension B.
+assert.strictEqual(getStringWidth('±'), 1);  // Ambiguous width is narrow.
+
+// Zero-width characters count as zero.
+assert.strictEqual(getStringWidth('\u0000'), 0);
+assert.strictEqual(getStringWidth('\u0007'), 0);
+assert.strictEqual(getStringWidth('\n'), 0);
+assert.strictEqual(getStringWidth('\r\n'), 0);
+assert.strictEqual(getStringWidth('\t'), 0);
+assert.strictEqual(getStringWidth('あ\tい'), 4);
+assert.strictEqual(getStringWidth('\u0301'), 0);  // Combining acute accent.
+assert.strictEqual(getStringWidth('e\u0301'), 1);
+assert.strictEqual(getStringWidth('\u200B'), 0);  // Zero-width space.
+assert.strictEqual(getStringWidth('a\u200Fb'), 2);  // Right-to-left mark.
+assert.strictEqual(getStringWidth('\uD83D'), 0);  // Lone surrogate.
+
+// ANSI escape sequences are ignored.
+assert.strictEqual(getStringWidth('\u001B[31mred\u001B[39m'), 3);
+assert.strictEqual(getStringWidth(util.styleText('bold', 'hi')), 2);
+assert.strictEqual(getStringWidth(util.styleText(['bold', 'red'], 'ok')), 2);
+assert.strictEqual(
+  getStringWidth('\u001B]8;;https://nodejs.org\u0007text\u001B]8;;\u0007'), 4);
+
+// An emoji sequence is rendered as one glyph of two columns.
+assert.strictEqual(getStringWidth('👩\u200D👩\u200D👧\u200D👧'), 2);
+assert.strictEqual(getStringWidth('a👩\u200D👩\u200D👧b'), 4);
+assert.strictEqual(getStringWidth('👨\u200D💻'), 2);
+assert.strictEqual(getStringWidth('🏳\uFE0F\u200D🌈'), 2);
+assert.strictEqual(getStringWidth('👍🏽'), 2);  // Skin tone modifier.
+assert.strictEqual(getStringWidth('🇮🇹'), 2);  // Flag.
+assert.strictEqual(getStringWidth('❤\uFE0F'), 2);  // Emoji presentation.
+assert.strictEqual(getStringWidth('❤'), 1);  // Text presentation.
+assert.strictEqual(getStringWidth('1\uFE0F\u20E3'), 2);  // Keycap.
+assert.strictEqual(getStringWidth('1\u20E3'), 2);  // Keycap without selector.
+assert.strictEqual(getStringWidth('#\u20E3'), 2);
+assert.strictEqual(getStringWidth('\u00A9\uFE0F'), 2);  // Copyright sign.
+assert.strictEqual(getStringWidth('a\u200Db'), 2);  // Joiner between letters.
+assert.strictEqual(getStringWidth('\u{1F917}\u{1F680}'), 4);
+assert.strictEqual(getStringWidth('\u26F9\uFE0F\u200D\u2642\uFE0F'), 2);  // Gender sequence.
+assert.strictEqual(getStringWidth('😀😀'), 4);
+
+// Hangul jamo form syllable blocks, spacing marks take their own column.
+assert.strictEqual(getStringWidth('\u1100\u1161'), 2);
+assert.strictEqual(getStringWidth('\u1100\u1161\u11A8'), 2);
+assert.strictEqual(getStringWidth('क\u093F'), 2);  // Devanagari vowel sign.
+
+if (common.hasIntl) {
+  assert.strictEqual(getStringWidth('\u00A0'), 1);  // No-break space.
+  assert.strictEqual(getStringWidth('ก\u0E34'), 1);  // Thai vowel mark.
+  assert.strictEqual(getStringWidth('\u00AD'), 0);  // Soft hyphen.
+  assert.strictEqual(getStringWidth('⌚'), 2);  // Emoji presentation by default.
+  assert.strictEqual(getStringWidth('\u1100\u1100\u1161'), 4);  // Unmatched jamo.
+  assert.strictEqual(getStringWidth('\u1100\u1161가'), 4);  // Jamo and a syllable.
+  assert.strictEqual(getStringWidth('\u1160'), 0);  // Jungseong filler.
+  assert.strictEqual(getStringWidth('\u1161'), 1);  // Lone vowel jamo.
+  assert.strictEqual(getStringWidth('🧑🏽\u200D🤝\u200D🧑🏻'), 2);
+  assert.strictEqual(getStringWidth('\u{E0001}'), 0);  // Language tag.
+  assert.strictEqual(getStringWidth('\u26F9\u200D\u2642'), 2);  // Unqualified sequence.
+  assert.strictEqual(getStringWidth('*\u20E3'), 2);
+  assert.strictEqual(getStringWidth('a\u20E3'), 1);  // Not a keycap base.
+  assert.strictEqual(getStringWidth('\u1100\u0301'), 2);
+  assert.strictEqual(getStringWidth('\u1100\u093F'), 3);  // Jamo with a spacing mark.
+  assert.strictEqual(getStringWidth('\u{1F1E6}\u{1F1E6}'), 1);  // Not a flag.
+  assert.strictEqual(getStringWidth('1\u0301'), 1);  // Not a keycap.
+  assert.strictEqual(getStringWidth('\u0D4E\u0D15'), 1);  // Malayalam dot reph, a prepended letter.
+}
+
+for (const value of [undefined, null, 1, true, {}, [], Symbol('s')]) {
+  assert.throws(() => getStringWidth(value), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+  });
+}
diff --git a/typings/internalBinding/icu.d.ts b/typings/internalBinding/icu.d.ts
index 7a688a5f0823..8504a5bee548 100644
--- a/typings/internalBinding/icu.d.ts
+++ b/typings/internalBinding/icu.d.ts
@@ -8,6 +8,7 @@ export interface ICUBinding {
   ): string;
   getConverter(label: string, flags: number): object | undefined;
   getStringWidth(value: string, ambiguousAsFullWidth?: boolean, expandEmojiSequence?: boolean): number;
+  getGraphemeStringWidth(value: string, ambiguousAsFullWidth?: boolean): number;
   hasConverter(label: string): boolean;
   icuErrName(status: number): string;
   transcode(