diff --git a/Cargo.lock b/Cargo.lock
index 3353a17f262..d2c91267d60 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1058,6 +1058,7 @@ dependencies = [
  "icu_timezone",
  "libc_alloc",
  "log",
+ "potential_utf",
  "serde",
  "simple_logger",
  "tinystr",
@@ -1080,6 +1081,7 @@ dependencies = [
  "icu_normalizer",
  "icu_properties",
  "icu_provider",
+ "potential_utf",
  "serde",
  "writeable",
  "zerovec",
@@ -1176,6 +1178,7 @@ dependencies = [
  "icu_provider_blob",
  "icu_timezone",
  "litemap",
+ "potential_utf",
  "serde",
  "serde_json",
  "smallvec",
@@ -1250,6 +1253,7 @@ dependencies = [
  "num-bigint",
  "num-rational",
  "num-traits",
+ "potential_utf",
  "serde",
  "smallvec",
  "tinystr",
@@ -1327,6 +1331,7 @@ dependencies = [
  "icu_locale_core",
  "icu_locale_data",
  "icu_provider",
+ "potential_utf",
  "serde",
  "serde_json",
  "tinystr",
@@ -1346,6 +1351,7 @@ dependencies = [
  "icu_benchmark_macros",
  "litemap",
  "postcard",
+ "potential_utf",
  "serde",
  "serde_json",
  "tinystr",
@@ -1454,6 +1460,7 @@ dependencies = [
  "icu_collections",
  "icu_properties_data",
  "icu_provider",
+ "potential_utf",
  "serde",
  "tinystr",
  "unicode-bidi",
@@ -1626,6 +1633,7 @@ dependencies = [
  "num-rational",
  "num-traits",
  "postcard",
+ "potential_utf",
  "serde",
  "serde-aux",
  "serde_json",
@@ -1655,6 +1663,7 @@ dependencies = [
  "icu_provider",
  "icu_segmenter_data",
  "itertools",
+ "potential_utf",
  "serde",
  "serde_json",
  "utf8_iter",
@@ -2123,6 +2132,18 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "potential_utf"
+version = "0.0.0"
+dependencies = [
+ "bincode",
+ "databake",
+ "serde",
+ "serde_json",
+ "writeable",
+ "zerovec",
+]
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -3413,6 +3434,7 @@ dependencies = [
  "iai",
  "icu_benchmark_macros",
  "postcard",
+ "potential_utf",
  "rand",
  "rand_distr",
  "rand_pcg",
diff --git a/Cargo.toml b/Cargo.toml
index 1fe118a2fcd..e9f2e036f93 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -74,6 +74,7 @@ members = [
     "utils/env_preferences",
     "utils/tinystr",
     "utils/tzif",
+    "utils/potential_utf",
     "utils/writeable",
     "utils/yoke",
     "utils/yoke/derive",
@@ -159,8 +160,8 @@ icu_provider_macros = { version = "~1.5.0", path = "provider/core/macros", defau
 icu_provider_adapters = { version = "~1.5.0", path = "provider/adapters", default-features = false }
 icu_provider_baked = { version = "~1.5.0", path = "provider/baked", default-features = false }
 icu_provider_blob = { version = "~1.5.0", path = "provider/blob", default-features = false }
-icu_provider_fs = { version = "~1.5.0", path = "provider/fs/", default-features = false }
-icu_provider_registry = { version = "~1.5.0", path = "provider/registry/", default-features = false }
+icu_provider_fs = { version = "~1.5.0", path = "provider/fs", default-features = false }
+icu_provider_registry = { version = "~1.5.0", path = "provider/registry", default-features = false }
 
 # Baked data
 icu_calendar_data = { version = "~1.5.0", path = "provider/data/calendar", default-features = false }
@@ -190,7 +191,8 @@ ixdtf = { version = "0.2.0", path = "utils/ixdtf", default-features = false }
 litemap = { version = "0.7.3", path = "utils/litemap", default-features = false }
 tinystr = { version = "0.7.5", path = "utils/tinystr", default-features = false }
 tzif = { version = "0.2.3", path = "utils/tzif", default-features = false }
-writeable = { version = "0.5.5", path = "utils/writeable/", default-features = false }
+potential_utf = { version = "0.0.0", path = "utils/potential_utf", default-features = false }
+writeable = { version = "0.5.5", path = "utils/writeable", default-features = false }
 yoke = { version = "0.7.4", path = "utils/yoke", default-features = false }
 yoke-derive = { version = "0.7.4", path = "utils/yoke/derive", default-features = false }
 zerofrom = { version = "0.1.3", path = "utils/zerofrom", default-features = false }
diff --git a/components/casemap/Cargo.toml b/components/casemap/Cargo.toml
index c86225517e2..945f0dcc3bb 100644
--- a/components/casemap/Cargo.toml
+++ b/components/casemap/Cargo.toml
@@ -25,8 +25,9 @@ icu_collections = { workspace = true }
 icu_locale_core = { workspace = true }
 icu_properties = { workspace = true }
 icu_provider = { workspace = true, features = ["macros"] }
-zerovec = { workspace = true, features = ["yoke"] }
+potential_utf = { workspace = true, features = ["zerovec"] }
 writeable = { workspace = true }
+zerovec = { workspace = true, features = ["yoke"] }
 
 databake = { workspace = true, features = ["derive"], optional = true}
 serde = { workspace = true, features = ["derive", "alloc"], optional = true }
@@ -46,7 +47,7 @@ criterion = { workspace = true }
 default = ["compiled_data"]
 std = ["icu_collections/std", "icu_provider/std"]
 bench = []
-serde = ["dep:serde", "zerovec/serde", "icu_collections/serde", "icu_provider/serde", "icu_properties/serde"]
+serde = ["dep:serde", "zerovec/serde", "icu_collections/serde", "icu_provider/serde", "icu_properties/serde", "potential_utf/serde"]
 datagen = ["serde", "dep:databake", "zerovec/databake", "icu_collections/databake"]
 compiled_data = ["dep:icu_casemap_data", "icu_properties/compiled_data"]
 
diff --git a/components/casemap/src/provider/unfold.rs b/components/casemap/src/provider/unfold.rs
index c8808159a1c..3d23e2412c1 100644
--- a/components/casemap/src/provider/unfold.rs
+++ b/components/casemap/src/provider/unfold.rs
@@ -7,7 +7,7 @@
 #[cfg(feature = "datagen")]
 use alloc::string::String;
 use icu_provider::prelude::*;
-use zerovec::ule::UnvalidatedStr;
+use potential_utf::PotentialUtf8;
 use zerovec::ZeroMap;
 
 /// Reverse case folding data. Maps from multi-character strings back
@@ -30,7 +30,7 @@ use zerovec::ZeroMap;
 pub struct CaseMapUnfoldV1<'data> {
     #[cfg_attr(feature = "serde", serde(borrow))]
     /// The actual map. Maps from strings to a list of codepoints, stored as a contiguous UTF-8 string
-    pub map: ZeroMap<'data, UnvalidatedStr, str>,
+    pub map: ZeroMap<'data, PotentialUtf8, str>,
 }
 
 impl<'data> CaseMapUnfoldV1<'data> {
@@ -80,7 +80,7 @@ impl<'data> CaseMapUnfoldV1<'data> {
             let val = Self::decode_string(&row[string_width..])
                 .ok_or(DataError::custom("Unfold: unpaired surrogate in value"))?;
             if map
-                .try_append(UnvalidatedStr::from_str(&key), val.as_ref())
+                .try_append(PotentialUtf8::from_str(&key), val.as_ref())
                 .is_some()
             {
                 return Err(DataError::custom("Unfold: keys not sorted/unique"));
@@ -99,6 +99,6 @@ impl<'data> CaseMapUnfoldV1<'data> {
     // Given a string, returns another string representing the set of characters
     // that case fold to that string.
     pub(crate) fn get(&self, key: &str) -> Option<&str> {
-        self.map.get(UnvalidatedStr::from_str(key))
+        self.map.get(PotentialUtf8::from_str(key))
     }
 }
diff --git a/components/datetime/Cargo.toml b/components/datetime/Cargo.toml
index 1d26c29f40e..3f5e0fc5f1d 100644
--- a/components/datetime/Cargo.toml
+++ b/components/datetime/Cargo.toml
@@ -31,6 +31,7 @@ icu_provider = { workspace = true, features = ["macros"] }
 icu_timezone = { workspace = true }
 smallvec = { workspace = true }
 tinystr = { workspace = true, features = ["alloc", "zerovec"] }
+potential_utf = { workspace = true, features = ["zerovec"] }
 writeable = { workspace = true }
 zerovec = { workspace = true, features = ["yoke"] }
 
@@ -78,6 +79,7 @@ serde = [
     "litemap?/serde",
     "smallvec/serde",
     "tinystr/serde",
+    "potential_utf/serde",
     "zerovec/serde",
 ]
 datagen = [
diff --git a/components/datetime/src/provider/calendar/symbols.rs b/components/datetime/src/provider/calendar/symbols.rs
index 535c00b3dd6..4e8dc118b45 100644
--- a/components/datetime/src/provider/calendar/symbols.rs
+++ b/components/datetime/src/provider/calendar/symbols.rs
@@ -8,8 +8,9 @@
 use alloc::borrow::Cow;
 use icu_calendar::types::MonthCode;
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use tinystr::{tinystr, TinyStr4};
-use zerovec::{ule::UnvalidatedStr, ZeroMap};
+use zerovec::ZeroMap;
 
 size_test!(DateSymbolsV1, date_symbols_v1_size, 3792);
 
@@ -123,17 +124,17 @@ pub struct Eras<'data> {
     ///
     /// Keys are era codes, and values are display names. See [`Eras`].
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub names: ZeroMap<'data, UnvalidatedStr, str>,
+    pub names: ZeroMap<'data, PotentialUtf8, str>,
     /// Symbol data for era abbreviations.
     ///
     /// Keys are era codes, and values are display names. See [`Eras`].
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub abbr: ZeroMap<'data, UnvalidatedStr, str>,
+    pub abbr: ZeroMap<'data, PotentialUtf8, str>,
     /// Symbol data for era narrow forms.
     ///
     /// Keys are era codes, and values are display names. See [`Eras`].
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub narrow: ZeroMap<'data, UnvalidatedStr, str>,
+    pub narrow: ZeroMap<'data, PotentialUtf8, str>,
 }
 
 // Note: the SymbolsV* struct doc strings metadata are attached to `$name` in the macro invocation to
diff --git a/components/datetime/src/provider/neo.rs b/components/datetime/src/provider/neo.rs
index d29290d4ba1..4549a28c7c4 100644
--- a/components/datetime/src/provider/neo.rs
+++ b/components/datetime/src/provider/neo.rs
@@ -7,8 +7,11 @@ mod adapter;
 use crate::pattern::runtime::{self, PatternULE};
 use alloc::borrow::Cow;
 use icu_provider::prelude::*;
-use zerovec::ule::{AsULE, UnvalidatedStr, ULE};
-use zerovec::{VarZeroVec, ZeroMap};
+use potential_utf::PotentialUtf8;
+use zerovec::{
+    ule::{AsULE, ULE},
+    VarZeroVec, ZeroMap,
+};
 
 #[cfg(feature = "experimental")]
 use crate::neo_skeleton::NeoSkeletonLength;
@@ -356,7 +359,7 @@ size_test!(YearNamesV1, year_names_v1_size, 48);
 pub enum YearNamesV1<'data> {
     /// This calendar uses eras with numeric years, this stores the era names mapped from
     /// era code to the name
-    Eras(#[cfg_attr(feature = "serde", serde(borrow))] ZeroMap<'data, UnvalidatedStr, str>),
+    Eras(#[cfg_attr(feature = "serde", serde(borrow))] ZeroMap<'data, PotentialUtf8, str>),
     /// This calendar is cyclic (Chinese, Dangi), so it uses cyclic year names without any eras
     Cyclic(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
 }
diff --git a/components/experimental/Cargo.toml b/components/experimental/Cargo.toml
index 2b0c3241e19..15837b20907 100644
--- a/components/experimental/Cargo.toml
+++ b/components/experimental/Cargo.toml
@@ -40,6 +40,7 @@ fixed_decimal = { workspace = true }
 icu_pattern = { workspace = true , features = ["alloc", "yoke", "zerofrom"]}
 litemap = { workspace = true }
 tinystr = { workspace = true, features = ["alloc", "zerovec"] }
+potential_utf = { workspace = true, features = ["zerovec"] }
 writeable = { workspace = true }
 zerotrie = { workspace = true, features = ["yoke", "zerofrom"] }
 zerovec = { workspace = true, features = ["derive", "yoke"] }
@@ -70,7 +71,7 @@ default = ["compiled_data"]
 compiled_data = ["dep:icu_experimental_data", "icu_decimal/compiled_data", "icu_list/compiled_data", "icu_plurals/compiled_data", "icu_properties/compiled_data", "icu_normalizer/compiled_data"]
 datagen = ["serde", "std", "dep:databake", "zerovec/databake", "zerotrie/databake", "tinystr/databake", "icu_collections/databake", "std", "log", "icu_pattern/databake"]
 ryu = ["fixed_decimal/ryu"]
-serde = ["dep:serde", "zerovec/serde", "tinystr/serde", "icu_collections/serde", "icu_decimal/serde", "icu_list/serde", "icu_pattern/serde", "icu_plurals/serde", "icu_provider/serde", "zerotrie/serde"]
+serde = ["dep:serde", "zerovec/serde", "potential_utf/serde", "tinystr/serde", "icu_collections/serde", "icu_decimal/serde", "icu_list/serde", "icu_pattern/serde", "icu_plurals/serde", "icu_provider/serde", "zerotrie/serde"]
 std = ["fixed_decimal/std", "icu_decimal/std", "icu_pattern/std", "icu_plurals/std", "icu_provider/std", "icu_locale_core/std"]
 
 bench = []
diff --git a/components/experimental/src/displaynames/displaynames.rs b/components/experimental/src/displaynames/displaynames.rs
index 85cb862286d..7f37f0274fd 100644
--- a/components/experimental/src/displaynames/displaynames.rs
+++ b/components/experimental/src/displaynames/displaynames.rs
@@ -13,7 +13,7 @@ use icu_locale_core::{
     Locale,
 };
 use icu_provider::prelude::*;
-use zerovec::ule::UnvalidatedStr;
+use potential_utf::PotentialUtf8;
 
 /// Lookup of the locale-specific display names by region code.
 ///
@@ -411,7 +411,7 @@ impl LocaleDisplayNamesFormatter {
             if let Some(script) = locale.id.script {
                 let data = self.locale_data.get();
                 let id = LanguageIdentifier::from((locale.id.language, Some(script), None));
-                let cmp = |uvstr: &UnvalidatedStr| id.strict_cmp(uvstr).reverse();
+                let cmp = |uvstr: &PotentialUtf8| id.strict_cmp(uvstr).reverse();
                 if let Some(x) = match self.options.style {
                     Some(Style::Short) => data.short_names.get_by(cmp),
                     Some(Style::Long) => data.long_names.get_by(cmp),
@@ -429,7 +429,7 @@ impl LocaleDisplayNamesFormatter {
                 if let Some(region) = locale.id.region {
                     let data = self.locale_data.get();
                     let id = LanguageIdentifier::from((locale.id.language, None, Some(region)));
-                    let cmp = |uvstr: &UnvalidatedStr| id.strict_cmp(uvstr).reverse();
+                    let cmp = |uvstr: &PotentialUtf8| id.strict_cmp(uvstr).reverse();
                     if let Some(x) = match self.options.style {
                         Some(Style::Short) => data.short_names.get_by(cmp),
                         Some(Style::Long) => data.long_names.get_by(cmp),
diff --git a/components/experimental/src/displaynames/provider.rs b/components/experimental/src/displaynames/provider.rs
index 3bcf2238504..5c6623be13a 100644
--- a/components/experimental/src/displaynames/provider.rs
+++ b/components/experimental/src/displaynames/provider.rs
@@ -10,8 +10,8 @@
 //! Read more about data providers: [`icu_provider`]
 
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use tinystr::UnvalidatedTinyAsciiStr;
-use zerovec::ule::UnvalidatedStr;
 use zerovec::ZeroMap;
 
 // We use raw TinyAsciiStrs for map keys, as we then don't have to
@@ -21,7 +21,7 @@ use zerovec::ZeroMap;
 type UnvalidatedRegion = UnvalidatedTinyAsciiStr<3>;
 type UnvalidatedLanguage = UnvalidatedTinyAsciiStr<3>;
 type UnvalidatedScript = UnvalidatedTinyAsciiStr<4>;
-type UnvalidatedLocale = UnvalidatedStr;
+type UnvalidatedLocale = PotentialUtf8;
 type UnvalidatedVariant = UnvalidatedTinyAsciiStr<8>;
 
 #[cfg(feature = "compiled_data")]
diff --git a/components/locale/Cargo.toml b/components/locale/Cargo.toml
index ee88605e01d..31f238609e4 100644
--- a/components/locale/Cargo.toml
+++ b/components/locale/Cargo.toml
@@ -25,13 +25,14 @@ denylist = ["bench"]
 all-features = true
 
 [dependencies]
+databake = { workspace = true, optional = true, features = ["derive"] }
+displaydoc = { workspace = true }
 icu_locale_core = { workspace = true, features = ["zerovec"] }
 icu_provider = { workspace = true, features = ["macros"] }
 serde = { workspace = true, features = ["derive", "alloc"], optional = true }
 tinystr = { workspace = true, features = ["alloc", "zerovec"] }
+potential_utf = { workspace = true, features = ["zerovec"] }
 zerovec = { workspace = true,  features = ["yoke"] }
-databake = { workspace = true, optional = true, features = ["derive"] }
-displaydoc = { workspace = true }
 
 icu_locale_data = { workspace = true, optional = true }
 
@@ -51,7 +52,7 @@ bench = false  # This option is required for Benchmark CI
 default = ["compiled_data"]
 std = []
 bench = ["serde"]
-serde = ["dep:serde", "icu_locale_core/serde", "tinystr/serde", "zerovec/serde", "icu_provider/serde"]
+serde = ["dep:serde", "icu_locale_core/serde", "tinystr/serde", "zerovec/serde", "icu_provider/serde", "potential_utf/serde"]
 datagen = ["serde", "dep:databake", "zerovec/databake", "icu_locale_core/databake", "tinystr/databake"]
 compiled_data = ["dep:icu_locale_data"]
 
diff --git a/components/locale/src/provider.rs b/components/locale/src/provider.rs
index b99740178f3..69344f5c833 100644
--- a/components/locale/src/provider.rs
+++ b/components/locale/src/provider.rs
@@ -56,8 +56,9 @@ pub const MARKERS: &[DataMarkerInfo] = &[
 use alloc::borrow::Cow;
 use icu_locale_core::subtags::{Language, Region, Script, Variant};
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use tinystr::{TinyAsciiStr, UnvalidatedTinyAsciiStr};
-use zerovec::{ule::UnvalidatedStr, VarZeroVec, ZeroMap, ZeroSlice, ZeroVec};
+use zerovec::{VarZeroVec, ZeroMap, ZeroSlice, ZeroVec};
 
 // We use raw TinyAsciiStrs for map keys, as we then don't have to
 // validate them as subtags on deserialization. Map lookup can be
@@ -347,7 +348,7 @@ pub struct ParentsV1<'data> {
     /// Map from language identifier to language identifier, indicating that the language on the
     /// left should inherit from the language on the right.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub parents: ZeroMap<'data, UnvalidatedStr, (Language, Option<Script>, Option<Region>)>,
+    pub parents: ZeroMap<'data, PotentialUtf8, (Language, Option<Script>, Option<Region>)>,
 }
 
 #[icu_provider::data_struct(marker(ScriptDirectionV1Marker, "locale/script_dir@1", singleton))]
diff --git a/components/locale_core/Cargo.toml b/components/locale_core/Cargo.toml
index 567dbc77834..2f1e6200422 100644
--- a/components/locale_core/Cargo.toml
+++ b/components/locale_core/Cargo.toml
@@ -35,6 +35,7 @@ icu = { path = "../../components/icu", default-features = false }
 icu_benchmark_macros = { path = "../../tools/benchmark/macros" }
 litemap = { path = "../../utils/litemap", features = ["testing"]}
 postcard = { workspace = true, features = ["use-std"] }
+potential_utf = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 
diff --git a/components/locale_core/src/zerovec.rs b/components/locale_core/src/zerovec.rs
index 2d7f7af904d..cab3f717598 100644
--- a/components/locale_core/src/zerovec.rs
+++ b/components/locale_core/src/zerovec.rs
@@ -19,22 +19,22 @@
 //! To perform lookup, store the stringified locale in a canonical BCP-47 form as a byte array,
 //! and then use [`Locale::strict_cmp()`] to perform an efficient, zero-allocation lookup.
 //!
-//! To produce more human-readable serialized output, you can use `UnvalidatedStr`.
+//! To produce more human-readable serialized output, you can use `PotentialUtf8`.
 //!
 //! ```
 //! use icu::locale::Locale;
-//! use zerovec::ule::UnvalidatedStr;
+//! use potential_utf::PotentialUtf8;
 //! use zerovec::ZeroMap;
 //!
 //! // ZeroMap from locales to integers
-//! let data: &[(&UnvalidatedStr, u32)] = &[
+//! let data: &[(&PotentialUtf8, u32)] = &[
 //!     ("de-DE-u-hc-h12".into(), 5),
 //!     ("en-US-u-ca-buddhist".into(), 10),
 //!     ("my-MM".into(), 15),
 //!     ("sr-Cyrl-ME".into(), 20),
 //!     ("zh-TW".into(), 25),
 //! ];
-//! let zm: ZeroMap<UnvalidatedStr, u32> = data.iter().copied().collect();
+//! let zm: ZeroMap<PotentialUtf8, u32> = data.iter().copied().collect();
 //!
 //! // Get the value associated with a locale
 //! let loc: Locale = "en-US-u-ca-buddhist".parse().unwrap();
@@ -96,16 +96,16 @@
 //! for a discussion on potential data models that could ensure that the locale is valid during
 //! deserialization.
 //!
-//! As above, to produce more human-readable serialized output, you can use `UnvalidatedStr`.
+//! As above, to produce more human-readable serialized output, you can use `PotentialUtf8`.
 //!
 //! ```
 //! use icu::locale::langid;
 //! use icu::locale::Locale;
-//! use zerovec::ule::UnvalidatedStr;
+//! use potential_utf::PotentialUtf8;
 //! use zerovec::ZeroMap;
 //!
 //! // ZeroMap from integer to locale string
-//! let data: &[(u32, &UnvalidatedStr)] = &[
+//! let data: &[(u32, &PotentialUtf8)] = &[
 //!     (5, "de-DE-u-hc-h12".into()),
 //!     (10, "en-US-u-ca-buddhist".into()),
 //!     (15, "my-MM".into()),
@@ -113,7 +113,7 @@
 //!     (25, "zh-TW".into()),
 //!     (30, "INVALID".into()),
 //! ];
-//! let zm: ZeroMap<u32, UnvalidatedStr> = data.iter().copied().collect();
+//! let zm: ZeroMap<u32, PotentialUtf8> = data.iter().copied().collect();
 //!
 //! // Construct a Locale by parsing the string.
 //! let value = zm.get(&25).expect("element is present");
diff --git a/components/properties/Cargo.toml b/components/properties/Cargo.toml
index f3b99b6e955..3bf4b25924e 100644
--- a/components/properties/Cargo.toml
+++ b/components/properties/Cargo.toml
@@ -27,6 +27,7 @@ zerovec = { workspace = true, features = ["derive"] }
 databake = { workspace = true, features = ["derive"], optional = true}
 serde = { workspace = true, features = ["derive", "alloc"], optional = true }
 tinystr = { workspace = true, features = ["alloc", "zerovec"] }
+potential_utf = { workspace = true, features = ["zerovec"]}
 
 unicode-bidi = { workspace = true, optional = true }
 
@@ -38,7 +39,7 @@ icu = { path = "../../components/icu", default-features = false }
 [features]
 default = ["compiled_data"]
 std = ["icu_collections/std", "icu_provider/std"]
-serde = ["dep:serde", "tinystr/serde", "zerovec/serde", "icu_collections/serde", "icu_provider/serde"]
-datagen = ["serde", "dep:databake", "zerovec/databake", "icu_collections/databake", "tinystr/databake"]
+serde = ["dep:serde", "tinystr/serde", "potential_utf/serde", "zerovec/serde", "icu_collections/serde", "icu_provider/serde"]
+datagen = ["serde", "dep:databake", "potential_utf/databake", "zerovec/databake", "icu_collections/databake", "tinystr/databake"]
 bidi = [ "dep:unicode-bidi" ]
 compiled_data = ["dep:icu_properties_data"]
diff --git a/components/properties/src/provider/names.rs b/components/properties/src/provider/names.rs
index 784c707c520..77382dc4500 100644
--- a/components/properties/src/provider/names.rs
+++ b/components/properties/src/provider/names.rs
@@ -17,8 +17,9 @@ use core::cmp::Ordering;
 
 use icu_provider::prelude::*;
 
+use potential_utf::PotentialUtf8;
 use tinystr::TinyStr4;
-use zerovec::ule::{UnvalidatedStr, VarULE};
+use zerovec::ule::VarULE;
 use zerovec::{maps::ZeroMapKV, VarZeroSlice, VarZeroVec, ZeroMap, ZeroVec};
 
 /// This is a property name that can be "loose matched" as according to
@@ -69,7 +70,7 @@ use zerovec::{maps::ZeroMapKV, VarZeroSlice, VarZeroVec, ZeroMap, ZeroVec};
 #[derive(Debug, VarULE)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
 #[repr(transparent)]
-pub struct NormalizedPropertyNameStr(UnvalidatedStr);
+pub struct NormalizedPropertyNameStr(PotentialUtf8);
 
 /// This impl requires enabling the optional `serde` Cargo feature of the `icu::properties` crate
 #[cfg(feature = "serde")]
@@ -78,7 +79,7 @@ impl<'de> serde::Deserialize<'de> for Box<NormalizedPropertyNameStr> {
     where
         D: serde::Deserializer<'de>,
     {
-        <Box<UnvalidatedStr>>::deserialize(deserializer).map(NormalizedPropertyNameStr::cast_box)
+        <Box<PotentialUtf8>>::deserialize(deserializer).map(NormalizedPropertyNameStr::cast_box)
     }
 }
 
@@ -92,7 +93,7 @@ where
     where
         D: serde::Deserializer<'de>,
     {
-        <&UnvalidatedStr>::deserialize(deserializer).map(NormalizedPropertyNameStr::cast_ref)
+        <&PotentialUtf8>::deserialize(deserializer).map(NormalizedPropertyNameStr::cast_ref)
     }
 }
 
@@ -156,24 +157,24 @@ impl NormalizedPropertyNameStr {
 
     /// Convert a string reference to a [`NormalizedPropertyNameStr`].
     pub const fn from_str(s: &str) -> &Self {
-        Self::cast_ref(UnvalidatedStr::from_str(s))
+        Self::cast_ref(PotentialUtf8::from_str(s))
     }
 
-    /// Convert a [`UnvalidatedStr`] reference to a [`NormalizedPropertyNameStr`] reference.
-    pub const fn cast_ref(value: &UnvalidatedStr) -> &Self {
+    /// Convert a [`PotentialUtf8`] reference to a [`NormalizedPropertyNameStr`] reference.
+    pub const fn cast_ref(value: &PotentialUtf8) -> &Self {
         // Safety: repr(transparent)
         unsafe { core::mem::transmute(value) }
     }
 
-    /// Convert a [`UnvalidatedStr`] box to a [`NormalizedPropertyNameStr`] box.
-    pub const fn cast_box(value: Box<UnvalidatedStr>) -> Box<Self> {
+    /// Convert a [`PotentialUtf8`] box to a [`NormalizedPropertyNameStr`] box.
+    pub const fn cast_box(value: Box<PotentialUtf8>) -> Box<Self> {
         // Safety: repr(transparent)
         unsafe { core::mem::transmute(value) }
     }
 
     /// Get a [`NormalizedPropertyNameStr`] box from a byte slice.
     pub fn boxed_from_bytes(b: &[u8]) -> Box<Self> {
-        Self::cast_box(UnvalidatedStr::from_boxed_bytes(b.into()))
+        Self::cast_box(PotentialUtf8::from_boxed_bytes(b.into()))
     }
 }
 
diff --git a/components/segmenter/Cargo.toml b/components/segmenter/Cargo.toml
index 7fecfd8090d..5f73cef2ab5 100644
--- a/components/segmenter/Cargo.toml
+++ b/components/segmenter/Cargo.toml
@@ -29,6 +29,7 @@ zerovec = { workspace = true, features = ["yoke"] }
 
 databake = { workspace = true, optional = true, features = ["derive"] }
 serde = { workspace = true, features = ["derive", "alloc"], optional = true }
+potential_utf = { workspace = true, features = ["zerovec"] }
 
 core_maths = { workspace = true, optional = true }
 
@@ -47,8 +48,8 @@ criterion = { workspace = true }
 [features]
 default = ["compiled_data", "auto"]
 std = ["icu_collections/std", "icu_locale_core/std", "icu_provider/std"]
-serde = ["dep:serde", "zerovec/serde", "icu_collections/serde", "icu_provider/serde"]
-datagen = ["serde", "dep:databake", "zerovec/databake", "icu_collections/databake"]
+serde = ["dep:serde", "potential_utf/serde", "zerovec/serde", "icu_collections/serde", "icu_provider/serde"]
+datagen = ["serde", "dep:databake", "potential_utf/databake", "zerovec/databake", "icu_collections/databake"]
 lstm = ["dep:core_maths"]
 auto = ["lstm"] # Enabled try_new_auto_unstable constructors
 compiled_data = ["dep:icu_segmenter_data"]
diff --git a/components/segmenter/src/complex/lstm/mod.rs b/components/segmenter/src/complex/lstm/mod.rs
index beba48838b4..6406daefd30 100644
--- a/components/segmenter/src/complex/lstm/mod.rs
+++ b/components/segmenter/src/complex/lstm/mod.rs
@@ -6,7 +6,8 @@ use crate::grapheme::GraphemeClusterSegmenter;
 use crate::provider::*;
 use alloc::vec::Vec;
 use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
-use zerovec::{maps::ZeroMapBorrowed, ule::UnvalidatedStr};
+use potential_utf::PotentialUtf8;
+use zerovec::maps::ZeroMapBorrowed;
 
 mod matrix;
 use matrix::*;
@@ -53,7 +54,7 @@ impl Iterator for LstmSegmenterIteratorUtf16<'_> {
 }
 
 pub(super) struct LstmSegmenter<'l> {
-    dic: ZeroMapBorrowed<'l, UnvalidatedStr, u16>,
+    dic: ZeroMapBorrowed<'l, PotentialUtf8, u16>,
     embedding: MatrixZero<'l, 2>,
     fw_w: MatrixZero<'l, 3>,
     fw_u: MatrixZero<'l, 3>,
@@ -116,7 +117,7 @@ impl<'l> LstmSegmenter<'l> {
                     };
 
                     self.dic
-                        .get_copied(UnvalidatedStr::from_str(grapheme_cluster))
+                        .get_copied(PotentialUtf8::from_str(grapheme_cluster))
                         .unwrap_or_else(|| self.dic.len() as u16)
                 })
                 .collect()
@@ -125,7 +126,7 @@ impl<'l> LstmSegmenter<'l> {
                 .chars()
                 .map(|c| {
                     self.dic
-                        .get_copied(UnvalidatedStr::from_str(c.encode_utf8(&mut [0; 4])))
+                        .get_copied(PotentialUtf8::from_str(c.encode_utf8(&mut [0; 4])))
                         .unwrap_or_else(|| self.dic.len() as u16)
                 })
                 .collect()
@@ -176,7 +177,7 @@ impl<'l> LstmSegmenter<'l> {
                 .map(|c| c.unwrap_or(REPLACEMENT_CHARACTER))
                 .map(|c| {
                     self.dic
-                        .get_copied(UnvalidatedStr::from_str(c.encode_utf8(&mut [0; 4])))
+                        .get_copied(PotentialUtf8::from_str(c.encode_utf8(&mut [0; 4])))
                         .unwrap_or_else(|| self.dic.len() as u16)
                 })
                 .collect()
diff --git a/components/segmenter/src/provider/lstm.rs b/components/segmenter/src/provider/lstm.rs
index eb7185b443d..03c72321e0f 100644
--- a/components/segmenter/src/provider/lstm.rs
+++ b/components/segmenter/src/provider/lstm.rs
@@ -8,7 +8,8 @@
 #![allow(clippy::exhaustive_structs, clippy::exhaustive_enums)]
 
 use icu_provider::prelude::*;
-use zerovec::{ule::UnvalidatedStr, ZeroMap, ZeroVec};
+use potential_utf::PotentialUtf8;
+use zerovec::{ZeroMap, ZeroVec};
 
 // We do this instead of const generics because ZeroFrom and Yokeable derives, as well as serde
 // don't support them
@@ -134,7 +135,7 @@ pub struct LstmDataFloat32<'data> {
     /// Type of the model
     pub(crate) model: ModelType,
     /// The grapheme cluster dictionary used to train the model
-    pub(crate) dic: ZeroMap<'data, UnvalidatedStr, u16>,
+    pub(crate) dic: ZeroMap<'data, PotentialUtf8, u16>,
     /// The embedding layer. Shape (dic.len + 1, e)
     pub(crate) embedding: LstmMatrix2<'data>,
     /// The forward layer's first matrix. Shape (h, 4, e)
@@ -160,7 +161,7 @@ impl<'data> LstmDataFloat32<'data> {
     #[allow(clippy::too_many_arguments)] // constructor
     pub const fn from_parts_unchecked(
         model: ModelType,
-        dic: ZeroMap<'data, UnvalidatedStr, u16>,
+        dic: ZeroMap<'data, PotentialUtf8, u16>,
         embedding: LstmMatrix2<'data>,
         fw_w: LstmMatrix3<'data>,
         fw_u: LstmMatrix3<'data>,
@@ -191,7 +192,7 @@ impl<'data> LstmDataFloat32<'data> {
     #[allow(clippy::too_many_arguments)] // constructor
     pub fn try_from_parts(
         model: ModelType,
-        dic: ZeroMap<'data, UnvalidatedStr, u16>,
+        dic: ZeroMap<'data, PotentialUtf8, u16>,
         embedding: LstmMatrix2<'data>,
         fw_w: LstmMatrix3<'data>,
         fw_u: LstmMatrix3<'data>,
@@ -252,7 +253,7 @@ impl<'de: 'data, 'data> serde::Deserialize<'de> for LstmDataFloat32<'data> {
         struct Raw<'data> {
             model: ModelType,
             #[cfg_attr(feature = "serde", serde(borrow))]
-            dic: ZeroMap<'data, UnvalidatedStr, u16>,
+            dic: ZeroMap<'data, PotentialUtf8, u16>,
             #[cfg_attr(feature = "serde", serde(borrow))]
             embedding: LstmMatrix2<'data>,
             #[cfg_attr(feature = "serde", serde(borrow))]
diff --git a/ffi/capi/Cargo.toml b/ffi/capi/Cargo.toml
index 14d2fc32945..5d45da3b814 100644
--- a/ffi/capi/Cargo.toml
+++ b/ffi/capi/Cargo.toml
@@ -121,6 +121,7 @@ icu_provider = { workspace = true }
 icu_provider_adapters = { workspace = true }
 
 tinystr = { workspace = true }
+potential_utf = { workspace = true, features = ["writeable"]}
 writeable = { workspace = true }
 
 # Diplomat
diff --git a/ffi/capi/src/lib.rs b/ffi/capi/src/lib.rs
index 39bee9fede2..aa76bcfb3ca 100644
--- a/ffi/capi/src/lib.rs
+++ b/ffi/capi/src/lib.rs
@@ -63,7 +63,6 @@ pub mod locale_core;
 pub mod logging;
 #[macro_use]
 pub mod provider;
-mod utf;
 
 // Components
 
diff --git a/ffi/capi/src/list.rs b/ffi/capi/src/list.rs
index 017d89dd9c1..8f44236d640 100644
--- a/ffi/capi/src/list.rs
+++ b/ffi/capi/src/list.rs
@@ -90,8 +90,8 @@ pub mod ffi {
                 .format(
                     list.iter()
                         .copied()
-                        .map(crate::utf::PotentiallyInvalidUtf8)
-                        .map(crate::utf::LossyWrap),
+                        .map(potential_utf::PotentialUtf8::from_bytes)
+                        .map(writeable::adapters::LossyWrap),
                 )
                 .write_to(write);
         }
@@ -107,8 +107,8 @@ pub mod ffi {
                 .format(
                     list.iter()
                         .copied()
-                        .map(crate::utf::PotentiallyInvalidUtf16)
-                        .map(crate::utf::LossyWrap),
+                        .map(potential_utf::PotentialUtf16::from_slice)
+                        .map(writeable::adapters::LossyWrap),
                 )
                 .write_to(write);
         }
diff --git a/provider/source/Cargo.toml b/provider/source/Cargo.toml
index 8f64fb31cd0..e3f9b4961e3 100644
--- a/provider/source/Cargo.toml
+++ b/provider/source/Cargo.toml
@@ -44,6 +44,7 @@ icu_provider_adapters = { workspace = true }
 icu_provider_registry = { workspace = true }
 litemap = { workspace = true, features = ["serde"] }
 tinystr = { workspace = true, features = ["alloc", "serde", "zerovec"] }
+potential_utf = { workspace = true }
 writeable = { workspace = true }
 zerotrie = { workspace = true, features = ["alloc"] }
 zerovec = { workspace = true, features = ["serde", "yoke"] }
diff --git a/provider/source/src/datetime/neo.rs b/provider/source/src/datetime/neo.rs
index 1de42147df1..99dbf42a140 100644
--- a/provider/source/src/datetime/neo.rs
+++ b/provider/source/src/datetime/neo.rs
@@ -13,10 +13,10 @@ use icu::datetime::provider::neo::marker_attrs::{self, Context, Length, PatternL
 use icu::datetime::provider::neo::*;
 use icu::locale::extensions::unicode::{value, Value};
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use std::borrow::Cow;
 use std::collections::{BTreeMap, HashSet};
 use tinystr::TinyAsciiStr;
-use zerovec::ule::UnvalidatedStr;
 
 /// Most keys don't have short symbols (except weekdays)
 ///
@@ -351,7 +351,7 @@ fn eras_convert(
     Ok(YearNamesV1::Eras(
         out_eras
             .iter()
-            .map(|(k, v)| (UnvalidatedStr::from_str(k), &**v))
+            .map(|(k, v)| (PotentialUtf8::from_str(k), &**v))
             .collect(),
     ))
 }
diff --git a/provider/source/src/displaynames/language.rs b/provider/source/src/displaynames/language.rs
index 22b8af90854..3ef8b0cc46f 100644
--- a/provider/source/src/displaynames/language.rs
+++ b/provider/source/src/displaynames/language.rs
@@ -9,8 +9,8 @@ use crate::SourceDataProvider;
 use icu::experimental::displaynames::provider::*;
 use icu::locale::subtags::Language;
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use std::collections::{BTreeMap, HashSet};
-use zerovec::ule::UnvalidatedStr;
 
 impl DataProvider<LanguageDisplayNamesV1Marker> for SourceDataProvider {
     fn load(
@@ -175,22 +175,22 @@ impl From<&cldr_serde::displaynames::language::Resource> for LocaleDisplayNamesV
             names: names
                 .into_iter()
                 .filter(|&(k, v)| k != v)
-                .map(|(k, v)| (UnvalidatedStr::from_str(k), v))
+                .map(|(k, v)| (PotentialUtf8::from_str(k), v))
                 .collect(),
             short_names: short_names
                 .into_iter()
                 .filter(|&(k, v)| k != v)
-                .map(|(k, v)| (UnvalidatedStr::from_str(k), v))
+                .map(|(k, v)| (PotentialUtf8::from_str(k), v))
                 .collect(),
             long_names: long_names
                 .into_iter()
                 .filter(|&(k, v)| k != v)
-                .map(|(k, v)| (UnvalidatedStr::from_str(k), v))
+                .map(|(k, v)| (PotentialUtf8::from_str(k), v))
                 .collect(),
             menu_names: menu_names
                 .into_iter()
                 .filter(|&(k, v)| k != v)
-                .map(|(k, v)| (UnvalidatedStr::from_str(k), v))
+                .map(|(k, v)| (PotentialUtf8::from_str(k), v))
                 .collect(),
         }
     }
@@ -300,7 +300,7 @@ mod tests {
         assert_eq!(
             data.get()
                 .names
-                .get(UnvalidatedStr::from_str("de-CH"))
+                .get(PotentialUtf8::from_str("de-CH"))
                 .unwrap(),
             "Swiss High German"
         );
diff --git a/provider/source/src/locale/parents.rs b/provider/source/src/locale/parents.rs
index a6297508b0a..6a6a162961c 100644
--- a/provider/source/src/locale/parents.rs
+++ b/provider/source/src/locale/parents.rs
@@ -8,9 +8,9 @@ use crate::SourceDataProvider;
 use icu::locale::provider::*;
 use icu::locale::subtags::{Language, Region, Script};
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use std::collections::{BTreeMap, HashSet};
 use writeable::Writeable;
-use zerovec::ule::UnvalidatedStr;
 
 impl DataProvider<ParentsV1Marker> for SourceDataProvider {
     fn load(&self, req: DataRequest) -> Result<DataResponse<ParentsV1Marker>, DataError> {
@@ -50,7 +50,7 @@ impl From<&cldr_serde::parent_locales::Resource> for ParentsV1<'static> {
         ParentsV1 {
             parents: parents
                 .iter()
-                .map(|(k, v)| (<&UnvalidatedStr>::from(k.as_ref()), v))
+                .map(|(k, v)| (<&PotentialUtf8>::from(k.as_ref()), v))
                 .collect(),
         }
     }
diff --git a/provider/source/src/segmenter/lstm.rs b/provider/source/src/segmenter/lstm.rs
index f868e4e08ee..d7dfea84fbe 100644
--- a/provider/source/src/segmenter/lstm.rs
+++ b/provider/source/src/segmenter/lstm.rs
@@ -12,9 +12,10 @@ use icu::segmenter::provider::{
 };
 use icu_provider::prelude::*;
 use ndarray::{Array, Array1, Array2, ArrayBase, Dim, Dimension, OwnedRepr};
+use potential_utf::PotentialUtf8;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Debug;
-use zerovec::{ule::UnvalidatedStr, ZeroVec};
+use zerovec::ZeroVec;
 
 // ndarray data structure in LSTM JSON data.
 #[derive(serde::Deserialize, Debug)]
@@ -136,7 +137,7 @@ impl RawLstmData {
             model,
             self.dic
                 .iter()
-                .map(|(k, &v)| (UnvalidatedStr::from_str(k), v))
+                .map(|(k, &v)| (PotentialUtf8::from_str(k), v))
                 .collect(),
             ndarray_to_lstm_matrix2(embedding)?,
             ndarray_to_lstm_matrix3(fw_w)?,
diff --git a/tools/make/depcheck/src/allowlist.rs b/tools/make/depcheck/src/allowlist.rs
index f62fc167086..cea4bbba42e 100644
--- a/tools/make/depcheck/src/allowlist.rs
+++ b/tools/make/depcheck/src/allowlist.rs
@@ -32,6 +32,7 @@ pub const BASIC_RUNTIME_DEPS: &[&str] = &[
     "icu_provider",
     "litemap",
     "tinystr",
+    "potential_utf",
     "writeable",
     "yoke",
     "zerofrom",
diff --git a/tutorials/.cargo/config.toml b/tutorials/.cargo/config.toml
index 27001c12583..063dfa0b546 100644
--- a/tutorials/.cargo/config.toml
+++ b/tutorials/.cargo/config.toml
@@ -72,6 +72,7 @@ ixdtf = { path = "../utils/ixdtf" }
 litemap = { path = "../utils/litemap" }
 tinystr = { path = "../utils/tinystr" }
 tzif = { path = "../utils/tzif" }
+potential_utf = { path = "../utils/potential_utf/" }
 writeable = { path = "../utils/writeable/" }
 yoke = { path = "../utils/yoke" }
 yoke-derive = { path = "../utils/yoke/derive" }
diff --git a/utils/potential_utf/Cargo.toml b/utils/potential_utf/Cargo.toml
new file mode 100644
index 00000000000..57f3d2687a6
--- /dev/null
+++ b/utils/potential_utf/Cargo.toml
@@ -0,0 +1,32 @@
+# This file is part of ICU4X. For terms of use, please see the file
+# called LICENSE at the top level of the ICU4X source tree
+# (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+[package]
+name = "potential_utf"
+version = "0.0.0"
+rust-version.workspace = true
+authors.workspace = true
+edition.workspace = true
+repository.workspace = true
+homepage.workspace = true
+license.workspace = true
+categories.workspace = true
+include.workspace = true
+
+[dependencies]
+databake = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+zerovec = { workspace = true, optional = true }
+writeable = { workspace = true, optional = true }
+
+[dev-dependencies]
+serde_json = "1"
+bincode = "1"
+
+[features]
+alloc = ["serde?/alloc"]
+databake = ["dep:databake"]
+serde = ["dep:serde"]
+writeable = ["dep:writeable", "alloc"]
+zerovec = ["dep:zerovec", "alloc"]
\ No newline at end of file
diff --git a/utils/potential_utf/LICENSE b/utils/potential_utf/LICENSE
new file mode 100644
index 00000000000..c9be6012c53
--- /dev/null
+++ b/utils/potential_utf/LICENSE
@@ -0,0 +1,46 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2020-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0
+
+—
+
+Portions of ICU4X may have been adapted from ICU4C and/or ICU4J.
+ICU 1.8.1 to ICU 57.1 © 1995-2016 International Business Machines Corporation and others.
diff --git a/utils/potential_utf/README.md b/utils/potential_utf/README.md
new file mode 100644
index 00000000000..5251f098de0
--- /dev/null
+++ b/utils/potential_utf/README.md
@@ -0,0 +1,11 @@
+# unvalidated_utf [![crates.io](https://img.shields.io/crates/v/unvalidated_utf)](https://crates.io/crates/unvalidated_utf)
+
+<!-- cargo-rdme start -->
+
+A crate providing unvalidated string and character types.
+
+<!-- cargo-rdme end -->
+
+## More Information
+
+For more information on development, authorship, contributing etc. please visit [`ICU4X home page`](https://github.com/unicode-org/icu4x).
diff --git a/utils/potential_utf/src/lib.rs b/utils/potential_utf/src/lib.rs
new file mode 100644
index 00000000000..5ea72a92a40
--- /dev/null
+++ b/utils/potential_utf/src/lib.rs
@@ -0,0 +1,32 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+#![cfg_attr(not(test), no_std)]
+#![cfg_attr(
+    not(test),
+    deny(
+        clippy::indexing_slicing,
+        clippy::unwrap_used,
+        clippy::expect_used,
+        clippy::panic,
+        clippy::exhaustive_structs,
+        clippy::exhaustive_enums,
+        missing_debug_implementations,
+    )
+)]
+
+//! A crate providing unvalidated string and character types.
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+mod uchar;
+mod ustr;
+
+pub use uchar::PotentialCodePoint;
+pub use ustr::PotentialUtf16;
+pub use ustr::PotentialUtf8;
+
+#[cfg(feature = "writeable")]
+mod writeable;
diff --git a/utils/potential_utf/src/uchar.rs b/utils/potential_utf/src/uchar.rs
new file mode 100644
index 00000000000..dd22aebb608
--- /dev/null
+++ b/utils/potential_utf/src/uchar.rs
@@ -0,0 +1,324 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use core::cmp::Ordering;
+use core::fmt;
+
+/// A 24-bit numeric data type that is expected to be a Unicode scalar value, but is not
+/// validated as such.
+///
+/// Use this type instead of `char` when you want to deal with data that is expected to be valid
+/// Unicode scalar values, but you want control over when or if you validate that assumption.
+///
+/// # Examples
+///
+/// ```
+/// use potential_utf::PotentialCodePoint;
+///
+/// assert_eq!(PotentialCodePoint::from_u24(0x68).try_to_char(), Ok('h'));
+/// assert_eq!(PotentialCodePoint::from_char('i').try_to_char(), Ok('i'));
+/// assert_eq!(PotentialCodePoint::from_u24(0x1F44B).try_to_char(), Ok('👋'));
+///
+/// assert!(PotentialCodePoint::from_u24(0xDE01).try_to_char().is_err());
+/// assert_eq!(PotentialCodePoint::from_u24(0xDE01).to_char_lossy(), char::REPLACEMENT_CHARACTER);
+/// ```
+#[repr(transparent)]
+#[allow(clippy::exhaustive_structs)] // transparent newtype
+#[derive(PartialEq, Eq, Clone, Copy, Hash)]
+pub struct PotentialCodePoint([u8; 3]);
+
+impl PotentialCodePoint {
+    /// Create a [`PotentialCodePoint`] from a `char`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use potential_utf::PotentialCodePoint;
+    ///
+    /// let a = PotentialCodePoint::from_char('a');
+    /// assert_eq!(a.try_to_char().unwrap(), 'a');
+    /// ```
+    #[inline]
+    pub const fn from_char(c: char) -> Self {
+        let [u0, u1, u2, _u3] = (c as u32).to_le_bytes();
+        Self([u0, u1, u2])
+    }
+
+    /// Create [`PotentialCodePoint`] from a u32 value, ignoring the most significant 8 bits.
+    #[inline]
+    pub const fn from_u24(c: u32) -> Self {
+        let [u0, u1, u2, _u3] = c.to_le_bytes();
+        Self([u0, u1, u2])
+    }
+
+    /// Attempt to convert a [`PotentialCodePoint`] to a `char`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use potential_utf::PotentialCodePoint;
+    /// use zerovec::ule::AsULE;
+    ///
+    /// let a = PotentialCodePoint::from_char('a');
+    /// assert_eq!(a.try_to_char(), Ok('a'));
+    ///
+    /// let b = PotentialCodePoint::from_unaligned([0xFF, 0xFF, 0xFF].into());
+    /// assert!(matches!(b.try_to_char(), Err(_)));
+    /// ```
+    #[inline]
+    pub fn try_to_char(self) -> Result<char, core::char::CharTryFromError> {
+        let [u0, u1, u2] = self.0;
+        #[cfg(test)]
+        dbg!([u0, u1, u2]);
+        char::try_from(u32::from_le_bytes([u0, u1, u2, 0]))
+    }
+
+    /// Convert a [`PotentialCodePoint`] to a `char', returning [`char::REPLACEMENT_CHARACTER`]
+    /// if the `PotentialCodePoint` does not represent a valid Unicode scalar value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use potential_utf::PotentialCodePoint;
+    /// use zerovec::ule::AsULE;
+    ///
+    /// let a = PotentialCodePoint::from_unaligned([0xFF, 0xFF, 0xFF].into());
+    /// assert_eq!(a.to_char_lossy(), char::REPLACEMENT_CHARACTER);
+    /// ```
+    #[inline]
+    pub fn to_char_lossy(self) -> char {
+        self.try_to_char().unwrap_or(char::REPLACEMENT_CHARACTER)
+    }
+
+    /// Convert a [`PotentialCodePoint`] to a `char` without checking that it is
+    /// a valid Unicode scalar value.
+    ///
+    /// # Safety
+    ///
+    /// The `PotentialCodePoint` must be a valid Unicode scalar value in little-endian order.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use potential_utf::PotentialCodePoint;
+    ///
+    /// let a = PotentialCodePoint::from_char('a');
+    /// assert_eq!(unsafe { a.to_char_unchecked() }, 'a');
+    /// ```
+    #[inline]
+    pub unsafe fn to_char_unchecked(self) -> char {
+        let [u0, u1, u2] = self.0;
+        char::from_u32_unchecked(u32::from_le_bytes([u0, u1, u2, 0]))
+    }
+}
+
+/// This impl requires enabling the optional `zerovec` Cargo feature
+#[cfg(feature = "zerovec")]
+impl zerovec::ule::AsULE for PotentialCodePoint {
+    type ULE = zerovec::ule::RawBytesULE<3>;
+
+    #[inline]
+    fn to_unaligned(self) -> Self::ULE {
+        zerovec::ule::RawBytesULE(self.0)
+    }
+
+    #[inline]
+    fn from_unaligned(unaligned: Self::ULE) -> Self {
+        Self(unaligned.0)
+    }
+}
+
+// Safety: PotentialCodePoint is always the little-endian representation of a char,
+// which corresponds to its AsULE::ULE type
+/// This impl requires enabling the optional `zerovec` Cargo feature
+#[cfg(feature = "zerovec")]
+unsafe impl zerovec::ule::EqULE for PotentialCodePoint {}
+
+impl fmt::Debug for PotentialCodePoint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Debug as a char if possible
+        match self.try_to_char() {
+            Ok(c) => fmt::Debug::fmt(&c, f),
+            Err(_) => fmt::Debug::fmt(&self.0, f),
+        }
+    }
+}
+
+impl PartialOrd for PotentialCodePoint {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for PotentialCodePoint {
+    // custom implementation, as derived Ord would compare lexicographically
+    fn cmp(&self, other: &Self) -> Ordering {
+        let [a0, a1, a2] = self.0;
+        let a = u32::from_le_bytes([a0, a1, a2, 0]);
+        let [b0, b1, b2] = other.0;
+        let b = u32::from_le_bytes([b0, b1, b2, 0]);
+        a.cmp(&b)
+    }
+}
+
+impl From<char> for PotentialCodePoint {
+    #[inline]
+    fn from(value: char) -> Self {
+        Self::from_char(value)
+    }
+}
+
+impl TryFrom<PotentialCodePoint> for char {
+    type Error = core::char::CharTryFromError;
+
+    #[inline]
+    fn try_from(value: PotentialCodePoint) -> Result<char, Self::Error> {
+        value.try_to_char()
+    }
+}
+
+/// This impl requires enabling the optional `serde` Cargo feature
+#[cfg(feature = "serde")]
+impl serde::Serialize for PotentialCodePoint {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::Error;
+        let c = self
+            .try_to_char()
+            .map_err(|_| S::Error::custom("invalid Unicode scalar value in PotentialCodePoint"))?;
+        if serializer.is_human_readable() {
+            serializer.serialize_char(c)
+        } else {
+            self.0.serialize(serializer)
+        }
+    }
+}
+
+/// This impl requires enabling the optional `serde` Cargo feature
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PotentialCodePoint {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            let c = <char>::deserialize(deserializer)?;
+            Ok(PotentialCodePoint::from_char(c))
+        } else {
+            let bytes = <[u8; 3]>::deserialize(deserializer)?;
+            Ok(PotentialCodePoint(bytes))
+        }
+    }
+}
+
+/// This impl requires enabling the optional `databake` Cargo feature
+#[cfg(feature = "databake")]
+impl databake::Bake for PotentialCodePoint {
+    fn bake(&self, env: &databake::CrateEnv) -> databake::TokenStream {
+        match self.try_to_char() {
+            Ok(ch) => {
+                env.insert("potential_utf");
+                let ch = ch.bake(env);
+                databake::quote! {
+                    potential_utf::PotentialCodePoint::from_char(#ch)
+                }
+            }
+            Err(_) => {
+                env.insert("potential_utf");
+                let u24 = u32::from_le_bytes([self.0[0], self.0[1], self.0[2], 0]);
+                databake::quote! {
+                    potential_utf::PotentialCodePoint::from_u24(#u24)
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use zerovec::ZeroVec;
+
+    #[test]
+    fn test_serde_fail() {
+        let uc = PotentialCodePoint([0xFF, 0xFF, 0xFF]);
+        serde_json::to_string(&uc).expect_err("serialize invalid char bytes");
+        bincode::serialize(&uc).expect_err("serialize invalid char bytes");
+    }
+
+    #[test]
+    fn test_serde_json() {
+        let c = '🙃';
+        let uc = PotentialCodePoint::from_char(c);
+        let json_ser = serde_json::to_string(&uc).unwrap();
+
+        assert_eq!(json_ser, r#""🙃""#);
+
+        let json_de: PotentialCodePoint = serde_json::from_str(&json_ser).unwrap();
+
+        assert_eq!(uc, json_de);
+    }
+
+    #[test]
+    fn test_serde_bincode() {
+        let c = '🙃';
+        let uc = PotentialCodePoint::from_char(c);
+        let bytes_ser = bincode::serialize(&uc).unwrap();
+
+        assert_eq!(bytes_ser, [0x43, 0xF6, 0x01]);
+
+        let bytes_de: PotentialCodePoint = bincode::deserialize(&bytes_ser).unwrap();
+
+        assert_eq!(uc, bytes_de);
+    }
+
+    #[test]
+    fn test_representation() {
+        let chars = ['w', 'ω', '文', '𑄃', '🙃'];
+
+        // backed by [PotentialCodePoint]
+        let uvchars: Vec<_> = chars
+            .iter()
+            .copied()
+            .map(PotentialCodePoint::from_char)
+            .collect();
+        // backed by [RawBytesULE<3>]
+        let zvec: ZeroVec<_> = uvchars.clone().into_iter().collect();
+
+        let ule_bytes = zvec.as_bytes();
+        let uvbytes;
+        unsafe {
+            let ptr = &uvchars[..] as *const _ as *const u8;
+            uvbytes = core::slice::from_raw_parts(ptr, ule_bytes.len());
+        }
+
+        // PotentialCodePoint is defined as little-endian, so this must be true on all platforms
+        // also asserts that to_unaligned/from_unaligned are no-ops
+        assert_eq!(uvbytes, ule_bytes);
+
+        assert_eq!(
+            &[119, 0, 0, 201, 3, 0, 135, 101, 0, 3, 17, 1, 67, 246, 1],
+            ule_bytes
+        );
+    }
+
+    #[test]
+    fn test_char_bake() {
+        databake::test_bake!(
+            PotentialCodePoint,
+            const,
+            crate::PotentialCodePoint::from_char('b'),
+            potential_utf
+        );
+        // surrogate code point
+        databake::test_bake!(
+            PotentialCodePoint,
+            const,
+            crate::PotentialCodePoint::from_u24(55296u32),
+            potential_utf
+        );
+    }
+}
diff --git a/utils/potential_utf/src/ustr.rs b/utils/potential_utf/src/ustr.rs
new file mode 100644
index 00000000000..1721530a875
--- /dev/null
+++ b/utils/potential_utf/src/ustr.rs
@@ -0,0 +1,245 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+use core::fmt;
+use core::ops::Deref;
+
+/// A byte slice that is expected to be a UTF-8 string but does not enforce that invariant.
+///
+/// Use this type instead of `str` if you don't need to enforce UTF-8 during deserialization. For
+/// example, strings that are keys of a map don't need to ever be reified as `str`s.
+///
+/// [`PotentialUtf8`] derefs to `[u8]`. To obtain a `str`, use [`Self::try_as_str()`].
+///
+/// The main advantage of this type over `[u8]` is that it serializes as a string in
+/// human-readable formats like JSON.
+///
+/// # Examples
+///
+/// Using an [`PotentialUtf8`] as the key of a [`ZeroMap`]:
+///
+/// ```
+/// use potential_utf::PotentialUtf8;
+/// use zerovec::ZeroMap;
+///
+/// // This map is cheap to deserialize, as we don't need to perform UTF-8 validation.
+/// let map: ZeroMap<PotentialUtf8, usize> = [
+///     (PotentialUtf8::from_bytes(b"abc"), 11),
+///     (PotentialUtf8::from_bytes(b"def"), 22),
+///     (PotentialUtf8::from_bytes(b"ghi"), 33),
+/// ]
+/// .into_iter()
+/// .collect();
+///
+/// let key = "abc";
+/// let value = map.get_copied(PotentialUtf8::from_str(key));
+/// assert_eq!(Some(11), value);
+/// ```
+///
+/// [`ZeroMap`]: zerovec::ZeroMap
+#[repr(transparent)]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+#[allow(clippy::exhaustive_structs)] // transparent newtype
+pub struct PotentialUtf8(pub [u8]);
+
+impl fmt::Debug for PotentialUtf8 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Debug as a string if possible
+        match self.try_as_str() {
+            Ok(s) => fmt::Debug::fmt(s, f),
+            Err(_) => fmt::Debug::fmt(&self.0, f),
+        }
+    }
+}
+
+impl PotentialUtf8 {
+    /// Create a [`PotentialUtf8`] from a byte slice.
+    #[inline]
+    pub const fn from_bytes(other: &[u8]) -> &Self {
+        // Safety: PotentialUtf8 is transparent over [u8]
+        unsafe { core::mem::transmute(other) }
+    }
+
+    /// Create a [`PotentialUtf8`] from a string slice.
+    #[inline]
+    pub const fn from_str(s: &str) -> &Self {
+        Self::from_bytes(s.as_bytes())
+    }
+
+    /// Create a [`PotentialUtf8`] from boxed bytes.
+    #[inline]
+    #[cfg(feature = "alloc")]
+    pub fn from_boxed_bytes(other: Box<[u8]>) -> Box<Self> {
+        // Safety: PotentialUtf8 is transparent over [u8]
+        unsafe { core::mem::transmute(other) }
+    }
+
+    /// Create a [`PotentialUtf8`] from a boxed `str`.
+    #[inline]
+    #[cfg(feature = "alloc")]
+    pub fn from_boxed_str(other: Box<str>) -> Box<Self> {
+        Self::from_boxed_bytes(other.into_boxed_bytes())
+    }
+
+    /// Get the bytes from a [`PotentialUtf8].
+    #[inline]
+    pub const fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+
+    /// Attempt to convert a [`PotentialUtf8`] to a `str`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use potential_utf::PotentialUtf8;
+    ///
+    /// static A: &PotentialUtf8 = PotentialUtf8::from_bytes(b"abc");
+    ///
+    /// let b = A.try_as_str().unwrap();
+    /// assert_eq!(b, "abc");
+    /// ```
+    // Note: this is const starting in 1.63
+    #[inline]
+    pub fn try_as_str(&self) -> Result<&str, core::str::Utf8Error> {
+        core::str::from_utf8(&self.0)
+    }
+}
+
+impl<'a> From<&'a str> for &'a PotentialUtf8 {
+    #[inline]
+    fn from(other: &'a str) -> Self {
+        PotentialUtf8::from_str(other)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl From<Box<str>> for Box<PotentialUtf8> {
+    #[inline]
+    fn from(other: Box<str>) -> Self {
+        PotentialUtf8::from_boxed_str(other)
+    }
+}
+
+impl Deref for PotentialUtf8 {
+    type Target = [u8];
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// This impl requires enabling the optional `zerovec` Cargo feature
+#[cfg(feature = "zerovec")]
+impl<'a> zerovec::maps::ZeroMapKV<'a> for PotentialUtf8 {
+    type Container = zerovec::VarZeroVec<'a, PotentialUtf8>;
+    type Slice = zerovec::VarZeroSlice<PotentialUtf8>;
+    type GetType = PotentialUtf8;
+    type OwnedType = Box<PotentialUtf8>;
+}
+
+// Safety (based on the safety checklist on the VarULE trait):
+//  1. PotentialUtf8 does not include any uninitialized or padding bytes (transparent over a ULE)
+//  2. PotentialUtf8 is aligned to 1 byte (transparent over a ULE)
+//  3. The impl of `validate_byte_slice()` returns an error if any byte is not valid (impossible)
+//  4. The impl of `validate_byte_slice()` returns an error if the slice cannot be used in its entirety (impossible)
+//  5. The impl of `from_byte_slice_unchecked()` returns a reference to the same data (returns the argument directly)
+//  6. All other methods are defaulted
+//  7. `[T]` byte equality is semantic equality (transparent over a ULE)
+/// This impl requires enabling the optional `zerovec` Cargo feature
+#[cfg(feature = "zerovec")]
+unsafe impl zerovec::ule::VarULE for PotentialUtf8 {
+    #[inline]
+    fn validate_byte_slice(_: &[u8]) -> Result<(), zerovec::ZeroVecError> {
+        Ok(())
+    }
+    #[inline]
+    unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &Self {
+        PotentialUtf8::from_bytes(bytes)
+    }
+}
+
+/// This impl requires enabling the optional `serde` Cargo feature
+#[cfg(feature = "serde")]
+impl serde::Serialize for PotentialUtf8 {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::Error;
+        let s = self
+            .try_as_str()
+            .map_err(|_| S::Error::custom("invalid UTF-8 in PotentialUtf8"))?;
+        if serializer.is_human_readable() {
+            serializer.serialize_str(s)
+        } else {
+            serializer.serialize_bytes(s.as_bytes())
+        }
+    }
+}
+
+/// This impl requires enabling the optional `serde` Cargo feature
+#[cfg(all(feature = "serde", feature = "alloc"))]
+impl<'de> serde::Deserialize<'de> for Box<PotentialUtf8> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            let boxed_str = Box::<str>::deserialize(deserializer)?;
+            Ok(PotentialUtf8::from_boxed_str(boxed_str))
+        } else {
+            let boxed_bytes = Box::<[u8]>::deserialize(deserializer)?;
+            Ok(PotentialUtf8::from_boxed_bytes(boxed_bytes))
+        }
+    }
+}
+
+/// This impl requires enabling the optional `serde` Cargo feature
+#[cfg(feature = "serde")]
+impl<'de, 'a> serde::Deserialize<'de> for &'a PotentialUtf8
+where
+    'de: 'a,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            let s = <&str>::deserialize(deserializer)?;
+            Ok(PotentialUtf8::from_str(s))
+        } else {
+            let bytes = <&[u8]>::deserialize(deserializer)?;
+            Ok(PotentialUtf8::from_bytes(bytes))
+        }
+    }
+}
+
+#[repr(transparent)]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+#[allow(clippy::exhaustive_structs)] // transparent newtype
+pub struct PotentialUtf16(pub [u16]);
+
+impl fmt::Debug for PotentialUtf16 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Debug as a string if possible
+        for c in char::decode_utf16(self.0.iter().copied()) {
+            match c {
+                Ok(c) => write!(f, "{c}")?,
+                Err(e) => write!(f, "\\0x{:x}", e.unpaired_surrogate())?,
+            }
+        }
+        Ok(())
+    }
+}
+
+impl PotentialUtf16 {
+    /// Create a [`PotentialUtf16`] from a u16 slice.
+    #[inline]
+    pub const fn from_slice(other: &[u16]) -> &Self {
+        // Safety: PotentialUtf16 is transparent over [u16]
+        unsafe { core::mem::transmute(other) }
+    }
+}
diff --git a/ffi/capi/src/utf.rs b/utils/potential_utf/src/writeable.rs
similarity index 73%
rename from ffi/capi/src/utf.rs
rename to utils/potential_utf/src/writeable.rs
index c9382c2104d..cd4899144a5 100644
--- a/ffi/capi/src/utf.rs
+++ b/utils/potential_utf/src/writeable.rs
@@ -2,40 +2,22 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
+use crate::{PotentialUtf16, PotentialUtf8};
 use alloc::borrow::Cow;
 use core::fmt::Write;
-use writeable::{LengthHint, Part, TryWriteable, Writeable};
-
-#[allow(dead_code)]
-pub(crate) struct LossyWrap<T>(pub T);
-
-impl<T: TryWriteable> Writeable for LossyWrap<T> {
-    fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {
-        let _ = self.0.try_write_to(sink)?;
-        Ok(())
-    }
-
-    fn writeable_length_hint(&self) -> LengthHint {
-        self.0.writeable_length_hint()
-    }
-}
+use writeable::{LengthHint, Part, PartsWrite, TryWriteable};
 
 use core::{char::DecodeUtf16Error, fmt, str::Utf8Error};
 
-/// Implements [`Writeable`] for [`&[u8]`] according to the [WHATWG Encoding Standard](
-/// https://encoding.spec.whatwg.org/#utf-8-decoder).
-#[derive(Debug)]
-#[allow(clippy::exhaustive_structs)] // newtype
-pub struct PotentiallyInvalidUtf8<'a>(pub &'a [u8]);
-
-impl TryWriteable for PotentiallyInvalidUtf8<'_> {
+/// This impl requires enabling the optional `writeable` Cargo feature
+impl TryWriteable for &'_ PotentialUtf8 {
     type Error = Utf8Error;
 
-    fn try_write_to_parts<S: writeable::PartsWrite + ?Sized>(
+    fn try_write_to_parts<S: PartsWrite + ?Sized>(
         &self,
         sink: &mut S,
     ) -> Result<Result<(), Self::Error>, fmt::Error> {
-        let mut remaining = self.0;
+        let mut remaining = &self.0;
         let mut r = Ok(());
         loop {
             match core::str::from_utf8(remaining) {
@@ -63,13 +45,13 @@ impl TryWriteable for PotentiallyInvalidUtf8<'_> {
         }
     }
 
-    fn writeable_length_hint(&self) -> writeable::LengthHint {
+    fn writeable_length_hint(&self) -> LengthHint {
         // Lower bound is all valid UTF-8, upper bound is all bytes with the high bit, which become replacement characters.
         LengthHint::between(self.0.len(), self.0.len() * 3)
     }
 
     fn try_write_to_string(&self) -> Result<Cow<str>, (Self::Error, Cow<str>)> {
-        match core::str::from_utf8(self.0) {
+        match core::str::from_utf8(&self.0) {
             Ok(valid) => Ok(Cow::Borrowed(valid)),
             Err(e) => {
                 // SAFETY: By Utf8Error invariants
@@ -90,7 +72,7 @@ impl TryWriteable for PotentiallyInvalidUtf8<'_> {
                 if let Some(error_len) = e.error_len() {
                     // SAFETY: By Utf8Error invariants
                     let remaining = unsafe { self.0.get_unchecked(e.valid_up_to() + error_len..) };
-                    let _discard = Self(remaining).try_write_to(&mut out);
+                    let _discard = PotentialUtf8::from_bytes(remaining).try_write_to(&mut out);
                 }
 
                 Err((e, Cow::Owned(out)))
@@ -99,16 +81,11 @@ impl TryWriteable for PotentiallyInvalidUtf8<'_> {
     }
 }
 
-/// Implements [`Writeable`] for [`&[u16]`] according to the [WHATWG Encoding Standard](
-/// https://encoding.spec.whatwg.org/#shared-utf-16-decoder).
-#[derive(Debug)]
-#[allow(clippy::exhaustive_structs)] // newtype
-pub struct PotentiallyInvalidUtf16<'a>(pub &'a [u16]);
-
-impl TryWriteable for PotentiallyInvalidUtf16<'_> {
+/// This impl requires enabling the optional `writeable` Cargo feature
+impl TryWriteable for &'_ PotentialUtf16 {
     type Error = DecodeUtf16Error;
 
-    fn try_write_to_parts<S: writeable::PartsWrite + ?Sized>(
+    fn try_write_to_parts<S: PartsWrite + ?Sized>(
         &self,
         sink: &mut S,
     ) -> Result<Result<(), Self::Error>, fmt::Error> {
@@ -141,15 +118,20 @@ mod test {
 
     #[test]
     fn test_utf8() {
-        assert_try_writeable_parts_eq!(PotentiallyInvalidUtf8(b"Foo Bar"), "Foo Bar", Ok(()), []);
         assert_try_writeable_parts_eq!(
-            PotentiallyInvalidUtf8(b"Foo\xFDBar"),
+            PotentialUtf8::from_bytes(b"Foo Bar"),
+            "Foo Bar",
+            Ok(()),
+            []
+        );
+        assert_try_writeable_parts_eq!(
+            PotentialUtf8::from_bytes(b"Foo\xFDBar"),
             "Foo�Bar",
             Err(core::str::from_utf8(b"Foo\xFDBar").unwrap_err()),
             [(3, 6, Part::ERROR)]
         );
         assert_try_writeable_parts_eq!(
-            PotentiallyInvalidUtf8(b"Foo\xFDBar\xff"),
+            PotentialUtf8::from_bytes(b"Foo\xFDBar\xff"),
             "Foo�Bar�",
             Err(core::str::from_utf8(b"Foo\xFDBar\xff").unwrap_err()),
             [(3, 6, Part::ERROR), (9, 12, Part::ERROR)],
@@ -159,13 +141,13 @@ mod test {
     #[test]
     fn test_utf16() {
         assert_try_writeable_parts_eq!(
-            PotentiallyInvalidUtf16(&[0xD83E, 0xDD73]),
+            PotentialUtf16::from_slice(&[0xD83E, 0xDD73]),
             "🥳",
             Ok(()),
             []
         );
         assert_try_writeable_parts_eq!(
-            PotentiallyInvalidUtf16(&[0xD83E, 0x20, 0xDD73]),
+            PotentialUtf16::from_slice(&[0xD83E, 0x20, 0xDD73]),
             "� �",
             Err(core::char::decode_utf16([0xD83E].into_iter())
                 .next()
diff --git a/utils/writeable/src/lib.rs b/utils/writeable/src/lib.rs
index ffc7536b9f1..63a5e6d6942 100644
--- a/utils/writeable/src/lib.rs
+++ b/utils/writeable/src/lib.rs
@@ -89,6 +89,21 @@ pub mod adapters {
     pub use parts_write_adapter::WithPart;
     pub use try_writeable::TryWriteableInfallibleAsWriteable;
     pub use try_writeable::WriteableAsTryWriteableInfallible;
+
+    #[derive(Debug)]
+    #[allow(clippy::exhaustive_structs)] // newtype
+    pub struct LossyWrap<T>(pub T);
+
+    impl<T: TryWriteable> Writeable for LossyWrap<T> {
+        fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {
+            let _ = self.0.try_write_to(sink)?;
+            Ok(())
+        }
+
+        fn writeable_length_hint(&self) -> LengthHint {
+            self.0.writeable_length_hint()
+        }
+    }
 }
 
 #[doc(hidden)] // for testing
diff --git a/utils/zerovec/Cargo.toml b/utils/zerovec/Cargo.toml
index e7df4fcacba..bf4f7d8b01c 100644
--- a/utils/zerovec/Cargo.toml
+++ b/utils/zerovec/Cargo.toml
@@ -50,6 +50,7 @@ rand_pcg = { workspace = true }
 rmp-serde = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+potential_utf = { workspace = true, features = ["zerovec"] }
 yoke = { path = "../../utils/yoke", features = ["derive"] }
 zerofrom = { path = "../../utils/zerofrom", features = ["derive"] }
 
diff --git a/utils/zerovec/src/ule/mod.rs b/utils/zerovec/src/ule/mod.rs
index 757307ada94..dbd235430d5 100644
--- a/utils/zerovec/src/ule/mod.rs
+++ b/utils/zerovec/src/ule/mod.rs
@@ -20,7 +20,6 @@ mod niche;
 mod option;
 mod plain;
 mod slices;
-mod unvalidated;
 
 pub mod tuple;
 pub use super::ZeroVecError;
@@ -30,7 +29,6 @@ pub use multi::MultiFieldsULE;
 pub use niche::{NicheBytes, NichedOption, NichedOptionULE};
 pub use option::{OptionULE, OptionVarULE};
 pub use plain::RawBytesULE;
-pub use unvalidated::{UnvalidatedChar, UnvalidatedStr};
 
 use alloc::alloc::Layout;
 use alloc::borrow::ToOwned;
diff --git a/utils/zerovec/src/ule/unvalidated.rs b/utils/zerovec/src/ule/unvalidated.rs
deleted file mode 100644
index 1d2f94e9e87..00000000000
--- a/utils/zerovec/src/ule/unvalidated.rs
+++ /dev/null
@@ -1,537 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use super::{AsULE, RawBytesULE, VarULE};
-use crate::ule::EqULE;
-use crate::{map::ZeroMapKV, VarZeroSlice, VarZeroVec, ZeroVecError};
-use alloc::boxed::Box;
-use core::cmp::Ordering;
-use core::fmt;
-use core::ops::Deref;
-
-/// A byte slice that is expected to be a UTF-8 string but does not enforce that invariant.
-///
-/// Use this type instead of `str` if you don't need to enforce UTF-8 during deserialization. For
-/// example, strings that are keys of a map don't need to ever be reified as `str`s.
-///
-/// [`UnvalidatedStr`] derefs to `[u8]`. To obtain a `str`, use [`Self::try_as_str()`].
-///
-/// The main advantage of this type over `[u8]` is that it serializes as a string in
-/// human-readable formats like JSON.
-///
-/// # Examples
-///
-/// Using an [`UnvalidatedStr`] as the key of a [`ZeroMap`]:
-///
-/// ```
-/// use zerovec::ule::UnvalidatedStr;
-/// use zerovec::ZeroMap;
-///
-/// let map: ZeroMap<UnvalidatedStr, usize> = [
-///     (UnvalidatedStr::from_str("abc"), 11),
-///     (UnvalidatedStr::from_str("def"), 22),
-///     (UnvalidatedStr::from_str("ghi"), 33),
-/// ]
-/// .into_iter()
-/// .collect();
-///
-/// let key = "abc";
-/// let value = map.get_copied_by(|uvstr| uvstr.as_bytes().cmp(key.as_bytes()));
-/// assert_eq!(Some(11), value);
-/// ```
-///
-/// [`ZeroMap`]: crate::ZeroMap
-#[repr(transparent)]
-#[derive(PartialEq, Eq, PartialOrd, Ord)]
-#[allow(clippy::exhaustive_structs)] // transparent newtype
-pub struct UnvalidatedStr([u8]);
-
-impl fmt::Debug for UnvalidatedStr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Debug as a string if possible
-        match self.try_as_str() {
-            Ok(s) => fmt::Debug::fmt(s, f),
-            Err(_) => fmt::Debug::fmt(&self.0, f),
-        }
-    }
-}
-
-impl UnvalidatedStr {
-    /// Create a [`UnvalidatedStr`] from a byte slice.
-    #[inline]
-    pub const fn from_bytes(other: &[u8]) -> &Self {
-        // Safety: UnvalidatedStr is transparent over [u8]
-        unsafe { core::mem::transmute(other) }
-    }
-
-    /// Create a [`UnvalidatedStr`] from a string slice.
-    #[inline]
-    pub const fn from_str(s: &str) -> &Self {
-        Self::from_bytes(s.as_bytes())
-    }
-
-    /// Create a [`UnvalidatedStr`] from boxed bytes.
-    #[inline]
-    pub fn from_boxed_bytes(other: Box<[u8]>) -> Box<Self> {
-        // Safety: UnvalidatedStr is transparent over [u8]
-        unsafe { core::mem::transmute(other) }
-    }
-
-    /// Create a [`UnvalidatedStr`] from a boxed `str`.
-    #[inline]
-    pub fn from_boxed_str(other: Box<str>) -> Box<Self> {
-        Self::from_boxed_bytes(other.into_boxed_bytes())
-    }
-
-    /// Get the bytes from a [`UnvalidatedStr].
-    #[inline]
-    pub const fn as_bytes(&self) -> &[u8] {
-        &self.0
-    }
-
-    /// Attempt to convert a [`UnvalidatedStr`] to a `str`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use zerovec::ule::UnvalidatedStr;
-    ///
-    /// static A: &UnvalidatedStr = UnvalidatedStr::from_bytes(b"abc");
-    ///
-    /// let b = A.try_as_str().unwrap();
-    /// assert_eq!(b, "abc");
-    /// ```
-    // Note: this is const starting in 1.63
-    #[inline]
-    pub fn try_as_str(&self) -> Result<&str, core::str::Utf8Error> {
-        core::str::from_utf8(&self.0)
-    }
-}
-
-impl<'a> From<&'a str> for &'a UnvalidatedStr {
-    #[inline]
-    fn from(other: &'a str) -> Self {
-        UnvalidatedStr::from_str(other)
-    }
-}
-
-impl From<Box<str>> for Box<UnvalidatedStr> {
-    #[inline]
-    fn from(other: Box<str>) -> Self {
-        UnvalidatedStr::from_boxed_str(other)
-    }
-}
-
-impl Deref for UnvalidatedStr {
-    type Target = [u8];
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<'a> ZeroMapKV<'a> for UnvalidatedStr {
-    type Container = VarZeroVec<'a, UnvalidatedStr>;
-    type Slice = VarZeroSlice<UnvalidatedStr>;
-    type GetType = UnvalidatedStr;
-    type OwnedType = Box<UnvalidatedStr>;
-}
-
-// Safety (based on the safety checklist on the VarULE trait):
-//  1. UnvalidatedStr does not include any uninitialized or padding bytes (transparent over a ULE)
-//  2. UnvalidatedStr is aligned to 1 byte (transparent over a ULE)
-//  3. The impl of `validate_byte_slice()` returns an error if any byte is not valid (impossible)
-//  4. The impl of `validate_byte_slice()` returns an error if the slice cannot be used in its entirety (impossible)
-//  5. The impl of `from_byte_slice_unchecked()` returns a reference to the same data (returns the argument directly)
-//  6. All other methods are defaulted
-//  7. `[T]` byte equality is semantic equality (transparent over a ULE)
-unsafe impl VarULE for UnvalidatedStr {
-    #[inline]
-    fn validate_byte_slice(_: &[u8]) -> Result<(), ZeroVecError> {
-        Ok(())
-    }
-    #[inline]
-    unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &Self {
-        UnvalidatedStr::from_bytes(bytes)
-    }
-}
-
-/// This impl requires enabling the optional `serde` Cargo feature of the `zerovec` crate
-#[cfg(feature = "serde")]
-impl serde::Serialize for UnvalidatedStr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::Error;
-        let s = self
-            .try_as_str()
-            .map_err(|_| S::Error::custom("invalid UTF-8 in UnvalidatedStr"))?;
-        if serializer.is_human_readable() {
-            serializer.serialize_str(s)
-        } else {
-            serializer.serialize_bytes(s.as_bytes())
-        }
-    }
-}
-
-/// This impl requires enabling the optional `serde` Cargo feature of the `zerovec` crate
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for Box<UnvalidatedStr> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            let boxed_str = Box::<str>::deserialize(deserializer)?;
-            Ok(UnvalidatedStr::from_boxed_str(boxed_str))
-        } else {
-            let boxed_bytes = Box::<[u8]>::deserialize(deserializer)?;
-            Ok(UnvalidatedStr::from_boxed_bytes(boxed_bytes))
-        }
-    }
-}
-
-/// This impl requires enabling the optional `serde` Cargo feature of the `zerovec` crate
-#[cfg(feature = "serde")]
-impl<'de, 'a> serde::Deserialize<'de> for &'a UnvalidatedStr
-where
-    'de: 'a,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            let s = <&str>::deserialize(deserializer)?;
-            Ok(UnvalidatedStr::from_str(s))
-        } else {
-            let bytes = <&[u8]>::deserialize(deserializer)?;
-            Ok(UnvalidatedStr::from_bytes(bytes))
-        }
-    }
-}
-
-/// A u8 array of little-endian data that is expected to be a Unicode scalar value, but is not
-/// validated as such.
-///
-/// Use this type instead of `char` when you want to deal with data that is expected to be valid
-/// Unicode scalar values, but you want control over when or if you validate that assumption.
-///
-/// # Examples
-///
-/// ```
-/// use zerovec::ule::UnvalidatedChar;
-/// use zerovec::{ZeroSlice, ZeroVec};
-///
-/// // data known to be little-endian three-byte chunks of valid Unicode scalar values
-/// let data = [0x68, 0x00, 0x00, 0x69, 0x00, 0x00, 0x4B, 0xF4, 0x01];
-/// // ground truth expectation
-/// let real = ['h', 'i', '👋'];
-///
-/// let chars: &ZeroSlice<UnvalidatedChar> = ZeroSlice::parse_byte_slice(&data).expect("invalid data length");
-/// let parsed: Vec<_> = chars.iter().map(|c| unsafe { c.to_char_unchecked() }).collect();
-/// assert_eq!(&parsed, &real);
-///
-/// let real_chars: ZeroVec<_> = real.iter().copied().map(UnvalidatedChar::from_char).collect();
-/// let serialized_data = chars.as_bytes();
-/// assert_eq!(serialized_data, &data);
-/// ```
-#[repr(transparent)]
-#[derive(PartialEq, Eq, Clone, Copy, Hash)]
-pub struct UnvalidatedChar([u8; 3]);
-
-impl UnvalidatedChar {
-    /// Create a [`UnvalidatedChar`] from a `char`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use zerovec::ule::UnvalidatedChar;
-    ///
-    /// let a = UnvalidatedChar::from_char('a');
-    /// assert_eq!(a.try_to_char().unwrap(), 'a');
-    /// ```
-    #[inline]
-    pub const fn from_char(c: char) -> Self {
-        let [u0, u1, u2, _u3] = (c as u32).to_le_bytes();
-        Self([u0, u1, u2])
-    }
-
-    #[inline]
-    #[doc(hidden)]
-    pub const fn from_u24(c: u32) -> Self {
-        let [u0, u1, u2, _u3] = c.to_le_bytes();
-        Self([u0, u1, u2])
-    }
-
-    /// Attempt to convert a [`UnvalidatedChar`] to a `char`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use zerovec::ule::{AsULE, UnvalidatedChar};
-    ///
-    /// let a = UnvalidatedChar::from_char('a');
-    /// assert_eq!(a.try_to_char(), Ok('a'));
-    ///
-    /// let b = UnvalidatedChar::from_unaligned([0xFF, 0xFF, 0xFF].into());
-    /// assert!(matches!(b.try_to_char(), Err(_)));
-    /// ```
-    #[inline]
-    pub fn try_to_char(self) -> Result<char, core::char::CharTryFromError> {
-        let [u0, u1, u2] = self.0;
-        char::try_from(u32::from_le_bytes([u0, u1, u2, 0]))
-    }
-
-    /// Convert a [`UnvalidatedChar`] to a `char', returning [`char::REPLACEMENT_CHARACTER`]
-    /// if the `UnvalidatedChar` does not represent a valid Unicode scalar value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use zerovec::ule::{AsULE, UnvalidatedChar};
-    ///
-    /// let a = UnvalidatedChar::from_unaligned([0xFF, 0xFF, 0xFF].into());
-    /// assert_eq!(a.to_char_lossy(), char::REPLACEMENT_CHARACTER);
-    /// ```
-    #[inline]
-    pub fn to_char_lossy(self) -> char {
-        self.try_to_char().unwrap_or(char::REPLACEMENT_CHARACTER)
-    }
-
-    /// Convert a [`UnvalidatedChar`] to a `char` without checking that it is
-    /// a valid Unicode scalar value.
-    ///
-    /// # Safety
-    ///
-    /// The `UnvalidatedChar` must be a valid Unicode scalar value in little-endian order.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use zerovec::ule::UnvalidatedChar;
-    ///
-    /// let a = UnvalidatedChar::from_char('a');
-    /// assert_eq!(unsafe { a.to_char_unchecked() }, 'a');
-    /// ```
-    #[inline]
-    pub unsafe fn to_char_unchecked(self) -> char {
-        let [u0, u1, u2] = self.0;
-        char::from_u32_unchecked(u32::from_le_bytes([u0, u1, u2, 0]))
-    }
-}
-
-impl RawBytesULE<3> {
-    /// Converts a [`UnvalidatedChar`] to its ULE type. This is equivalent to calling
-    /// [`AsULE::to_unaligned`].
-    #[inline]
-    pub const fn from_unvalidated_char(uc: UnvalidatedChar) -> Self {
-        RawBytesULE(uc.0)
-    }
-}
-
-impl AsULE for UnvalidatedChar {
-    type ULE = RawBytesULE<3>;
-
-    #[inline]
-    fn to_unaligned(self) -> Self::ULE {
-        RawBytesULE(self.0)
-    }
-
-    #[inline]
-    fn from_unaligned(unaligned: Self::ULE) -> Self {
-        Self(unaligned.0)
-    }
-}
-
-// Safety: UnvalidatedChar is always the little-endian representation of a char,
-// which corresponds to its AsULE::ULE type
-unsafe impl EqULE for UnvalidatedChar {}
-
-impl fmt::Debug for UnvalidatedChar {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Debug as a char if possible
-        match self.try_to_char() {
-            Ok(c) => fmt::Debug::fmt(&c, f),
-            Err(_) => fmt::Debug::fmt(&self.0, f),
-        }
-    }
-}
-
-impl PartialOrd for UnvalidatedChar {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for UnvalidatedChar {
-    // custom implementation, as derived Ord would compare lexicographically
-    fn cmp(&self, other: &Self) -> Ordering {
-        let [a0, a1, a2] = self.0;
-        let a = u32::from_le_bytes([a0, a1, a2, 0]);
-        let [b0, b1, b2] = other.0;
-        let b = u32::from_le_bytes([b0, b1, b2, 0]);
-        a.cmp(&b)
-    }
-}
-
-impl From<char> for UnvalidatedChar {
-    #[inline]
-    fn from(value: char) -> Self {
-        Self::from_char(value)
-    }
-}
-
-impl TryFrom<UnvalidatedChar> for char {
-    type Error = core::char::CharTryFromError;
-
-    #[inline]
-    fn try_from(value: UnvalidatedChar) -> Result<char, Self::Error> {
-        value.try_to_char()
-    }
-}
-
-/// This impl requires enabling the optional `serde` Cargo feature of the `zerovec` crate
-#[cfg(feature = "serde")]
-impl serde::Serialize for UnvalidatedChar {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::Error;
-        let c = self
-            .try_to_char()
-            .map_err(|_| S::Error::custom("invalid Unicode scalar value in UnvalidatedChar"))?;
-        if serializer.is_human_readable() {
-            serializer.serialize_char(c)
-        } else {
-            self.0.serialize(serializer)
-        }
-    }
-}
-
-/// This impl requires enabling the optional `serde` Cargo feature of the `zerovec` crate
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for UnvalidatedChar {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            let c = <char>::deserialize(deserializer)?;
-            Ok(UnvalidatedChar::from_char(c))
-        } else {
-            let bytes = <[u8; 3]>::deserialize(deserializer)?;
-            Ok(UnvalidatedChar(bytes))
-        }
-    }
-}
-
-#[cfg(feature = "databake")]
-impl databake::Bake for UnvalidatedChar {
-    fn bake(&self, env: &databake::CrateEnv) -> databake::TokenStream {
-        match self.try_to_char() {
-            Ok(ch) => {
-                env.insert("zerovec");
-                let ch = ch.bake(env);
-                databake::quote! {
-                    zerovec::ule::UnvalidatedChar::from_char(#ch)
-                }
-            }
-            Err(_) => {
-                env.insert("zerovec");
-                let u24 = u32::from_le_bytes([self.0[0], self.0[1], self.0[2], 0]);
-                databake::quote! {
-                    zerovec::ule::UnvalidatedChar::from_u24(#u24)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::ZeroVec;
-
-    #[test]
-    fn test_serde_fail() {
-        let uc = UnvalidatedChar([0xFF, 0xFF, 0xFF]);
-        serde_json::to_string(&uc).expect_err("serialize invalid char bytes");
-        bincode::serialize(&uc).expect_err("serialize invalid char bytes");
-    }
-
-    #[test]
-    fn test_serde_json() {
-        let c = '🙃';
-        let uc = UnvalidatedChar::from_char(c);
-        let json_ser = serde_json::to_string(&uc).unwrap();
-
-        assert_eq!(json_ser, r#""🙃""#);
-
-        let json_de: UnvalidatedChar = serde_json::from_str(&json_ser).unwrap();
-
-        assert_eq!(uc, json_de);
-    }
-
-    #[test]
-    fn test_serde_bincode() {
-        let c = '🙃';
-        let uc = UnvalidatedChar::from_char(c);
-        let bytes_ser = bincode::serialize(&uc).unwrap();
-
-        assert_eq!(bytes_ser, [0x43, 0xF6, 0x01]);
-
-        let bytes_de: UnvalidatedChar = bincode::deserialize(&bytes_ser).unwrap();
-
-        assert_eq!(uc, bytes_de);
-    }
-
-    #[test]
-    fn test_representation() {
-        let chars = ['w', 'ω', '文', '𑄃', '🙃'];
-
-        // backed by [UnvalidatedChar]
-        let uvchars: Vec<_> = chars
-            .iter()
-            .copied()
-            .map(UnvalidatedChar::from_char)
-            .collect();
-        // backed by [RawBytesULE<3>]
-        let zvec: ZeroVec<_> = uvchars.clone().into_iter().collect();
-
-        let ule_bytes = zvec.as_bytes();
-        let uvbytes;
-        unsafe {
-            let ptr = &uvchars[..] as *const _ as *const u8;
-            uvbytes = core::slice::from_raw_parts(ptr, ule_bytes.len());
-        }
-
-        // UnvalidatedChar is defined as little-endian, so this must be true on all platforms
-        // also asserts that to_unaligned/from_unaligned are no-ops
-        assert_eq!(uvbytes, ule_bytes);
-
-        assert_eq!(
-            &[119, 0, 0, 201, 3, 0, 135, 101, 0, 3, 17, 1, 67, 246, 1],
-            ule_bytes
-        );
-    }
-
-    #[test]
-    fn test_char_bake() {
-        databake::test_bake!(
-            UnvalidatedChar,
-            const,
-            crate::ule::UnvalidatedChar::from_char('b'),
-            zerovec
-        );
-        // surrogate code point
-        databake::test_bake!(
-            UnvalidatedChar,
-            const,
-            crate::ule::UnvalidatedChar::from_u24(55296u32),
-            zerovec
-        );
-    }
-}
diff --git a/utils/zerovec/src/zerovec/mod.rs b/utils/zerovec/src/zerovec/mod.rs
index 6c9ca1fdb9c..ca6e8658148 100644
--- a/utils/zerovec/src/zerovec/mod.rs
+++ b/utils/zerovec/src/zerovec/mod.rs
@@ -1043,16 +1043,10 @@ impl<T: AsULE> FromIterator<T> for ZeroVec<'_, T> {
 ///
 /// ```
 /// use zerovec::{ZeroSlice, zeroslice, ule::AsULE};
-/// use zerovec::ule::UnvalidatedChar;
 ///
 /// const SIGNATURE: &ZeroSlice<char> = zeroslice!(char; <char as AsULE>::ULE::from_aligned; ['b', 'y', 'e', '✌']);
 /// const EMPTY: &ZeroSlice<u32> = zeroslice![];
-/// const UC: &ZeroSlice<UnvalidatedChar> =
-///     zeroslice!(
-///         UnvalidatedChar;
-///         <UnvalidatedChar as AsULE>::ULE::from_unvalidated_char;
-///         [UnvalidatedChar::from_char('a')]
-///     );
+///
 /// let empty: &ZeroSlice<u32> = zeroslice![];
 /// let nums = zeroslice!(u32; <u32 as AsULE>::ULE::from_unsigned; [1, 2, 3, 4, 5]);
 /// assert_eq!(nums.last().unwrap(), 5);