diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0edda32e6d4..205830f074f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,7 +11,7 @@
     - `FormattedDateTime` and `FormattedZonedDateTime` now implement `Clone` and `Copy` (https://github.com/unicode-org/icu4x/pull/4476)
   - `icu_properties`
     - Add `Aran` script code (https://github.com/unicode-org/icu4x/pull/4426)
-    - Mark `BidiClassAdapter::new` as const (https://github.com/unicode-org/icu4x/pull/4584)
+    - Mark additional constructors as `const` (https://github.com/unicode-org/icu4x/pull/4584, https://github.com/unicode-org/icu4x/pull/4574)
     - Implement Joining_Type property (https://github.com/unicode-org/icu4x/pull/4599)
   - `icu_segmenter`
     - Fix Unicode 15.0 line breaking (https://github.com/unicode-org/icu4x/pull/4389)
diff --git a/components/normalizer/src/properties.rs b/components/normalizer/src/properties.rs
index 631cb281fda..9794d5209cd 100644
--- a/components/normalizer/src/properties.rs
+++ b/components/normalizer/src/properties.rs
@@ -90,7 +90,7 @@ impl CanonicalComposition {
     ///
     /// [📚 Help choosing a constructor](icu_provider::constructors)
     #[cfg(feature = "compiled_data")]
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             canonical_compositions: DataPayload::from_static_ref(
                 crate::provider::Baked::SINGLETON_NORMALIZER_COMP_V1,
diff --git a/components/properties/src/props.rs b/components/properties/src/props.rs
index a043218c24f..e9c3030fbbd 100644
--- a/components/properties/src/props.rs
+++ b/components/properties/src/props.rs
@@ -585,7 +585,7 @@ macro_rules! impl_value_getter {
         impl $ty {
             $(#[$attr_n2e])*
             #[cfg(feature = "compiled_data")]
-            $vis_n2e fn $cname_n2e() -> PropertyValueNameToEnumMapperBorrowed<'static, $ty> {
+            $vis_n2e const fn $cname_n2e() -> PropertyValueNameToEnumMapperBorrowed<'static, $ty> {
                 PropertyValueNameToEnumMapperBorrowed {
                     map: crate::provider::Baked::$singleton_n2e,
                     markers: PhantomData,
@@ -604,7 +604,7 @@ macro_rules! impl_value_getter {
             $(
                 $(#[$attr_e2sn])*
                 #[cfg(feature = "compiled_data")]
-                $vis_e2sn fn $cname_e2sn() -> $mapper_e2snb<'static, $ty> {
+                $vis_e2sn const fn $cname_e2sn() -> $mapper_e2snb<'static, $ty> {
                     $mapper_e2snb {
                         map: crate::provider::Baked::$singleton_e2sn,
                         markers: PhantomData,
@@ -622,7 +622,7 @@ macro_rules! impl_value_getter {
 
                 $(#[$attr_e2ln])*
                 #[cfg(feature = "compiled_data")]
-                $vis_e2ln fn $cname_e2ln() -> $mapper_e2lnb<'static, $ty> {
+                $vis_e2ln const fn $cname_e2ln() -> $mapper_e2lnb<'static, $ty> {
                     $mapper_e2lnb {
                         map: crate::provider::Baked::$singleton_e2ln,
                         markers: PhantomData,
diff --git a/experimental/harfbuzz/README.md b/experimental/harfbuzz/README.md
index 8cdab6e5369..f005f1209a2 100644
--- a/experimental/harfbuzz/README.md
+++ b/experimental/harfbuzz/README.md
@@ -11,7 +11,7 @@ use harfbuzz::{Buffer, Direction, sys};
 
 let mut b = Buffer::with("مساء الخير");
 
-let unicode_funcs = icu_harfbuzz::new_hb_unicode_funcs().unwrap();
+let unicode_funcs = icu_harfbuzz::UnicodeFuncs::new().unwrap();
 
 // NOTE: This currently requires `unsafe` code. For progress toward a safe abstraction, see:
 // <https://github.com/servo/rust-harfbuzz/pull/197>
diff --git a/experimental/harfbuzz/src/lib.rs b/experimental/harfbuzz/src/lib.rs
index 9a8054dfc59..2202fbeba98 100644
--- a/experimental/harfbuzz/src/lib.rs
+++ b/experimental/harfbuzz/src/lib.rs
@@ -28,7 +28,7 @@
 //!
 //! let mut b = Buffer::with("مساء الخير");
 //!
-//! let unicode_funcs = icu_harfbuzz::new_hb_unicode_funcs().unwrap();
+//! let unicode_funcs = icu_harfbuzz::UnicodeFuncs::new().unwrap();
 //!
 //! // NOTE: This currently requires `unsafe` code. For progress toward a safe abstraction, see:
 //! // <https://github.com/servo/rust-harfbuzz/pull/197>
@@ -52,11 +52,13 @@ use icu_normalizer::properties::CanonicalCombiningClassMap;
 use icu_normalizer::properties::CanonicalComposition;
 use icu_normalizer::properties::CanonicalDecomposition;
 use icu_normalizer::properties::Decomposed;
-use icu_normalizer::provider::CanonicalCompositionsV1Marker;
-use icu_normalizer::provider::CanonicalDecompositionDataV1Marker;
-use icu_normalizer::provider::CanonicalDecompositionTablesV1Marker;
-use icu_normalizer::provider::NonRecursiveDecompositionSupplementV1Marker;
+use icu_normalizer::provider::{
+    CanonicalCompositionsV1Marker, CanonicalDecompositionDataV1Marker,
+    CanonicalDecompositionTablesV1Marker, NonRecursiveDecompositionSupplementV1Marker,
+};
+use icu_properties::bidi_data;
 use icu_properties::bidi_data::BidiAuxiliaryProperties;
+use icu_properties::maps;
 use icu_properties::maps::CodePointMapData;
 use icu_properties::names::PropertyEnumToValueNameLinearTiny4Mapper;
 use icu_properties::provider::bidi_data::BidiAuxiliaryPropertiesV1Marker;
@@ -65,7 +67,7 @@ use icu_properties::provider::{
 };
 use icu_properties::{GeneralCategory, Script};
 use icu_provider::prelude::*;
-use tinystr::{tinystr, TinyStr4};
+use tinystr::tinystr;
 
 /// The total number of General Category values is fixed per
 /// https://www.unicode.org/policies/stability_policy.html :
@@ -113,169 +115,6 @@ static ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ: [u8; 30] = [
     HB_UNICODE_GENERAL_CATEGORY_FINAL_PUNCTUATION as u8, // FinalPunctuation = 29,
 ];
 
-unsafe extern "C" fn icu4x_hb_unicode_combining_class(
-    _ufuncs: *mut hb_unicode_funcs_t,
-    unicode: hb_codepoint_t,
-    user_data: *mut c_void,
-) -> hb_unicode_combining_class_t {
-    (*(user_data as *mut CanonicalCombiningClassMap))
-        .get32(unicode)
-        .0 as hb_unicode_combining_class_t
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_combining_class_destroy(user_data: *mut c_void) {
-    let _ = Box::from_raw(user_data as *mut CanonicalCombiningClassMap);
-}
-
-#[allow(clippy::indexing_slicing)]
-unsafe extern "C" fn icu4x_hb_unicode_general_category(
-    _ufuncs: *mut hb_unicode_funcs_t,
-    unicode: hb_codepoint_t,
-    user_data: *mut c_void,
-) -> hb_unicode_general_category_t {
-    // Indexing is OK, because `GeneralCategory` data is validated upon
-    // deserialization so that there can be no out-of-range `GeneralCategory`
-    // values (which would be UB to materialize). `GeneralCategory` is a
-    // stable exhaustive enum, and the length of `ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ`
-    // matches the number of enum items, so the index will always be in range here.
-    ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ[(*(user_data as *mut CodePointMapData<GeneralCategory>))
-        .as_borrowed()
-        .get32(unicode) as usize] as hb_unicode_general_category_t
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_general_category_destroy(user_data: *mut c_void) {
-    let _ = Box::from_raw(user_data as *mut CodePointMapData<GeneralCategory>);
-}
-
-/// Returns the Bidi_Mirroring_Glyph, but adjusting the return value
-/// to fix HarfBuzz expected behavior for code points whose property value
-/// for Bidi_Mirroring_Glyph is the undefined value.
-///
-/// From HarfBuzz docs on `hb_unicode_mirroring_func_t`:
-/// <note>Note: If a code point does not have a specified
-/// Bi-Directional Mirroring Glyph defined, the method should
-/// return the original code point.</note>
-unsafe extern "C" fn icu4x_hb_unicode_mirroring(
-    _ufuncs: *mut hb_unicode_funcs_t,
-    unicode: hb_codepoint_t,
-    user_data: *mut c_void,
-) -> hb_codepoint_t {
-    (*(user_data as *mut BidiAuxiliaryProperties))
-        .as_borrowed()
-        .get32_mirroring_props(unicode)
-        .mirroring_glyph
-        .map(u32::from)
-        .unwrap_or(unicode) as hb_codepoint_t
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_mirroring_destroy(user_data: *mut c_void) {
-    let _ = Box::from_raw(user_data as *mut BidiAuxiliaryProperties);
-}
-
-struct ScriptDataForHarfBuzz {
-    script_map: CodePointMapData<Script>,
-    enum_to_name_mapper: PropertyEnumToValueNameLinearTiny4Mapper<Script>,
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_script(
-    _ufuncs: *mut hb_unicode_funcs_t,
-    unicode: hb_codepoint_t,
-    user_data: *mut c_void,
-) -> hb_script_t {
-    let script_data: &ScriptDataForHarfBuzz = &*(user_data as *mut ScriptDataForHarfBuzz);
-    let script: Script = script_data.script_map.as_borrowed().get32(unicode);
-    let enum_to_name_mapper = script_data.enum_to_name_mapper.as_borrowed();
-    let name: TinyStr4 = enum_to_name_mapper
-        .get(script)
-        .unwrap_or(tinystr!(4, "Zzzz"));
-    hb_script_from_string(
-        name.as_ptr() as *const c_char,
-        name.len().try_into().unwrap_or(0),
-    )
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_script_destroy(user_data: *mut c_void) {
-    let _ = Box::from_raw(user_data as *mut ScriptDataForHarfBuzz);
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_compose(
-    _ufuncs: *mut hb_unicode_funcs_t,
-    a: hb_codepoint_t,
-    b: hb_codepoint_t,
-    ab: *mut hb_codepoint_t,
-    user_data: *mut c_void,
-) -> hb_bool_t {
-    // It appears that HarfBuzz will pass valid scalar values
-    // unless the application violated the contract of
-    // `hb_buffer_add_codepoints` and passed in non-scalar values.
-    // If we treated `hb_buffer_add_codepoints` as conceptually
-    // `unsafe`, it would be appropriate not to do scalar value
-    // validation here.
-    let first = if let Some(first) = core::char::from_u32(a) {
-        first
-    } else {
-        // GIGO case
-        debug_assert!(false);
-        return false as hb_bool_t;
-    };
-    let second = if let Some(second) = core::char::from_u32(b) {
-        second
-    } else {
-        // GIGO case
-        debug_assert!(false);
-        return false as hb_bool_t;
-    };
-    if let Some(c) = (*(user_data as *mut CanonicalComposition)).compose(first, second) {
-        core::ptr::write(ab, c as hb_codepoint_t);
-        true as hb_bool_t
-    } else {
-        false as hb_bool_t
-    }
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_compose_destroy(user_data: *mut c_void) {
-    let _ = Box::from_raw(user_data as *mut CanonicalComposition);
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_decompose(
-    _ufuncs: *mut hb_unicode_funcs_t,
-    ab: hb_codepoint_t,
-    a: *mut hb_codepoint_t,
-    b: *mut hb_codepoint_t,
-    user_data: *mut c_void,
-) -> hb_bool_t {
-    // It appears that HarfBuzz will pass valid scalar values
-    // unless the application violated the contract of
-    // `hb_buffer_add_codepoints` and passed in non-scalar values.
-    // If we treated `hb_buffer_add_codepoints` as conceptually
-    // `unsafe`, it would be appropriate not to do scalar value
-    // validation here.
-    let composed = if let Some(composed) = core::char::from_u32(ab) {
-        composed
-    } else {
-        // GIGO case
-        debug_assert!(false);
-        return false as hb_bool_t;
-    };
-    match (*(user_data as *mut CanonicalDecomposition)).decompose(composed) {
-        Decomposed::Default => false as hb_bool_t,
-        Decomposed::Expansion(first, second) => {
-            core::ptr::write(a, first as hb_codepoint_t);
-            core::ptr::write(b, second as hb_codepoint_t);
-            true as hb_bool_t
-        }
-        Decomposed::Singleton(single) => {
-            core::ptr::write(a, single as hb_codepoint_t);
-            core::ptr::write(b, 0);
-            true as hb_bool_t
-        }
-    }
-}
-
-unsafe extern "C" fn icu4x_hb_unicode_decompose_destroy(user_data: *mut c_void) {
-    let _ = Box::from_raw(user_data as *mut CanonicalDecomposition);
-}
-
 /// RAII holder for `*mut hb_unicode_funcs_t`.
 // TODO(#2838): Document the conditions under which multithreaded lookups via the
 // `*mut hb_unicode_funcs_t` are OK. HarfBuzz itself takes care of atomic
@@ -315,124 +154,521 @@ impl UnicodeFuncs {
     pub fn as_ptr(&self) -> *mut hb_unicode_funcs_t {
         self.raw
     }
-}
 
-impl Drop for UnicodeFuncs {
-    fn drop(&mut self) {
+    fn empty() -> Result<Self, HarfBuzzError> {
+        let empty = unsafe { hb_unicode_funcs_get_empty() };
+        // The HarfBuzz refcounting convention is that "create"
+        // sets refcount to one, not zero.
+        // https://harfbuzz.github.io/object-model-lifecycle.html
+        let raw = unsafe { hb_unicode_funcs_create(empty) };
+        if raw == empty {
+            Err(HarfBuzzError::Alloc)
+        } else {
+            Ok(Self { raw })
+        }
+    }
+
+    /// Sets up a `hb_unicode_funcs_t` with ICU4X compiled data as the back end as the Unicode
+    /// Database operations that HarfBuzz needs. The `hb_unicode_funcs_t` held
+    /// by the returned `UnicodeFuncs` is marked immutable.
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    pub fn new() -> Result<Self, HarfBuzzError> {
+        let ufuncs = Self::empty()?;
+
         unsafe {
-            hb_unicode_funcs_destroy(self.raw);
+            hb_unicode_funcs_set_combining_class_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        _: *mut c_void,
+                    ) -> hb_unicode_combining_class_t {
+                        CanonicalCombiningClassMap::new().get32(unicode).0
+                            as hb_unicode_combining_class_t
+                    }
+                    cb
+                }),
+                core::ptr::null_mut(),
+                None,
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_general_category_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        _: *mut c_void,
+                    ) -> hb_unicode_general_category_t {
+                        // Indexing is OK, because `GeneralCategory` data is validated upon
+                        // deserialization so that there can be no out-of-range `GeneralCategory`
+                        // values (which would be UB to materialize). `GeneralCategory` is a
+                        // stable exhaustive enum, and the length of `ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ`
+                        // matches the number of enum items, so the index will always be in range here.
+                        #![allow(clippy::indexing_slicing)]
+                        ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ
+                            [maps::general_category().get32(unicode) as usize]
+                            as hb_unicode_general_category_t
+                    }
+                    cb
+                }),
+                core::ptr::null_mut(),
+                None,
+            );
         }
+
+        // Returns the Bidi_Mirroring_Glyph, but adjusting the return value
+        // to fix HarfBuzz expected behavior for code points whose property value
+        // for Bidi_Mirroring_Glyph is the undefined value.
+        //
+        // From HarfBuzz docs on `hb_unicode_mirroring_func_t`:
+        // <note>Note: If a code point does not have a specified
+        // Bi-Directional Mirroring Glyph defined, the method should
+        // return the original code point.</note>
+        unsafe {
+            hb_unicode_funcs_set_mirroring_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        _: *mut c_void,
+                    ) -> hb_codepoint_t {
+                        bidi_data::bidi_auxiliary_properties()
+                            .get32_mirroring_props(unicode)
+                            .mirroring_glyph
+                            .map(u32::from)
+                            .unwrap_or(unicode) as hb_codepoint_t
+                    }
+                    cb
+                }),
+                core::ptr::null_mut(),
+                None,
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_script_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        _: *mut c_void,
+                    ) -> hb_script_t {
+                        let script = maps::script().get32(unicode);
+                        let name = Script::enum_to_short_name_mapper()
+                            .get(script)
+                            .unwrap_or(tinystr!(4, "Zzzz"));
+
+                        unsafe {
+                            hb_script_from_string(
+                                name.as_ptr() as *const c_char,
+                                name.len().try_into().unwrap_or(0),
+                            )
+                        }
+                    }
+                    cb
+                }),
+                core::ptr::null_mut(),
+                None,
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_compose_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        a: hb_codepoint_t,
+                        b: hb_codepoint_t,
+                        ab: *mut hb_codepoint_t,
+                        _: *mut c_void,
+                    ) -> hb_bool_t {
+                        // It appears that HarfBuzz will pass valid scalar values
+                        // unless the application violated the contract of
+                        // `hb_buffer_add_codepoints` and passed in non-scalar values.
+                        // If we treated `hb_buffer_add_codepoints` as conceptually
+                        // `unsafe`, it would be appropriate not to do scalar value
+                        // validation here.
+                        let Some(first) = char::from_u32(a) else {
+                            // GIGO case
+                            debug_assert!(false);
+                            return false as hb_bool_t;
+                        };
+                        let Some(second) = char::from_u32(b) else {
+                            // GIGO case
+                            debug_assert!(false);
+                            return false as hb_bool_t;
+                        };
+                        let Some(c) = CanonicalComposition::new().compose(first, second) else {
+                            return false as hb_bool_t;
+                        };
+                        unsafe {
+                            core::ptr::write(ab, c as hb_codepoint_t);
+                        }
+                        true as hb_bool_t
+                    }
+                    cb
+                }),
+                core::ptr::null_mut(),
+                None,
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_decompose_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        ab: hb_codepoint_t,
+                        a: *mut hb_codepoint_t,
+                        b: *mut hb_codepoint_t,
+                        _: *mut c_void,
+                    ) -> hb_bool_t {
+                        // It appears that HarfBuzz will pass valid scalar values
+                        // unless the application violated the contract of
+                        // `hb_buffer_add_codepoints` and passed in non-scalar values.
+                        // If we treated `hb_buffer_add_codepoints` as conceptually
+                        // `unsafe`, it would be appropriate not to do scalar value
+                        // validation here.
+                        let Some(composed) = char::from_u32(ab) else {
+                            // GIGO case
+                            debug_assert!(false);
+                            return false as hb_bool_t;
+                        };
+                        match CanonicalDecomposition::new().decompose(composed) {
+                            Decomposed::Default => false as hb_bool_t,
+                            Decomposed::Expansion(first, second) => {
+                                unsafe {
+                                    core::ptr::write(a, first as hb_codepoint_t);
+                                }
+                                unsafe {
+                                    core::ptr::write(b, second as hb_codepoint_t);
+                                }
+                                true as hb_bool_t
+                            }
+                            Decomposed::Singleton(single) => {
+                                unsafe {
+                                    core::ptr::write(a, single as hb_codepoint_t);
+                                }
+                                unsafe {
+                                    core::ptr::write(b, 0);
+                                }
+                                true as hb_bool_t
+                            }
+                        }
+                    }
+                    cb
+                }),
+                core::ptr::null_mut(),
+                None,
+            );
+        }
+
+        // Compatibility decomposition and East Asian Width lookups
+        // are deprecated, and there's no need to set up the callbacks
+        // for those.
+
+        unsafe {
+            hb_unicode_funcs_make_immutable(ufuncs.raw);
+        }
+        Ok(ufuncs)
     }
-}
 
-/// Sets up a `hb_unicode_funcs_t` with ICU4X compiled data as the back end as the Unicode
-/// Database operations that HarfBuzz needs. The `hb_unicode_funcs_t` held
-/// by the returned `UnicodeFuncs` is marked immutable.
-///
-/// ✨ *Enabled with the `compiled_data` Cargo feature.*
-///
-/// [📚 Help choosing a constructor](icu_provider::constructors)
-#[cfg(feature = "compiled_data")]
-pub fn new_hb_unicode_funcs() -> Result<UnicodeFuncs, HarfBuzzError> {
-    create_ufuncs(
-        CanonicalCombiningClassMap::new(),
-        icu_properties::maps::general_category().static_to_owned(),
-        icu_properties::bidi_data::bidi_auxiliary_properties().static_to_owned(),
-        icu_properties::maps::script().static_to_owned(),
-        Script::enum_to_short_name_mapper().static_to_owned(),
-        CanonicalComposition::new(),
-        CanonicalDecomposition::new(),
-    )
-}
+    #[doc = icu_provider::gen_any_buffer_unstable_docs!(UNSTABLE, Self::new)]
+    pub fn new_unstable<D>(provider: &D) -> Result<UnicodeFuncs, HarfBuzzError>
+    where
+        D: DataProvider<BidiAuxiliaryPropertiesV1Marker>
+            + DataProvider<CanonicalCompositionsV1Marker>
+            + DataProvider<CanonicalDecompositionDataV1Marker>
+            + DataProvider<CanonicalDecompositionTablesV1Marker>
+            + DataProvider<NonRecursiveDecompositionSupplementV1Marker>
+            + DataProvider<GeneralCategoryV1Marker>
+            + DataProvider<ScriptValueToShortNameV1Marker>
+            + DataProvider<ScriptV1Marker>
+            + ?Sized,
+    {
+        let canonical_combining_class_map = CanonicalCombiningClassMap::try_new_unstable(provider)?;
+        let general_category_map = maps::load_general_category(provider)?;
+        let bidi_auxiliary_props_map =
+            bidi_data::load_bidi_auxiliary_properties_unstable(provider)?;
+        let script_map = maps::load_script(provider)?;
+        let script_enum_to_short_name_lookup = Script::get_enum_to_short_name_mapper(provider)?;
+        let canonical_composition = CanonicalComposition::try_new_unstable(provider)?;
+        let canonical_decomposition = CanonicalDecomposition::try_new_unstable(provider)?;
 
-#[doc = icu_provider::gen_any_buffer_unstable_docs!(UNSTABLE, new_hb_unicode_funcs)]
-pub fn new_hb_unicode_funcs_unstable<D>(provider: &D) -> Result<UnicodeFuncs, HarfBuzzError>
-where
-    D: DataProvider<BidiAuxiliaryPropertiesV1Marker>
-        + DataProvider<CanonicalCompositionsV1Marker>
-        + DataProvider<CanonicalDecompositionDataV1Marker>
-        + DataProvider<CanonicalDecompositionTablesV1Marker>
-        + DataProvider<NonRecursiveDecompositionSupplementV1Marker>
-        + DataProvider<GeneralCategoryV1Marker>
-        + DataProvider<ScriptValueToShortNameV1Marker>
-        + DataProvider<ScriptV1Marker>
-        + ?Sized,
-{
-    create_ufuncs(
-        CanonicalCombiningClassMap::try_new_unstable(provider)?,
-        icu_properties::maps::load_general_category(provider)?,
-        icu_properties::bidi_data::load_bidi_auxiliary_properties_unstable(provider)?,
-        icu_properties::maps::load_script(provider)?,
-        Script::get_enum_to_short_name_mapper(provider)?,
-        CanonicalComposition::try_new_unstable(provider)?,
-        CanonicalDecomposition::try_new_unstable(provider)?,
-    )
-}
+        let ufuncs = Self::empty()?;
 
-fn create_ufuncs(
-    canonical_combining_class_map: CanonicalCombiningClassMap,
-    general_category_map: CodePointMapData<GeneralCategory>,
-    bidi_auxiliary_props_map: BidiAuxiliaryProperties,
-    script_map: CodePointMapData<Script>,
-    script_enum_to_short_name_lookup: PropertyEnumToValueNameLinearTiny4Mapper<Script>,
-    canonical_composition: CanonicalComposition,
-    canonical_decomposition: CanonicalDecomposition,
-) -> Result<UnicodeFuncs, HarfBuzzError> {
-    unsafe {
-        let empty = hb_unicode_funcs_get_empty();
-        // The HarfBuzz refcounting convention is that "create"
-        // sets refcount to one, not zero.
-        // https://harfbuzz.github.io/object-model-lifecycle.html
-        let ufuncs = hb_unicode_funcs_create(empty);
-        if ufuncs == empty {
-            return Err(HarfBuzzError::Alloc);
+        unsafe {
+            hb_unicode_funcs_set_combining_class_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        user_data: *mut c_void,
+                    ) -> hb_unicode_combining_class_t {
+                        unsafe { &*(user_data as *const CanonicalCombiningClassMap) }
+                            .get32(unicode)
+                            .0 as hb_unicode_combining_class_t
+                    }
+                    cb
+                }),
+                Box::into_raw(Box::new(canonical_combining_class_map)) as *mut c_void,
+                Some({
+                    extern "C" fn cb(user_data: *mut c_void) {
+                        drop(unsafe {
+                            Box::from_raw(user_data as *mut CanonicalCombiningClassMap)
+                        });
+                    }
+                    cb
+                }),
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_general_category_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        user_data: *mut c_void,
+                    ) -> hb_unicode_general_category_t {
+                        // Indexing is OK, because `GeneralCategory` data is validated upon
+                        // deserialization so that there can be no out-of-range `GeneralCategory`
+                        // values (which would be UB to materialize). `GeneralCategory` is a
+                        // stable exhaustive enum, and the length of `ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ`
+                        // matches the number of enum items, so the index will always be in range here.
+                        #![allow(clippy::indexing_slicing)]
+                        ICU4X_GENERAL_CATEGORY_TO_HARFBUZZ[unsafe {
+                            &*(user_data as *const CodePointMapData<GeneralCategory>)
+                        }
+                        .as_borrowed()
+                        .get32(unicode)
+                            as usize] as hb_unicode_general_category_t
+                    }
+                    cb
+                }),
+                Box::into_raw(Box::new(general_category_map)) as *mut c_void,
+                Some({
+                    extern "C" fn cb(user_data: *mut c_void) {
+                        drop(unsafe {
+                            Box::from_raw(user_data as *mut CodePointMapData<GeneralCategory>)
+                        });
+                    }
+                    cb
+                }),
+            );
+        }
+
+        // Returns the Bidi_Mirroring_Glyph, but adjusting the return value
+        // to fix HarfBuzz expected behavior for code points whose property value
+        // for Bidi_Mirroring_Glyph is the undefined value.
+        //
+        // From HarfBuzz docs on `hb_unicode_mirroring_func_t`:
+        // <note>Note: If a code point does not have a specified
+        // Bi-Directional Mirroring Glyph defined, the method should
+        // return the original code point.</note>
+        unsafe {
+            hb_unicode_funcs_set_mirroring_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        user_data: *mut c_void,
+                    ) -> hb_codepoint_t {
+                        unsafe { &*(user_data as *const BidiAuxiliaryProperties) }
+                            .as_borrowed()
+                            .get32_mirroring_props(unicode)
+                            .mirroring_glyph
+                            .map(u32::from)
+                            .unwrap_or(unicode) as hb_codepoint_t
+                    }
+                    cb
+                }),
+                Box::into_raw(Box::new(bidi_auxiliary_props_map)) as *mut c_void,
+                Some({
+                    extern "C" fn cb(user_data: *mut c_void) {
+                        drop(unsafe { Box::from_raw(user_data as *mut BidiAuxiliaryProperties) });
+                    }
+                    cb
+                }),
+            );
+        }
+
+        struct ScriptDataForHarfBuzz {
+            script_map: CodePointMapData<Script>,
+            enum_to_name_mapper: PropertyEnumToValueNameLinearTiny4Mapper<Script>,
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_script_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        unicode: hb_codepoint_t,
+                        user_data: *mut c_void,
+                    ) -> hb_script_t {
+                        let script = unsafe { &*(user_data as *const ScriptDataForHarfBuzz) }
+                            .script_map
+                            .as_borrowed()
+                            .get32(unicode);
+                        let name = unsafe { &*(user_data as *const ScriptDataForHarfBuzz) }
+                            .enum_to_name_mapper
+                            .as_borrowed()
+                            .get(script)
+                            .unwrap_or(tinystr!(4, "Zzzz"));
+
+                        unsafe {
+                            hb_script_from_string(
+                                name.as_ptr() as *const c_char,
+                                name.len().try_into().unwrap_or(0),
+                            )
+                        }
+                    }
+                    cb
+                }),
+                Box::into_raw(Box::new(ScriptDataForHarfBuzz {
+                    script_map,
+                    enum_to_name_mapper: script_enum_to_short_name_lookup,
+                })) as *mut c_void,
+                Some({
+                    extern "C" fn cb(user_data: *mut c_void) {
+                        drop(unsafe { Box::from_raw(user_data as *mut ScriptDataForHarfBuzz) });
+                    }
+                    cb
+                }),
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_compose_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        a: hb_codepoint_t,
+                        b: hb_codepoint_t,
+                        ab: *mut hb_codepoint_t,
+                        user_data: *mut c_void,
+                    ) -> hb_bool_t {
+                        // It appears that HarfBuzz will pass valid scalar values
+                        // unless the application violated the contract of
+                        // `hb_buffer_add_codepoints` and passed in non-scalar values.
+                        // If we treated `hb_buffer_add_codepoints` as conceptually
+                        // `unsafe`, it would be appropriate not to do scalar value
+                        // validation here.
+                        let Some(first) = char::from_u32(a) else {
+                            // GIGO case
+                            debug_assert!(false);
+                            return false as hb_bool_t;
+                        };
+                        let Some(second) = char::from_u32(b) else {
+                            // GIGO case
+                            debug_assert!(false);
+                            return false as hb_bool_t;
+                        };
+                        let Some(c) = unsafe { &*(user_data as *const CanonicalComposition) }
+                            .compose(first, second)
+                        else {
+                            return false as hb_bool_t;
+                        };
+                        unsafe {
+                            core::ptr::write(ab, c as hb_codepoint_t);
+                        }
+                        true as hb_bool_t
+                    }
+                    cb
+                }),
+                Box::into_raw(Box::new(canonical_composition)) as *mut c_void,
+                Some({
+                    extern "C" fn cb(user_data: *mut c_void) {
+                        drop(unsafe { Box::from_raw(user_data as *mut CanonicalComposition) });
+                    }
+                    cb
+                }),
+            );
+        }
+
+        unsafe {
+            hb_unicode_funcs_set_decompose_func(
+                ufuncs.raw,
+                Some({
+                    extern "C" fn cb(
+                        _: *mut hb_unicode_funcs_t,
+                        ab: hb_codepoint_t,
+                        a: *mut hb_codepoint_t,
+                        b: *mut hb_codepoint_t,
+                        user_data: *mut c_void,
+                    ) -> hb_bool_t {
+                        // It appears that HarfBuzz will pass valid scalar values
+                        // unless the application violated the contract of
+                        // `hb_buffer_add_codepoints` and passed in non-scalar values.
+                        // If we treated `hb_buffer_add_codepoints` as conceptually
+                        // `unsafe`, it would be appropriate not to do scalar value
+                        // validation here.
+                        let Some(composed) = char::from_u32(ab) else {
+                            // GIGO case
+                            debug_assert!(false);
+                            return false as hb_bool_t;
+                        };
+                        match unsafe { &*(user_data as *const CanonicalDecomposition) }
+                            .decompose(composed)
+                        {
+                            Decomposed::Default => false as hb_bool_t,
+                            Decomposed::Expansion(first, second) => {
+                                unsafe { core::ptr::write(a, first as hb_codepoint_t) };
+                                unsafe { core::ptr::write(b, second as hb_codepoint_t) };
+                                true as hb_bool_t
+                            }
+                            Decomposed::Singleton(single) => {
+                                unsafe { core::ptr::write(a, single as hb_codepoint_t) };
+                                unsafe { core::ptr::write(b, 0) };
+                                true as hb_bool_t
+                            }
+                        }
+                    }
+                    cb
+                }),
+                Box::into_raw(Box::new(canonical_decomposition)) as *mut c_void,
+                Some({
+                    extern "C" fn cb(user_data: *mut c_void) {
+                        drop(unsafe { Box::from_raw(user_data as *mut CanonicalDecomposition) });
+                    }
+                    cb
+                }),
+            );
         }
-        // Below this point, the only return is upon success.
-        hb_unicode_funcs_set_combining_class_func(
-            ufuncs,
-            Some(icu4x_hb_unicode_combining_class),
-            Box::into_raw(Box::new(canonical_combining_class_map)) as *mut c_void,
-            Some(icu4x_hb_unicode_combining_class_destroy),
-        );
-        hb_unicode_funcs_set_general_category_func(
-            ufuncs,
-            Some(icu4x_hb_unicode_general_category),
-            Box::into_raw(Box::new(general_category_map)) as *mut c_void,
-            Some(icu4x_hb_unicode_general_category_destroy),
-        );
-        hb_unicode_funcs_set_mirroring_func(
-            ufuncs,
-            Some(icu4x_hb_unicode_mirroring),
-            Box::into_raw(Box::new(bidi_auxiliary_props_map)) as *mut c_void,
-            Some(icu4x_hb_unicode_mirroring_destroy),
-        );
-        hb_unicode_funcs_set_script_func(
-            ufuncs,
-            Some(icu4x_hb_unicode_script),
-            Box::into_raw(Box::new(ScriptDataForHarfBuzz {
-                script_map,
-                enum_to_name_mapper: script_enum_to_short_name_lookup,
-            })) as *mut c_void,
-            Some(icu4x_hb_unicode_script_destroy),
-        );
-        hb_unicode_funcs_set_compose_func(
-            ufuncs,
-            Some(icu4x_hb_unicode_compose),
-            Box::into_raw(Box::new(canonical_composition)) as *mut c_void,
-            Some(icu4x_hb_unicode_compose_destroy),
-        );
-        hb_unicode_funcs_set_decompose_func(
-            ufuncs,
-            Some(icu4x_hb_unicode_decompose),
-            Box::into_raw(Box::new(canonical_decomposition)) as *mut c_void,
-            Some(icu4x_hb_unicode_decompose_destroy),
-        );
 
         // Compatibility decomposition and East Asian Width lookups
         // are deprecated, and there's no need to set up the callbacks
         // for those.
 
-        hb_unicode_funcs_make_immutable(ufuncs);
-        Ok(UnicodeFuncs::from_raw(ufuncs))
+        unsafe {
+            hb_unicode_funcs_make_immutable(ufuncs.raw);
+        }
+
+        Ok(ufuncs)
+    }
+}
+
+impl Drop for UnicodeFuncs {
+    fn drop(&mut self) {
+        unsafe {
+            hb_unicode_funcs_destroy(self.raw);
+        }
     }
 }