diff --git a/Cargo.lock b/Cargo.lock
index be32ab6bf..226ada33f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1078,6 +1078,18 @@ dependencies = [
  "stable_deref_trait",
 ]
 
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
 [[package]]
 name = "encode_unicode"
 version = "1.0.0"
@@ -2082,6 +2094,16 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "icu_provider_adapters"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37dafa75fcb2ca73939cf7e7f4967d30be122b5e1d10f2b344e0addca8fa9446"
+dependencies = [
+ "icu_locale",
+ "icu_provider",
+]
+
 [[package]]
 name = "icu_provider_baked"
 version = "2.1.1"
@@ -2097,6 +2119,21 @@ dependencies = [
  "zerotrie",
 ]
 
+[[package]]
+name = "icu_provider_blob"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcd377d80121ab5d320c90f914cf7145a6881556d886c2aa2c6f89cdae5f7a30"
+dependencies = [
+ "icu_provider",
+ "log",
+ "postcard",
+ "serde",
+ "writeable",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "icu_provider_export"
 version = "2.1.1"
@@ -2107,6 +2144,7 @@ dependencies = [
  "icu_locale",
  "icu_provider",
  "icu_provider_baked",
+ "icu_provider_blob",
  "log",
  "writeable",
 ]
@@ -2155,9 +2193,9 @@ dependencies = [
 
 [[package]]
 name = "icu_segmenter"
-version = "2.1.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43da5e7e9b540df15e53ca27f69b50e36e01b652584b40b3335ed65d18303834"
+checksum = "a807a7488f3f758629ae86d99d9d30dce24da2fb2945d74c80a4f4a62c71db73"
 dependencies = [
  "core_maths",
  "databake",
@@ -3303,6 +3341,8 @@ dependencies = [
  "icu_normalizer",
  "icu_properties",
  "icu_provider",
+ "icu_provider_adapters",
+ "icu_provider_blob",
  "icu_segmenter",
  "linebender_resource_handle",
  "oxipng",
@@ -3377,6 +3417,7 @@ dependencies = [
  "fontique",
  "oxipng",
  "parley",
+ "parley_data",
  "parley_dev",
  "parley_draw",
  "peniko",
@@ -3537,6 +3578,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
 dependencies = [
  "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
  "serde",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 02a566aef..8b7a4ffe3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,9 +45,10 @@ icu_normalizer = { version = "~2.1.1", default-features = false }
 icu_properties = { version = "~2.1.2", default-features = false }
 icu_provider = { version = "2.1.1", default-features = false }
 icu_provider_adapters = { version = "2.1.1", default-features = false }
+icu_provider_blob = { version = "2.1.1", default-features = false, features = ["alloc"] }
 icu_provider_export = { version = "2.1.1", default-features = false }
 icu_provider_source = { version = "2.1.1", default-features = false }
-icu_segmenter = { version = "~2.1.1", default-features = false }
+icu_segmenter = { version = "~2.1.2", default-features = false }
 linebender_resource_handle = { version = "0.1.1", default-features = false }
 parley = { version = "0.7.0", default-features = false, path = "parley" }
 parley_data = { path = "parley_data", default-features = false }
diff --git a/parley/Cargo.toml b/parley/Cargo.toml
index b10b4dbb6..1171d89b4 100644
--- a/parley/Cargo.toml
+++ b/parley/Cargo.toml
@@ -23,6 +23,14 @@ libm = ["fontique/libm", "peniko/libm", "skrifa/libm", "dep:core_maths"]
 # Enables support for system font backends
 system = ["std", "fontique/system"]
 accesskit = ["dep:accesskit"]
+## Enables runtime loading of segmenter models for language-specific word/line breaking.
+## This allows applications to load additional segmentation data (e.g., for Thai, Lao,
+## Khmer, Burmese, Chinese, Japanese) at runtime rather than baking it into the binary.
+runtime-segmenter-data = [
+    "dep:icu_provider_adapters",
+    "dep:icu_provider_blob",
+    "icu_segmenter/serde",
+]
 
 [dependencies]
 skrifa = { workspace = true }
@@ -38,6 +46,8 @@ icu_collections = { workspace = true }
 icu_normalizer = { workspace = true }
 icu_properties = { workspace = true }
 icu_provider = { workspace = true }
+icu_provider_blob = { workspace = true, optional = true }
+icu_provider_adapters = { workspace = true, optional = true }
 icu_segmenter = { workspace = true, features = ["auto"] }
 # Used in ICU4X baked data sources
 zerovec = { workspace = true }
diff --git a/parley/src/analysis/mod.rs b/parley/src/analysis/mod.rs
index 84d7badc7..b0e9266bc 100644
--- a/parley/src/analysis/mod.rs
+++ b/parley/src/analysis/mod.rs
@@ -26,6 +26,73 @@ use icu_segmenter::{
 };
 use parley_data::CompositeProps;
 
+#[cfg(feature = "runtime-segmenter-data")]
+use icu_provider::buf::AsDeserializingBufferProvider;
+#[cfg(feature = "runtime-segmenter-data")]
+use icu_provider_adapters::fork::{
+    ForkByMarkerProvider, MultiForkByErrorProvider, predicates::IdentifierNotFoundPredicate,
+};
+
+/// Segmenter model data that can be loaded at runtime.
+///
+/// This type wraps binary blob data containing LSTM models or dictionaries for language-specific word/line
+/// segmentation. The blobs are exported from `parley_data`, and can be included at compile time or saved as files from
+/// `parley_data` at build time and later loaded as files at runtime.
+///
+/// # Example
+///
+/// ```ignore
+/// use parley_data::SegmenterModelData;
+///
+/// // Load from a file
+/// let blob = std::fs::read("Thai_codepoints_exclusive_model4_heavy.postcard")?;
+/// let model = SegmenterModelData::from_blob(blob.into_boxed_slice())?;
+///
+/// // Or embed at compile time
+/// let model = SegmenterModelData::from_static(parley_data::bundled_models::THAI_LSTM)?;
+/// ```
+#[cfg(feature = "runtime-segmenter-data")]
+#[derive(Debug)]
+pub struct SegmenterModelData {
+    pub(crate) provider: icu_provider_blob::BlobDataProvider,
+}
+
+#[cfg(feature = "runtime-segmenter-data")]
+impl SegmenterModelData {
+    /// Creates a new `SegmenterModelData` from an owned blob.
+    ///
+    /// The blob should be a postcard-serialized ICU4X data blob from `parley_data`.
+    pub fn from_blob(blob: alloc::boxed::Box<[u8]>) -> Result<Self, icu_provider::DataError> {
+        let provider = icu_provider_blob::BlobDataProvider::try_new_from_blob(blob)?;
+        Ok(Self { provider })
+    }
+
+    /// Creates a new `SegmenterModelData` from a static byte slice.
+    ///
+    /// This is useful for embedding model data directly in your binary using `include_bytes!()`.
+    pub fn from_static(blob: &'static [u8]) -> Result<Self, icu_provider::DataError> {
+        let provider = icu_provider_blob::BlobDataProvider::try_new_from_static_blob(blob)?;
+        Ok(Self { provider })
+    }
+}
+
+/// The buffer provider for all data loaded at runtime.
+#[cfg(feature = "runtime-segmenter-data")]
+struct RuntimeBufferProvider {
+    provider:
+        MultiForkByErrorProvider<icu_provider_blob::BlobDataProvider, IdentifierNotFoundPredicate>,
+    segmenter_mode: SegmenterMode,
+}
+
+#[allow(unused)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum SegmenterMode {
+    /// Use LSTM for SE Asian scripts, dictionary for CJK (default).
+    Auto,
+    /// Use dictionary for all complex scripts.
+    Dictionary,
+}
+
 pub(crate) struct AnalysisDataSources {
     grapheme_segmenter: GraphemeClusterSegmenter,
     word_segmenter: WordSegmenter,
@@ -36,6 +103,9 @@ pub(crate) struct AnalysisDataSources {
     brackets: CodePointMapData<BidiMirroringGlyph>,
 
     composite: CompositeProps,
+
+    #[cfg(feature = "runtime-segmenter-data")]
+    runtime_buffer_provider: Option<RuntimeBufferProvider>,
 }
 
 #[derive(Default)]
@@ -46,7 +116,13 @@ struct LineSegmenters {
 }
 
 impl LineSegmenters {
-    fn get(&mut self, word_break_strength: WordBreak) -> LineSegmenterBorrowed<'_> {
+    fn get(
+        &mut self,
+        word_break_strength: WordBreak,
+        #[cfg(feature = "runtime-segmenter-data")] runtime_buffer_provider: Option<
+            &RuntimeBufferProvider,
+        >,
+    ) -> LineSegmenterBorrowed<'_> {
         let segmenter = match word_break_strength {
             WordBreak::Normal => &mut self.normal,
             WordBreak::KeepAll => &mut self.keep_all,
@@ -62,7 +138,27 @@ impl LineSegmenters {
                     WordBreak::KeepAll => LineBreakWordOption::KeepAll,
                 };
                 line_break_opts.word_option = Some(word_break_strength_icu);
-                LineSegmenter::try_new_auto_unstable(&PROVIDER, line_break_opts)
+
+                #[cfg(feature = "runtime-segmenter-data")]
+                if let Some(&RuntimeBufferProvider {
+                    ref provider,
+                    segmenter_mode,
+                }) = runtime_buffer_provider
+                {
+                    let combined =
+                        ForkByMarkerProvider::new(provider.as_deserializing(), &PROVIDER);
+                    return match segmenter_mode {
+                        SegmenterMode::Auto => {
+                            LineSegmenter::try_new_auto_unstable(&combined, line_break_opts)
+                        }
+                        SegmenterMode::Dictionary => {
+                            LineSegmenter::try_new_dictionary_unstable(&combined, line_break_opts)
+                        }
+                    }
+                    .expect("Failed to create LineSegmenter");
+                }
+
+                LineSegmenter::try_new_for_non_complex_scripts_unstable(&PROVIDER, line_break_opts)
                     .expect("Failed to create LineSegmenter")
             })
             .as_borrowed()
@@ -73,7 +169,7 @@ impl AnalysisDataSources {
     pub(crate) fn new() -> Self {
         Self {
             grapheme_segmenter: GraphemeClusterSegmenter::try_new_unstable(&PROVIDER).unwrap(),
-            word_segmenter: WordSegmenter::try_new_lstm_unstable(
+            word_segmenter: WordSegmenter::try_new_for_non_complex_scripts_unstable(
                 &PROVIDER,
                 WordBreakOptions::default(),
             )
@@ -84,6 +180,73 @@ impl AnalysisDataSources {
             script_short_name: PropertyNamesShort::<Script>::try_new_unstable(&PROVIDER).unwrap(),
             brackets: CodePointMapData::<BidiMirroringGlyph>::try_new_unstable(&PROVIDER).unwrap(),
             composite: CompositeProps,
+            #[cfg(feature = "runtime-segmenter-data")]
+            runtime_buffer_provider: None,
+        }
+    }
+
+    #[cfg(feature = "runtime-segmenter-data")]
+    fn reinitialize_word_segmenter(&mut self) {
+        let Some(buffer_provider) = self.runtime_buffer_provider.as_ref() else {
+            return;
+        };
+        // Combine the complex script providers with the baked data for non-complex scripts.
+        let combined =
+            ForkByMarkerProvider::new(buffer_provider.provider.as_deserializing(), &PROVIDER);
+
+        self.word_segmenter = match buffer_provider.segmenter_mode {
+            SegmenterMode::Auto => {
+                WordSegmenter::try_new_auto_unstable(&combined, WordBreakOptions::default())
+            }
+            SegmenterMode::Dictionary => {
+                WordSegmenter::try_new_dictionary_unstable(&combined, WordBreakOptions::default())
+            }
+        }
+        .expect("Failed to create WordSegmenter with runtime models");
+
+        // Clear cached line segmenters; they will be lazily recreated with the new mode.
+        self.line_segmenters = LineSegmenters::default();
+    }
+
+    #[cfg(feature = "runtime-segmenter-data")]
+    pub(crate) fn load_segmenter_models(
+        &mut self,
+        providers: Vec<icu_provider_blob::BlobDataProvider>,
+        mode: SegmenterMode,
+    ) {
+        // Create a forking buffer provider that combines all blob providers.
+        let buffer_provider = RuntimeBufferProvider {
+            provider: MultiForkByErrorProvider::new_with_predicate(
+                providers,
+                IdentifierNotFoundPredicate,
+            ),
+            segmenter_mode: mode,
+        };
+        self.runtime_buffer_provider = Some(buffer_provider);
+
+        self.reinitialize_word_segmenter();
+    }
+
+    #[cfg(feature = "runtime-segmenter-data")]
+    pub(crate) fn append_segmenter_model(
+        &mut self,
+        provider: icu_provider_blob::BlobDataProvider,
+        mode: SegmenterMode,
+    ) {
+        match self.runtime_buffer_provider.as_mut() {
+            None => {
+                self.load_segmenter_models(alloc::vec![provider], mode);
+            }
+            Some(buffer_provider) => {
+                let cur_mode = buffer_provider.segmenter_mode;
+                assert_eq!(
+                    cur_mode, mode,
+                    "Tried to load a {mode:?} segmenter model, but the current segmenters are {cur_mode:?}"
+                );
+
+                buffer_provider.provider.push(provider);
+                self.reinitialize_word_segmenter();
+            }
         }
     }
 
@@ -92,6 +255,22 @@ impl AnalysisDataSources {
         &self.composite
     }
 
+    #[inline(always)]
+    pub(crate) fn line_segmenter(
+        &mut self,
+        word_break_strength: WordBreak,
+    ) -> LineSegmenterBorrowed<'_> {
+        #[cfg(feature = "runtime-segmenter-data")]
+        {
+            self.line_segmenters
+                .get(word_break_strength, self.runtime_buffer_provider.as_ref())
+        }
+        #[cfg(not(feature = "runtime-segmenter-data"))]
+        {
+            self.line_segmenters.get(word_break_strength)
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn grapheme_segmenter(&self) -> GraphemeClusterSegmenterBorrowed<'_> {
         self.grapheme_segmenter.as_borrowed()
@@ -354,8 +533,7 @@ pub(crate) fn analyze_text<B: Brush>(lcx: &mut LayoutContext<B>, mut text: &str)
         if substring_index == 0 && last {
             let mut lb_iter = lcx
                 .analysis_data_sources
-                .line_segmenters
-                .get(word_break_strength)
+                .line_segmenter(word_break_strength)
                 .segment_str(substring);
 
             let _first = lb_iter.next();
@@ -378,8 +556,7 @@ pub(crate) fn analyze_text<B: Brush>(lcx: &mut LayoutContext<B>, mut text: &str)
 
         let line_boundaries_iter = lcx
             .analysis_data_sources
-            .line_segmenters
-            .get(word_break_strength)
+            .line_segmenter(word_break_strength)
             .segment_str(substring);
 
         let mut substring_chars = substring.chars();
diff --git a/parley/src/analysis/provider.rs b/parley/src/analysis/provider.rs
index 10fedae67..9f2d4e522 100644
--- a/parley/src/analysis/provider.rs
+++ b/parley/src/analysis/provider.rs
@@ -26,6 +26,8 @@ macro_rules! impl_data_provider {
         impl_segmenter_break_grapheme_cluster_v1!($provider);
         impl_segmenter_break_line_v1!($provider);
         impl_normalizer_nfc_v1!($provider);
+        impl_segmenter_dictionary_auto_v1!($provider);
+        impl_segmenter_dictionary_extended_v1!($provider);
         impl_segmenter_lstm_auto_v1!($provider);
         impl_property_name_short_script_v1!($provider);
         impl_normalizer_nfd_data_v1!($provider);
diff --git a/parley/src/context.rs b/parley/src/context.rs
index 364a01d77..62dc7c1dc 100644
--- a/parley/src/context.rs
+++ b/parley/src/context.rs
@@ -53,6 +53,108 @@ impl<B: Brush> LayoutContext<B> {
         }
     }
 
+    /// Loads runtime segmenter models for improved word/line breaking.
+    ///
+    /// By default, Parley uses rule-based segmentation which works well for most languages but produces suboptimal
+    /// results for languages like Thai, Lao, Khmer, and Burmese that don't use spaces between words.
+    ///
+    /// This method allows loading LSTM models at runtime to enable proper word segmentation for these languages. CJK
+    /// text uses dictionary data.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use parley::{LayoutContext, FontContext, SegmenterModelData};
+    ///
+    /// let mut layout_ctx = LayoutContext::new();
+    ///
+    /// // Load Thai and Khmer LSTM models from files
+    /// let thai_blob = std::fs::read("Thai_codepoints_exclusive_model4_heavy.postcard")?;
+    /// let thai_model = SegmenterModelData::from_blob(thai_blob.into_boxed_slice())?;
+    ///
+    /// let khmer_blob = std::fs::read("Khmer_codepoints_exclusive_model4_heavy.postcard")?;
+    /// let khmer_model = SegmenterModelData::from_blob(khmer_blob.into_boxed_slice())?;
+    ///
+    /// layout_ctx.load_segmenter_models_auto([thai_model, khmer_model]);
+    /// ```
+    #[cfg(feature = "runtime-segmenter-data")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "runtime-segmenter-data")))]
+    pub fn load_segmenter_models_auto(
+        &mut self,
+        models: impl IntoIterator<Item = crate::SegmenterModelData>,
+    ) {
+        self.analysis_data_sources.load_segmenter_models(
+            models.into_iter().map(|model| model.provider).collect(),
+            crate::analysis::SegmenterMode::Auto,
+        );
+    }
+
+    /// Loads runtime dictionary segmenter models for word/line breaking.
+    ///
+    /// Unlike [`Self::load_segmenter_models_auto`] which uses LSTM for Southeast Asian scripts, this uses dictionary
+    /// data for all complex scripts. Dictionaries may be faster at runtime but require more data.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use parley::{LayoutContext, FontContext};
+    /// use parley_data::SegmenterModelData;
+    ///
+    /// let mut layout_ctx = LayoutContext::new();
+    ///
+    /// // Load Thai dictionary-based segmenter
+    /// let thai_blob = std::fs::read("thaidict.postcard")?;
+    /// let thai_model = SegmenterModelData::from_blob(thai_blob.into_boxed_slice())?;
+    ///
+    /// layout_ctx.load_segmenter_models_dictionary([thai_model]);
+    /// ```
+    #[cfg(feature = "runtime-segmenter-data")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "runtime-segmenter-data")))]
+    pub fn load_segmenter_models_dictionary(
+        &mut self,
+        models: impl IntoIterator<Item = crate::SegmenterModelData>,
+    ) {
+        self.analysis_data_sources.load_segmenter_models(
+            models.into_iter().map(|model| model.provider).collect(),
+            crate::analysis::SegmenterMode::Dictionary,
+        );
+    }
+
+    /// Add a runtime segmenter model for improved word/line breaking. See [`Self::load_segmenter_models_auto`] for
+    /// more.
+    ///
+    /// This method does *not* handle duplicates--if you load the same model twice, it will simply attempt to use it
+    /// twice during text analysis and make things slower.
+    ///
+    /// # Panics
+    ///
+    /// If you previously called [`Self::load_segmenter_models_dictionary`] or
+    /// [`Self::append_segmenter_model_dictionary`] to load a dictionary segmenter. Previously-loaded segmenters, if
+    /// any, must have been "auto".
+    #[cfg(feature = "runtime-segmenter-data")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "runtime-segmenter-data")))]
+    pub fn append_segmenter_model_auto(&mut self, model: crate::SegmenterModelData) {
+        self.analysis_data_sources
+            .append_segmenter_model(model.provider, crate::analysis::SegmenterMode::Auto);
+    }
+
+    /// Add a runtime segmenter model for improved word/line breaking. See [`Self::load_segmenter_models_dictionary`]
+    /// for more.
+    ///
+    /// This method does *not* handle duplicates--if you load the same model twice, it will simply attempt to use it
+    /// twice during text analysis and make things slower.
+    ///
+    /// # Panics
+    ///
+    /// If you previously called [`Self::load_segmenter_models_auto`] or [`Self::append_segmenter_model_auto`] to load
+    /// an "auto mode" segmenter. Previously-loaded segmenters, if any, must have been "dictionary".
+    #[cfg(feature = "runtime-segmenter-data")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "runtime-segmenter-data")))]
+    pub fn append_segmenter_model_dictionary(&mut self, model: crate::SegmenterModelData) {
+        self.analysis_data_sources
+            .append_segmenter_model(model.provider, crate::analysis::SegmenterMode::Dictionary);
+    }
+
     fn resolve_style_set(
         &mut self,
         font_ctx: &mut FontContext,
diff --git a/parley/src/lib.rs b/parley/src/lib.rs
index 00960121e..c38c9db5e 100644
--- a/parley/src/lib.rs
+++ b/parley/src/lib.rs
@@ -128,6 +128,8 @@ mod tests;
 pub use linebender_resource_handle::FontData;
 pub use util::BoundingBox;
 
+#[cfg(feature = "runtime-segmenter-data")]
+pub use analysis::SegmenterModelData;
 pub use builder::{RangedBuilder, TreeBuilder};
 pub use context::LayoutContext;
 pub use font::FontContext;
diff --git a/parley_data/src/generated/icu4x_data/mod.rs b/parley_data/src/generated/icu4x_data/mod.rs
index 48813ff2e..cd5f2bace 100644
--- a/parley_data/src/generated/icu4x_data/mod.rs
+++ b/parley_data/src/generated/icu4x_data/mod.rs
@@ -5,7 +5,9 @@
 // @generated
 include!("normalizer_nfd_tables_v1.rs.data");
 include!("normalizer_nfd_supplement_v1.rs.data");
+include!("segmenter_dictionary_auto_v1.rs.data");
 include!("segmenter_break_grapheme_cluster_v1.rs.data");
+include!("segmenter_dictionary_extended_v1.rs.data");
 include!("segmenter_break_line_v1.rs.data");
 include!("normalizer_nfc_v1.rs.data");
 include!("segmenter_lstm_auto_v1.rs.data");
@@ -52,7 +54,9 @@ macro_rules! impl_data_provider {
         make_provider!($provider);
         impl_normalizer_nfd_tables_v1!($provider);
         impl_normalizer_nfd_supplement_v1!($provider);
+        impl_segmenter_dictionary_auto_v1!($provider);
         impl_segmenter_break_grapheme_cluster_v1!($provider);
+        impl_segmenter_dictionary_extended_v1!($provider);
         impl_segmenter_break_line_v1!($provider);
         impl_normalizer_nfc_v1!($provider);
         impl_segmenter_lstm_auto_v1!($provider);
diff --git a/parley_data/src/generated/icu4x_data/segmenter_dictionary_auto_v1.rs.data b/parley_data/src/generated/icu4x_data/segmenter_dictionary_auto_v1.rs.data
new file mode 100644
index 000000000..7313928c1
--- /dev/null
+++ b/parley_data/src/generated/icu4x_data/segmenter_dictionary_auto_v1.rs.data
@@ -0,0 +1,56 @@
+// @generated
+/// Implement `DataProvider<SegmenterDictionaryAutoV1>` on the given struct using the data
+/// hardcoded in this file. This allows the struct to be used with
+/// `icu`'s `_unstable` constructors.
+///
+/// This macro requires the following crates:
+/// * `icu_provider`
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __impl_segmenter_dictionary_auto_v1 {
+    ($ provider : ty) => {
+        #[clippy::msrv = "1.83"]
+        const _: () = <$provider>::MUST_USE_MAKE_PROVIDER_MACRO;
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::DataProvider<icu_segmenter::provider::SegmenterDictionaryAutoV1> for $provider {
+            fn load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponse<icu_segmenter::provider::SegmenterDictionaryAutoV1>, icu_provider::DataError> {
+                Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<icu_segmenter::provider::SegmenterDictionaryAutoV1 as icu_provider::DataMarker>::INFO, req))
+            }
+        }
+    };
+    ($ provider : ty , ITER) => {
+        __impl_segmenter_dictionary_auto_v1!($provider);
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::IterableDataProvider<icu_segmenter::provider::SegmenterDictionaryAutoV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok(Default::default())
+            }
+        }
+    };
+    ($ provider : ty , DRY) => {
+        __impl_segmenter_dictionary_auto_v1!($provider);
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::DryDataProvider<icu_segmenter::provider::SegmenterDictionaryAutoV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<icu_segmenter::provider::SegmenterDictionaryAutoV1 as icu_provider::DataMarker>::INFO, req))
+            }
+        }
+    };
+    ($ provider : ty , DRY , ITER) => {
+        __impl_segmenter_dictionary_auto_v1!($provider);
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::DryDataProvider<icu_segmenter::provider::SegmenterDictionaryAutoV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<icu_segmenter::provider::SegmenterDictionaryAutoV1 as icu_provider::DataMarker>::INFO, req))
+            }
+        }
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::IterableDataProvider<icu_segmenter::provider::SegmenterDictionaryAutoV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok(Default::default())
+            }
+        }
+    };
+}
+#[doc(inline)]
+pub use __impl_segmenter_dictionary_auto_v1 as impl_segmenter_dictionary_auto_v1;
diff --git a/parley_data/src/generated/icu4x_data/segmenter_dictionary_extended_v1.rs.data b/parley_data/src/generated/icu4x_data/segmenter_dictionary_extended_v1.rs.data
new file mode 100644
index 000000000..b251393e1
--- /dev/null
+++ b/parley_data/src/generated/icu4x_data/segmenter_dictionary_extended_v1.rs.data
@@ -0,0 +1,56 @@
+// @generated
+/// Implement `DataProvider<SegmenterDictionaryExtendedV1>` on the given struct using the data
+/// hardcoded in this file. This allows the struct to be used with
+/// `icu`'s `_unstable` constructors.
+///
+/// This macro requires the following crates:
+/// * `icu_provider`
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __impl_segmenter_dictionary_extended_v1 {
+    ($ provider : ty) => {
+        #[clippy::msrv = "1.83"]
+        const _: () = <$provider>::MUST_USE_MAKE_PROVIDER_MACRO;
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::DataProvider<icu_segmenter::provider::SegmenterDictionaryExtendedV1> for $provider {
+            fn load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponse<icu_segmenter::provider::SegmenterDictionaryExtendedV1>, icu_provider::DataError> {
+                Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<icu_segmenter::provider::SegmenterDictionaryExtendedV1 as icu_provider::DataMarker>::INFO, req))
+            }
+        }
+    };
+    ($ provider : ty , ITER) => {
+        __impl_segmenter_dictionary_extended_v1!($provider);
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::IterableDataProvider<icu_segmenter::provider::SegmenterDictionaryExtendedV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok(Default::default())
+            }
+        }
+    };
+    ($ provider : ty , DRY) => {
+        __impl_segmenter_dictionary_extended_v1!($provider);
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::DryDataProvider<icu_segmenter::provider::SegmenterDictionaryExtendedV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<icu_segmenter::provider::SegmenterDictionaryExtendedV1 as icu_provider::DataMarker>::INFO, req))
+            }
+        }
+    };
+    ($ provider : ty , DRY , ITER) => {
+        __impl_segmenter_dictionary_extended_v1!($provider);
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::DryDataProvider<icu_segmenter::provider::SegmenterDictionaryExtendedV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                Err(icu_provider::DataErrorKind::IdentifierNotFound.with_req(<icu_segmenter::provider::SegmenterDictionaryExtendedV1 as icu_provider::DataMarker>::INFO, req))
+            }
+        }
+        #[clippy::msrv = "1.83"]
+        impl icu_provider::IterableDataProvider<icu_segmenter::provider::SegmenterDictionaryExtendedV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok(Default::default())
+            }
+        }
+    };
+}
+#[doc(inline)]
+pub use __impl_segmenter_dictionary_extended_v1 as impl_segmenter_dictionary_extended_v1;
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/Burmese_codepoints_exclusive_model4_heavy.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/Burmese_codepoints_exclusive_model4_heavy.postcard
new file mode 100644
index 000000000..8eeec468c
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/Burmese_codepoints_exclusive_model4_heavy.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/Khmer_codepoints_exclusive_model4_heavy.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/Khmer_codepoints_exclusive_model4_heavy.postcard
new file mode 100644
index 000000000..e61504dbb
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/Khmer_codepoints_exclusive_model4_heavy.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/Lao_codepoints_exclusive_model4_heavy.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/Lao_codepoints_exclusive_model4_heavy.postcard
new file mode 100644
index 000000000..1a77a7186
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/Lao_codepoints_exclusive_model4_heavy.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/Thai_codepoints_exclusive_model4_heavy.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/Thai_codepoints_exclusive_model4_heavy.postcard
new file mode 100644
index 000000000..b80a84749
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/Thai_codepoints_exclusive_model4_heavy.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/burmesedict.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/burmesedict.postcard
new file mode 100644
index 000000000..2f3819bf7
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/burmesedict.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/cjdict.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/cjdict.postcard
new file mode 100644
index 000000000..b83bef032
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/cjdict.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/khmerdict.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/khmerdict.postcard
new file mode 100644
index 000000000..6814e2f4d
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/khmerdict.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/laodict.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/laodict.postcard
new file mode 100644
index 000000000..4dfaa2248
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/laodict.postcard differ
diff --git a/parley_data/src/generated/icu4x_data/segmenter_models/thaidict.postcard b/parley_data/src/generated/icu4x_data/segmenter_models/thaidict.postcard
new file mode 100644
index 000000000..192102466
Binary files /dev/null and b/parley_data/src/generated/icu4x_data/segmenter_models/thaidict.postcard differ
diff --git a/parley_data/src/lib.rs b/parley_data/src/lib.rs
index eda99ef81..c895b96d8 100644
--- a/parley_data/src/lib.rs
+++ b/parley_data/src/lib.rs
@@ -5,6 +5,14 @@
 //!
 //! - Re-exported ICU4X data providers for grapheme, word, and line breaking, plus Unicode normalization tables used by Parley.
 //! - A locale-invariant `CompositeProps` provider backed by a compact `CodePointTrie`, allowing the engine to obtain all required character properties with a single lookup.
+//! - Runtime loading of segmenter models for language-specific word/line breaking (via Parley's `SegmenterModelData`).
+//!
+//! # Pluggable segmenter models
+//!
+//! By default, Parley uses ICU4X's rule-based segmentation. This works well for most languages, but produces suboptimal results for languages like Thai, Lao, Khmer, Burmese, Chinese, and Japanese that don't use spaces between words.
+//!
+//! For better segmentation in these languages, you can load LSTM models or dictionaries at runtime.
+//! These models are included here if you want to import them directly, but if you want to reduce code size, you may want to export them from this crate at build time and load them dynamically.
 
 #![no_std]
 
@@ -169,3 +177,91 @@ impl From<Properties> for u32 {
         value.0
     }
 }
+
+/// Bundled segmenter models for languages requiring complex word breaking.
+///
+/// These are pre-generated postcard blobs that can be loaded at runtime.
+///
+/// You can also depend on `parley_data` in your build, and export these models to files that you can ship alongside
+/// your Parley-using application and load dynamically.
+pub mod bundled_models {
+    /// Thai LSTM model for word/line segmentation.
+    pub const THAI_LSTM: &[u8] = include_bytes!(
+        "generated/icu4x_data/segmenter_models/Thai_codepoints_exclusive_model4_heavy.postcard"
+    );
+
+    /// Lao LSTM model for word/line segmentation.
+    pub const LAO_LSTM: &[u8] = include_bytes!(
+        "generated/icu4x_data/segmenter_models/Lao_codepoints_exclusive_model4_heavy.postcard"
+    );
+
+    /// Khmer LSTM model for word/line segmentation.
+    pub const KHMER_LSTM: &[u8] = include_bytes!(
+        "generated/icu4x_data/segmenter_models/Khmer_codepoints_exclusive_model4_heavy.postcard"
+    );
+
+    /// Burmese LSTM model for word/line segmentation.
+    pub const BURMESE_LSTM: &[u8] = include_bytes!(
+        "generated/icu4x_data/segmenter_models/Burmese_codepoints_exclusive_model4_heavy.postcard"
+    );
+
+    /// Chinese/Japanese dictionary for word segmentation.
+    pub const CJ_DICT: &[u8] =
+        include_bytes!("generated/icu4x_data/segmenter_models/cjdict.postcard");
+
+    /// Thai dictionary for word segmentation.
+    pub const THAI_DICT: &[u8] =
+        include_bytes!("generated/icu4x_data/segmenter_models/thaidict.postcard");
+
+    /// Lao dictionary for word segmentation.
+    pub const LAO_DICT: &[u8] =
+        include_bytes!("generated/icu4x_data/segmenter_models/laodict.postcard");
+
+    /// Khmer dictionary for word segmentation.
+    pub const KHMER_DICT: &[u8] =
+        include_bytes!("generated/icu4x_data/segmenter_models/khmerdict.postcard");
+
+    /// Burmese dictionary for word segmentation.
+    pub const BURMESE_DICT: &[u8] =
+        include_bytes!("generated/icu4x_data/segmenter_models/burmesedict.postcard");
+
+    /// All bundled LSTM-based segmenters as (model ID, blob) pairs.
+    pub const ALL_LSTM: &[(&str, &[u8])] = &[
+        ("Thai_codepoints_exclusive_model4_heavy", THAI_LSTM),
+        ("Lao_codepoints_exclusive_model4_heavy", LAO_LSTM),
+        ("Khmer_codepoints_exclusive_model4_heavy", KHMER_LSTM),
+        ("Burmese_codepoints_exclusive_model4_heavy", BURMESE_LSTM),
+    ];
+
+    /// All bundled "preferred" segmenters (LSTM when possible, dictionary if not) as (model ID, blob) pairs.
+    pub const ALL_AUTO: &[(&str, &[u8])] = &[
+        ("cjdict", CJ_DICT),
+        ("Thai_codepoints_exclusive_model4_heavy", THAI_LSTM),
+        ("Lao_codepoints_exclusive_model4_heavy", LAO_LSTM),
+        ("Khmer_codepoints_exclusive_model4_heavy", KHMER_LSTM),
+        ("Burmese_codepoints_exclusive_model4_heavy", BURMESE_LSTM),
+    ];
+
+    /// All bundled dictionary-based segmenters as (model ID, blob) pairs.
+    pub const ALL_DICT: &[(&str, &[u8])] = &[
+        ("cjdict", CJ_DICT),
+        ("thaidict", THAI_DICT),
+        ("laodict", LAO_DICT),
+        ("khmerdict", KHMER_DICT),
+        ("burmesedict", BURMESE_DICT),
+    ];
+
+    /// All bundled segmenters, LSTM and dictionary, as (model ID, blob) pairs. Note that you cannot load both LSTM and
+    /// dictionary segmenters for the same locale at runtime.
+    pub const ALL: &[(&str, &[u8])] = &[
+        ("Thai_codepoints_exclusive_model4_heavy", THAI_LSTM),
+        ("Lao_codepoints_exclusive_model4_heavy", LAO_LSTM),
+        ("Khmer_codepoints_exclusive_model4_heavy", KHMER_LSTM),
+        ("Burmese_codepoints_exclusive_model4_heavy", BURMESE_LSTM),
+        ("cjdict", CJ_DICT),
+        ("thaidict", THAI_DICT),
+        ("laodict", LAO_DICT),
+        ("khmerdict", KHMER_DICT),
+        ("burmesedict", BURMESE_DICT),
+    ];
+}
diff --git a/parley_data_gen/Cargo.toml b/parley_data_gen/Cargo.toml
index a1b7bc84d..b6f24c5a7 100644
--- a/parley_data_gen/Cargo.toml
+++ b/parley_data_gen/Cargo.toml
@@ -15,7 +15,7 @@ icu_collections = { workspace = true, features = ["databake"] }
 icu_locale = { workspace = true }
 icu_normalizer = { workspace = true, features = ["compiled_data"] }
 icu_properties = { workspace = true, features = ["compiled_data"] }
-icu_provider_export = { workspace = true, features = ["baked_exporter"] }
+icu_provider_export = { workspace = true, features = ["baked_exporter", "blob_exporter"] }
 icu_provider_source = { workspace = true, features = ["networking", "use_wasm"] }
 icu_segmenter = { workspace = true }
 parley_data = { workspace = true, default-features = false, features = ["datagen"] }
diff --git a/parley_data_gen/README.md b/parley_data_gen/README.md
index eab41be6b..d24250221 100644
--- a/parley_data_gen/README.md
+++ b/parley_data_gen/README.md
@@ -7,7 +7,7 @@ The generator requires a network connection the first time it runs so that `icu_
 ## Usage
 
 ```
-cargo run -p parley_data_gen -- <output-dir>
+cargo run --release -p parley_data_gen -- <output-dir>
 ```
 
 The `output-dir` is created if it does not exist. After the command completes, the directory will contain:
diff --git a/parley_data_gen/src/lib.rs b/parley_data_gen/src/lib.rs
index 6b1ad6eff..40ad46045 100644
--- a/parley_data_gen/src/lib.rs
+++ b/parley_data_gen/src/lib.rs
@@ -13,9 +13,11 @@ use icu_properties::{
         BidiClass, Emoji, ExtendedPictographic, LineBreak, RegionalIndicator, VariationSelector,
     },
 };
+use icu_provider_export::blob_exporter::BlobExporter;
 use icu_provider_export::prelude::*;
 use icu_provider_source::SourceDataProvider;
 use parley_data::Properties;
+use std::fs::File;
 use std::io::{BufWriter, Write};
 
 const COPYRIGHT_HEADER: &str =
@@ -42,6 +44,8 @@ pub fn generate(out: std::path::PathBuf) {
             icu_segmenter::provider::SegmenterBreakGraphemeClusterV1::INFO,
             icu_segmenter::provider::SegmenterBreakWordOverrideV1::INFO,
             icu_segmenter::provider::SegmenterLstmAutoV1::INFO,
+            icu_segmenter::provider::SegmenterDictionaryAutoV1::INFO,
+            icu_segmenter::provider::SegmenterDictionaryExtendedV1::INFO,
             icu_segmenter::provider::SegmenterBreakWordV1::INFO,
             icu_segmenter::provider::SegmenterBreakLineV1::INFO,
             icu_normalizer::provider::NormalizerNfcV1::INFO,
@@ -109,7 +113,7 @@ pub fn generate(out: std::path::PathBuf) {
         if !composite_dir.exists() {
             std::fs::create_dir(&composite_dir).unwrap();
         }
-        let mut file = BufWriter::new(std::fs::File::create(composite_dir.join("mod.rs")).unwrap());
+        let mut file = BufWriter::new(File::create(composite_dir.join("mod.rs")).unwrap());
 
         writeln!(&mut file, "{COPYRIGHT_HEADER}").unwrap();
         writeln!(&mut file, "/// Backing data for the `CompositeProps`").unwrap();
@@ -129,7 +133,50 @@ pub fn generate(out: std::path::PathBuf) {
         .unwrap();
     }
 
-    let mut file = BufWriter::new(std::fs::File::create(out.join("mod.rs")).unwrap());
+    // Generate segmenter model blobs (LSTM models for Thai, Lao, Khmer, Burmese)
+    {
+        let models_dir = out.join("icu4x_data").join("segmenter_models");
+        std::fs::create_dir_all(&models_dir).unwrap();
+
+        for model in [
+            "Burmese_codepoints_exclusive_model4_heavy",
+            "Khmer_codepoints_exclusive_model4_heavy",
+            "Lao_codepoints_exclusive_model4_heavy",
+            "Thai_codepoints_exclusive_model4_heavy",
+            "cjdict",
+            "burmesedict",
+            "khmerdict",
+            "laodict",
+            "thaidict",
+        ] {
+            let blob_path = models_dir.join(format!("{model}.postcard"));
+
+            ExportDriver::new(
+                [DataLocaleFamily::single(DataLocale::default())],
+                DeduplicationStrategy::None.into(),
+                LocaleFallbacker::new_without_data(),
+            )
+            .with_markers([
+                icu_segmenter::provider::SegmenterLstmAutoV1::INFO,
+                icu_segmenter::provider::SegmenterDictionaryAutoV1::INFO,
+                // SegmenterDictionaryAutoV1 only includes dictionary data for scripts with no LSTM model
+                icu_segmenter::provider::SegmenterDictionaryExtendedV1::INFO,
+                icu_segmenter::provider::SegmenterBreakWordV1::INFO,
+                icu_segmenter::provider::SegmenterBreakWordOverrideV1::INFO,
+                icu_segmenter::provider::SegmenterBreakLineV1::INFO,
+            ])
+            .with_segmenter_models([(*model).to_string()])
+            .export(
+                &icu4x_source_provider,
+                BlobExporter::new_with_sink(Box::new(&mut BufWriter::new(
+                    File::create(&blob_path).unwrap(),
+                ))),
+            )
+            .unwrap_or_else(|e| panic!("Failed to export {model}: {e}"));
+        }
+    }
+
+    let mut file = BufWriter::new(File::create(out.join("mod.rs")).unwrap());
 
     writeln!(&mut file, "{COPYRIGHT_HEADER}").unwrap();
     writeln!(&mut file, "mod composite;").unwrap();
diff --git a/parley_dev/README.md b/parley_dev/README.md
index 967032ba5..43fb0b5bc 100644
--- a/parley_dev/README.md
+++ b/parley_dev/README.md
@@ -9,3 +9,4 @@ Some files included in this folder are under different licenses to the rest of t
 - The font file `Arimo-VariableFont_wght.ttf` in `./assets/arimo_fonts/` is licensed solely as documented in that folder (and is licensed under the Apache License, Version 2.0).
 - The font file `Roboto-Regular.ttf` in `./assets/roboto_fonts/` is licensed solely as documented in that folder (and is licensed under the Apache License, Version 2.0).
 - The font file `NotoKufiArabic-Regular.otf` in `./assets/noto_fonts/` is licensed solely as documented in that folder (and is licensed under the SIL Open Font License, Version 1.1).
+- The font file `NotoSansThai-Regular.ttf` in `./assets/noto_fonts/` is licensed solely as documented in that folder (and is licensed under the SIL Open Font License, Version 1.1).
diff --git a/parley_dev/assets/fonts/noto_fonts/NotoSansMyanmar-Regular.ttf b/parley_dev/assets/fonts/noto_fonts/NotoSansMyanmar-Regular.ttf
new file mode 100644
index 000000000..beb2bab10
Binary files /dev/null and b/parley_dev/assets/fonts/noto_fonts/NotoSansMyanmar-Regular.ttf differ
diff --git a/parley_dev/assets/fonts/noto_fonts/NotoSansThai-Regular.ttf b/parley_dev/assets/fonts/noto_fonts/NotoSansThai-Regular.ttf
new file mode 100644
index 000000000..ba78e8162
Binary files /dev/null and b/parley_dev/assets/fonts/noto_fonts/NotoSansThai-Regular.ttf differ
diff --git a/parley_dev/src/lib.rs b/parley_dev/src/lib.rs
index a096819d0..92daf49cc 100644
--- a/parley_dev/src/lib.rs
+++ b/parley_dev/src/lib.rs
@@ -19,7 +19,13 @@ pub fn font_dirs() -> impl Iterator<Item = PathBuf> {
 }
 
 /// The font families that are available in the assets/fonts directory.
-pub const FONT_FAMILIES: &[&str] = &["Arimo", "Roboto", "Noto Kufi Arabic"];
+pub static FONT_FAMILIES: &[&str] = &[
+    "Arimo",
+    "Roboto",
+    "Noto Kufi Arabic",
+    "Noto Sans Thai",
+    "Noto Sans Myanmar",
+];
 
 /// A sample to be used for development.
 #[derive(Debug)]
diff --git a/parley_tests/Cargo.toml b/parley_tests/Cargo.toml
index 2438e517a..7864e2a34 100644
--- a/parley_tests/Cargo.toml
+++ b/parley_tests/Cargo.toml
@@ -15,7 +15,8 @@ name = "tests"
 path = "tests/mod.rs"
 
 [dependencies]
-parley = { workspace = true, features = ["std"] }
+parley = { workspace = true, features = ["std", "runtime-segmenter-data"] }
+parley_data = { workspace = true }
 parley_dev = { workspace = true }
 parley_draw = { workspace = true, features = ["std", "vello_cpu"] }
 peniko = { workspace = true, features = ["std"] }
diff --git a/parley_tests/snapshots/mixed_script_line_break_with_multiple_models-0.png b/parley_tests/snapshots/mixed_script_line_break_with_multiple_models-0.png
new file mode 100644
index 000000000..87fb1187a
Binary files /dev/null and b/parley_tests/snapshots/mixed_script_line_break_with_multiple_models-0.png differ
diff --git a/parley_tests/snapshots/mixed_script_line_break_with_no_models-0.png b/parley_tests/snapshots/mixed_script_line_break_with_no_models-0.png
new file mode 100644
index 000000000..0da96e5b7
Binary files /dev/null and b/parley_tests/snapshots/mixed_script_line_break_with_no_models-0.png differ
diff --git a/parley_tests/snapshots/thai_line_break_with_model-0.png b/parley_tests/snapshots/thai_line_break_with_model-0.png
new file mode 100644
index 000000000..8193cea07
Binary files /dev/null and b/parley_tests/snapshots/thai_line_break_with_model-0.png differ
diff --git a/parley_tests/snapshots/thai_line_break_without_model-0.png b/parley_tests/snapshots/thai_line_break_without_model-0.png
new file mode 100644
index 000000000..cec2bad3d
Binary files /dev/null and b/parley_tests/snapshots/thai_line_break_without_model-0.png differ
diff --git a/parley_tests/tests/mod.rs b/parley_tests/tests/mod.rs
index 6fed5990a..3aed1d8c5 100644
--- a/parley_tests/tests/mod.rs
+++ b/parley_tests/tests/mod.rs
@@ -28,6 +28,7 @@ mod draw;
 mod editor;
 mod issues;
 mod lines;
+mod segmenter;
 mod styles;
 mod wrap;
 #[macro_use]
diff --git a/parley_tests/tests/segmenter.rs b/parley_tests/tests/segmenter.rs
new file mode 100644
index 000000000..f732d6d98
--- /dev/null
+++ b/parley_tests/tests/segmenter.rs
@@ -0,0 +1,102 @@
+// Copyright 2026 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Tests for runtime segmenter model loading.
+//!
+//! These tests verify that loading LSTM segmenter models at runtime improves
+//! word/line breaking for languages like Thai, Lao, Khmer, and Burmese.
+
+use crate::test_name;
+use crate::util::{ColorBrush, TestEnv};
+use parley::{Alignment, AlignmentOptions, SegmenterModelData, StyleProperty};
+use parley_data::bundled_models;
+use peniko::color::palette::css;
+
+/// "Hello, welcome to Thailand"
+const THAI_TEXT: &str = "สวัสดีครับ ยินดีต้อนรับสู่ประเทศไทย";
+
+fn load_thai_model() -> SegmenterModelData {
+    SegmenterModelData::from_static(bundled_models::THAI_LSTM)
+        .expect("Failed to load Thai LSTM model")
+}
+
+fn load_burmese_model() -> SegmenterModelData {
+    SegmenterModelData::from_static(bundled_models::BURMESE_LSTM)
+        .expect("Failed to load Burmese LSTM model")
+}
+
+/// Tests that Thai text line breaking improves with LSTM model.
+#[test]
+fn thai_line_break_without_model() {
+    let mut env = TestEnv::new(test_name!(), None);
+
+    let mut builder = env.ranged_builder(THAI_TEXT);
+    builder.push_default(StyleProperty::Brush(ColorBrush::new(css::BLACK)));
+    builder.push_default(StyleProperty::FontSize(24.0));
+
+    let mut layout = builder.build(THAI_TEXT);
+    // Use a narrow width to force line wrapping
+    layout.break_all_lines(Some(150.0));
+    layout.align(None, Alignment::Start, AlignmentOptions::default());
+
+    env.check_layout_snapshot(&layout);
+}
+
+/// Tests Thai text line breaking with LSTM model loaded.
+#[test]
+fn thai_line_break_with_model() {
+    let mut env = TestEnv::new(test_name!(), None);
+
+    // Load the Thai LSTM model
+    env.layout_context_mut()
+        .load_segmenter_models_auto([load_thai_model()]);
+
+    let mut builder = env.ranged_builder(THAI_TEXT);
+    builder.push_default(StyleProperty::Brush(ColorBrush::new(css::BLACK)));
+    builder.push_default(StyleProperty::FontSize(24.0));
+
+    let mut layout = builder.build(THAI_TEXT);
+    // Use the same narrow width as the test without model
+    layout.break_all_lines(Some(150.0));
+    layout.align(None, Alignment::Start, AlignmentOptions::default());
+
+    env.check_layout_snapshot(&layout);
+}
+
+const MIXED_THAI_BURMESE: &str = "สวัสดีครับ\n(Hello in Thai)\nမင်္ဂလာပါ\n(Hello in Burm-ese)";
+
+/// Tests that loading multiple LSTM models works correctly for mixed-script text.
+#[test]
+fn mixed_script_line_break_with_no_models() {
+    let mut env = TestEnv::new(test_name!(), None);
+
+    let mut builder = env.ranged_builder(MIXED_THAI_BURMESE);
+    builder.push_default(StyleProperty::FontSize(20.0));
+
+    let mut layout = builder.build(MIXED_THAI_BURMESE);
+    // Use a narrow width to force line wrapping
+    layout.break_all_lines(Some(70.0));
+    layout.align(None, Alignment::Start, AlignmentOptions::default());
+
+    env.check_layout_snapshot(&layout);
+}
+
+/// Tests that loading multiple LSTM models works correctly for mixed-script text.
+#[test]
+fn mixed_script_line_break_with_multiple_models() {
+    let mut env = TestEnv::new(test_name!(), None);
+
+    // Load both Thai and Burmese LSTM models
+    env.layout_context_mut()
+        .load_segmenter_models_auto([load_thai_model(), load_burmese_model()]);
+
+    let mut builder = env.ranged_builder(MIXED_THAI_BURMESE);
+    builder.push_default(StyleProperty::FontSize(20.0));
+
+    let mut layout = builder.build(MIXED_THAI_BURMESE);
+    // Use a narrow width to force line wrapping
+    layout.break_all_lines(Some(70.0));
+    layout.align(None, Alignment::Start, AlignmentOptions::default());
+
+    env.check_layout_snapshot(&layout);
+}
diff --git a/parley_tests/tests/util/env.rs b/parley_tests/tests/util/env.rs
index d0ad36d2c..b95cb53e0 100644
--- a/parley_tests/tests/util/env.rs
+++ b/parley_tests/tests/util/env.rs
@@ -28,6 +28,8 @@ fn snapshot_dir() -> PathBuf {
 pub(crate) const FONT_FAMILY_LIST: &[FontFamilyName<'_>] = &[
     FontFamilyName::Named(Cow::Borrowed("Roboto")),
     FontFamilyName::Named(Cow::Borrowed("Noto Kufi Arabic")),
+    FontFamilyName::Named(Cow::Borrowed("Noto Sans Thai")),
+    FontFamilyName::Named(Cow::Borrowed("Noto Sans Myanmar")),
 ];
 
 pub(crate) const CLUSTER_INFO_COLOR: Color = Color::from_rgba8(100, 100, 100, 255);
@@ -189,6 +191,10 @@ impl TestEnv {
         builder
     }
 
+    pub(crate) fn layout_context_mut(&mut self) -> &mut LayoutContext<ColorBrush> {
+        &mut self.layout_cx
+    }
+
     pub(crate) fn driver<'a>(
         &'a mut self,
         editor: &'a mut PlainEditor<ColorBrush>,