diff --git a/parley/src/lib.rs b/parley/src/lib.rs
index 1aa7938a4..18133b81b 100644
--- a/parley/src/lib.rs
+++ b/parley/src/lib.rs
@@ -127,10 +127,12 @@ mod tests;
 
 pub use linebender_resource_handle::FontData;
 pub use parlance::BaseDirection;
+pub use parley_engine::AnalysisDataSources;
 pub use parley_engine::break_overrides::{
     AsciiLineBreakTable, AsciiLineBreakTableBuilder, CHROMIUM_LINE_BREAK_OVERRIDE,
     LineBreakContext, LineBreakOverrideFn,
 };
+pub use parley_engine::emoji;
 
 pub use builder::{RangedBuilder, StyleRunBuilder, TreeBuilder};
 pub use context::LayoutContext;
diff --git a/parley/src/tests/mod.rs b/parley/src/tests/mod.rs
index 52b77f872..f6f46b89d 100644
--- a/parley/src/tests/mod.rs
+++ b/parley/src/tests/mod.rs
@@ -3,4 +3,5 @@
 
 mod test_analysis;
 mod test_builders;
+mod test_emoji_segmenters;
 mod utils;
diff --git a/parley/src/tests/test_analysis.rs b/parley/src/tests/test_analysis.rs
index 7084d9c3a..fe5d9c3d3 100644
--- a/parley/src/tests/test_analysis.rs
+++ b/parley/src/tests/test_analysis.rs
@@ -1296,7 +1296,7 @@ fn test_whitespace_contiguous_interspersed_in_latin_mixed() {
 }
 
 #[test]
-fn test_color_emoji_with_non_printing_variation_selector() {
+fn test_color_emoji_with_presentation() {
     verify_analysis("\u{270c}\u{fe0f}", |_| {})
         .expect_is_emoji_or_pictograph_list(vec![true, false])
         .expect_is_variation_selector_list(vec![false, true]);
diff --git a/parley/src/tests/test_emoji_segmenters.rs b/parley/src/tests/test_emoji_segmenters.rs
new file mode 100644
index 000000000..afc515b1d
--- /dev/null
+++ b/parley/src/tests/test_emoji_segmenters.rs
@@ -0,0 +1,618 @@
+// Copyright 2026 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Tests extracted from the [emoji segmenter].
+//!
+//! [emoji segmenter]: <https://github.com/google/emoji-segmenter>
+
+use alloc::vec::Vec;
+use core::char;
+
+use crate::{
+    AnalysisDataSources,
+    emoji::{EmojiDFA, EmojiPresentationStyle, EmojiSegmentationCategory},
+};
+
+struct TestEntity<'a> {
+    sequence: &'a [u32],
+    categories: &'a [EmojiSegmentationCategory],
+    style: EmojiPresentationStyle,
+}
+
+fn assert_emoji_segmenters_produce_same_result(entity: TestEntity<'_>) {
+    let analysis = AnalysisDataSources::new();
+
+    let mut emoji_dfa = EmojiDFA::new();
+
+    let result = entity
+        .sequence
+        .iter()
+        .copied()
+        .map(|cp| {
+            let ch = char::from_u32(cp).unwrap();
+            let emoji_properties = analysis.emoji_properties(ch);
+
+            let category = EmojiSegmentationCategory::from_codepoint(cp, emoji_properties);
+
+            emoji_dfa.step_record(category);
+
+            category
+        })
+        .collect::<Vec<_>>();
+
+    assert_eq!(result, entity.categories);
+    assert_eq!(emoji_dfa.presentation_style(), entity.style);
+}
+
+// Emoji presentation default; Encoded: 😀
+#[test]
+fn emoji_presentation_default() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F600, // GRINNING FACE
+        ],
+        categories: &[EmojiSegmentationCategory::EmojiPresentation],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Text presentation default (copyright); Encoded: ©
+#[test]
+fn text_presentation_default() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x00A9, // COPYRIGHT SIGN
+        ],
+        categories: &[EmojiSegmentationCategory::Emoji],
+        style: EmojiPresentationStyle::Default,
+    });
+}
+
+// Lone keycap base; Encoded: 1
+#[test]
+fn long_keycap_base() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[0x0031], // DIGIT ONE
+        categories: &[EmojiSegmentationCategory::KeycapBase],
+        style: EmojiPresentationStyle::Default,
+    });
+}
+
+// Keycap base + VS-15 (no term); Encoded: 1︎
+#[test]
+fn keycap_base_vs15() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x0031, // DIGIT ONE
+            0xFE0E, // VARIATION SELECTOR-15
+        ],
+        categories: &[
+            EmojiSegmentationCategory::KeycapBase,
+            EmojiSegmentationCategory::Vs15,
+        ],
+        style: EmojiPresentationStyle::Text,
+    });
+}
+
+// Keycap base + VS-16 (no term); Encoded: 1️
+#[test]
+fn keycap_base_vs16() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x0031, // DIGIT ONE
+            0xFE0F, // VARIATION SELECTOR-16
+        ],
+        categories: &[
+            EmojiSegmentationCategory::KeycapBase,
+            EmojiSegmentationCategory::Vs16,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Unqualified keycap; Encoded: #⃣
+#[test]
+fn unqualified_keycap() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x0023, // NUMBER SIGN
+            0x20E3, // COMBINING ENCLOSING KEYCAP
+        ],
+        categories: &[
+            EmojiSegmentationCategory::KeycapBase,
+            EmojiSegmentationCategory::KeycapEnd,
+        ],
+        style: EmojiPresentationStyle::Default,
+    });
+}
+
+// Keycap + VS-15 + term; Encoded: 1︎⃣
+#[test]
+fn keycap_vs15_term() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x0031, // DIGIT ONE
+            0xFE0E, // VARIATION SELECTOR-15
+            0x20E3, // COMBINING ENCLOSING KEYCAP
+        ],
+        categories: &[
+            EmojiSegmentationCategory::KeycapBase,
+            EmojiSegmentationCategory::Vs15,
+            EmojiSegmentationCategory::KeycapEnd,
+        ],
+        style: EmojiPresentationStyle::Text,
+    });
+}
+
+// Qualified keycap; Encoded: *️⃣
+#[test]
+fn qualified_keycap() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x002A, // ASTERISK
+            0xFE0F, // VARIATION SELECTOR-16
+            0x20E3, // COMBINING ENCLOSING KEYCAP
+        ],
+        categories: &[
+            EmojiSegmentationCategory::KeycapBase,
+            EmojiSegmentationCategory::Vs16,
+            EmojiSegmentationCategory::KeycapEnd,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Lone emoji modifier (Fitzpatrick); Encoded: 🏻
+#[test]
+fn lone_emoji_modifier() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F3FB, // EMOJI MODIFIER FITZPATRICK TYPE-1-2
+        ],
+        categories: &[EmojiSegmentationCategory::EmojiModifier],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Bare modifier base, text default; Encoded: ☝
+#[test]
+fn bare_modifier_base_text_default() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x261D, // WHITE UP POINTING INDEX
+        ],
+        categories: &[EmojiSegmentationCategory::EmojiModifierBase],
+        style: EmojiPresentationStyle::Text,
+    });
+}
+
+// Modifier base (text default) + VS-16; Encoded: ☝️
+#[test]
+fn modifier_base_text_default_vs16() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x261D, // WHITE UP POINTING INDEX
+            0xFE0F, // VARIATION SELECTOR-16
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Vs16,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Modifier base (text default) + skin tone; Encoded: ☝🏻
+#[test]
+fn modifier_base_text_default_skin_tone() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x261D,  // WHITE UP POINTING INDEX
+            0x1F3FB, // EMOJI MODIFIER FITZPATRICK TYPE-1-2
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::EmojiModifier,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Modifier base (emoji default) + skin tone; Encoded: 👦🏻
+#[test]
+fn modifier_base_emoji_default_skin_tone() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F466, // BOY
+            0x1F3FB, // EMOJI MODIFIER FITZPATRICK TYPE-1-2
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::EmojiModifier,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Lone regional indicator; Encoded: 🇺
+#[test]
+fn lone_regional_indicator() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F1FA, // REGIONAL INDICATOR SYMBOL LETTER U
+        ],
+        categories: &[EmojiSegmentationCategory::RegionalIndicator],
+        style: EmojiPresentationStyle::Default,
+    });
+}
+
+// Flag sequence (US); Encoded: 🇺🇸
+#[test]
+fn flag_sequence_us() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F1FA, // REGIONAL INDICATOR SYMBOL LETTER U
+            0x1F1F8, // REGIONAL INDICATOR SYMBOL LETTER S
+        ],
+        categories: &[
+            EmojiSegmentationCategory::RegionalIndicator,
+            EmojiSegmentationCategory::RegionalIndicator,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Double lone regional indicator + Flag sequence (US); Encoded: 🇺🇺🇸
+//
+// FIXME: segmented clusters are incorrect
+//  ✖️, [[0x1F1FA, 0x1F1FA], [0x1F1F8]]
+//  ✔️, [[0x1F1FA], [0x1F1FA, 0x1F1F8]]
+#[test]
+#[ignore]
+fn double_lone_regional_indicator_flag_sequence_us() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F1FA, // REGIONAL INDICATOR SYMBOL LETTER U
+            0x1F1FA, // REGIONAL INDICATOR SYMBOL LETTER U
+            0x1F1F8, // REGIONAL INDICATOR SYMBOL LETTER S
+        ],
+        categories: &[
+            EmojiSegmentationCategory::RegionalIndicator,
+            EmojiSegmentationCategory::RegionalIndicator,
+            EmojiSegmentationCategory::RegionalIndicator,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Text-default emoji + VS-15; Encoded: ☺︎
+#[test]
+fn text_default_emoji_vs15() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x263A, // WHITE SMILING FACE
+            0xFE0E, // VARIATION SELECTOR-15
+        ],
+        categories: &[
+            EmojiSegmentationCategory::Emoji,
+            EmojiSegmentationCategory::Vs15,
+        ],
+        style: EmojiPresentationStyle::Text,
+    });
+}
+
+// Text-default emoji + VS-16; Encoded: ☺️
+#[test]
+fn text_default_emoji_vs16() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x263A, // WHITE SMILING FACE
+            0xFE0F, // VARIATION SELECTOR-16
+        ],
+        categories: &[
+            EmojiSegmentationCategory::Emoji,
+            EmojiSegmentationCategory::Vs16,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Emoji-default emoji + VS-15; Encoded: 😀︎
+#[test]
+fn emoji_default_emoji_vs15() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F600, // GRINNING FACE
+            0xFE0E,  // VARIATION SELECTOR-15
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiPresentation,
+            EmojiSegmentationCategory::Vs15,
+        ],
+        style: EmojiPresentationStyle::Text,
+    });
+}
+
+// Emoji-default emoji + VS-16; Encoded: 😀️
+#[test]
+fn emoji_default_emoji_vs16() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F600, // GRINNING FACE
+            0xFE0F,  // VARIATION SELECTOR-16
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiPresentation,
+            EmojiSegmentationCategory::Vs16,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// ZWJ family; Encoded: 👨‍👩‍👧
+#[test]
+fn zwj_family() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F468, // MAN
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F469, // WOMAN
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F467, // GIRL
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Long ZWJ family (4 members); Encoded: 👨‍👩‍👧‍👦
+#[test]
+fn long_zwj_family() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F468, // MAN
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F469, // WOMAN
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F467, // GIRL
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F466, // BOY
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// ZWJ couple; Encoded: 👨‍❤‍👨
+#[test]
+fn zwj_couple() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F468, // MAN
+            0x200D,  // ZERO WIDTH JOINER
+            0x2764,  // HEAVY BLACK HEART
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F468, // MAN
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::Emoji,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// ZWJ with VS-16 element; Encoded: 👨️‍👩
+#[test]
+fn zwj_with_vs16_element() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F468, // MAN
+            0xFE0F,  // VARIATION SELECTOR-16
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F469, // WOMAN
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Vs16,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// ZWJ with VS-16 on both elements; Encoded: 👨️‍👩️
+#[test]
+fn zwj_with_vs16_on_both_elements() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F468, // MAN
+            0xFE0F,  // VARIATION SELECTOR-16
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F469, // WOMAN
+            0xFE0F,  // VARIATION SELECTOR-16
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Vs16,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::Vs16,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// ZWJ after modifier sequence; Encoded: 👦🏻‍💻
+#[test]
+fn zwj_after_modifier_sequence() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F466, // BOY
+            0x1F3FB, // EMOJI MODIFIER FITZPATRICK TYPE-1-2
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F4BB, // PERSONAL COMPUTER
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::EmojiModifier,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiPresentation,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// ZWJ technologist with skin tone; Encoded: 👨🏻‍💻
+#[test]
+fn zwj_technologist_with_skin_tone() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F468, // MAN
+            0x1F3FB, // EMOJI MODIFIER FITZPATRICK TYPE-1-2
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F4BB, // PERSONAL COMPUTER
+        ],
+        categories: &[
+            EmojiSegmentationCategory::EmojiModifierBase,
+            EmojiSegmentationCategory::EmojiModifier,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiPresentation,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// VS-16 enables ZWJ continuation; Encoded: ☺️‍👩
+#[test]
+fn vs16_enables_zwj_continuation() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x263A,  // WHITE SMILING FACE
+            0xFE0F,  // VARIATION SELECTOR-16
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F469, // WOMAN
+        ],
+        categories: &[
+            EmojiSegmentationCategory::Emoji,
+            EmojiSegmentationCategory::Vs16,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiModifierBase,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// Tag sequence (England); Encoded: 🏴󠁧󠁢󠁥󠁮󠁧󠁿
+#[test]
+fn tag_sequence_england() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F3F4, // WAVING BLACK FLAG
+            0xE0067, // TAG LATIN SMALL LETTER G
+            0xE0062, // TAG LATIN SMALL LETTER B
+            0xE0065, // TAG LATIN SMALL LETTER E
+            0xE006E, // TAG LATIN SMALL LETTER N
+            0xE0067, // TAG LATIN SMALL LETTER G
+            0xE007F, // CANCEL TAG
+        ],
+        categories: &[
+            EmojiSegmentationCategory::TagBase,
+            EmojiSegmentationCategory::TagSpec,
+            EmojiSegmentationCategory::TagSpec,
+            EmojiSegmentationCategory::TagSpec,
+            EmojiSegmentationCategory::TagSpec,
+            EmojiSegmentationCategory::TagSpec,
+            EmojiSegmentationCategory::TagEnd,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// TAG_BASE as ZWJ element; Encoded: 🏴‍😀"
+#[test]
+fn tag_base_as_zwj_element() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F3F4, // WAVING BLACK FLAG
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F600, // GRINNING FACE
+        ],
+        categories: &[
+            EmojiSegmentationCategory::TagBase,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiPresentation,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// TAG_BASE + VS-16 + ZWJ; Encoded: 🏴️‍😀",
+#[test]
+fn tag_base_vs16_as_zwj() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F3F4, // WAVING BLACK FLAG
+            0xFE0F,  // VARIATION SELECTOR-16
+            0x200D,  // ZERO WIDTH JOINER
+            0x1F600, // GRINNING FACE
+        ],
+        categories: &[
+            EmojiSegmentationCategory::TagBase,
+            EmojiSegmentationCategory::Vs16,
+            EmojiSegmentationCategory::Zwj,
+            EmojiSegmentationCategory::EmojiPresentation,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
+
+// TAG_BASE + VS-15; Encoded: 🏴︎
+#[test]
+fn tag_base_vs15() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F3F4, // WAVING BLACK FLAG
+            0xFE0E,  // VARIATION SELECTOR-15
+        ],
+        categories: &[
+            EmojiSegmentationCategory::TagBase,
+            EmojiSegmentationCategory::Vs15,
+        ],
+        style: EmojiPresentationStyle::Text,
+    });
+}
+
+// TAG_BASE + VS-16; Encoded: 🏴️
+#[test]
+fn tag_base_vs16() {
+    assert_emoji_segmenters_produce_same_result(TestEntity {
+        sequence: &[
+            0x1F3F4, // WAVING BLACK FLAG
+            0xFE0F,  // VARIATION SELECTOR-16
+        ],
+        categories: &[
+            EmojiSegmentationCategory::TagBase,
+            EmojiSegmentationCategory::Vs16,
+        ],
+        style: EmojiPresentationStyle::Emoji,
+    });
+}
diff --git a/parley_data/src/emoji.rs b/parley_data/src/emoji.rs
new file mode 100644
index 000000000..a356e9d80
--- /dev/null
+++ b/parley_data/src/emoji.rs
@@ -0,0 +1,104 @@
+// Copyright 2026 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+/// Emoji character properties relevant for text analysis.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct EmojiProperties(u32);
+
+impl EmojiProperties {
+    const EMOJI_SHIFT: u32 = 0;
+    const EXTENDED_PICTOGRAPHIC_SHIFT: u32 = 1;
+    const EMOJI_COMPONENT_SHIFT: u32 = 2;
+    const EMOJI_PRESENTATION_SHIFT: u32 = 3;
+    const EMOJI_MODIFIER_SHIFT: u32 = 4;
+    const EMOJI_MODIFIER_BASE_SHIFT: u32 = 5;
+    const REGIONAL_INDICATOR_SHIFT: u32 = 6;
+
+    const EMOJI_MASK: u32 = 1 << Self::EMOJI_SHIFT;
+    const EXTENDED_PICTOGRAPHIC_MASK: u32 = 1 << Self::EXTENDED_PICTOGRAPHIC_SHIFT;
+    const EMOJI_COMPONENT_MASK: u32 = 1 << Self::EMOJI_COMPONENT_SHIFT;
+    const EMOJI_PRESENTATION_MASK: u32 = 1 << Self::EMOJI_PRESENTATION_SHIFT;
+    const EMOJI_MODIFIER_MASK: u32 = 1 << Self::EMOJI_MODIFIER_SHIFT;
+    const EMOJI_MODIFIER_BASE_MASK: u32 = 1 << Self::EMOJI_MODIFIER_BASE_SHIFT;
+    const REGIONAL_INDICATOR_MASK: u32 = 1 << Self::REGIONAL_INDICATOR_SHIFT;
+
+    /// All zeroes.
+    pub const ZERO: Self = Self(0);
+
+    #[cfg(feature = "baked")]
+    #[inline]
+    /// Returns the properties for a given character.
+    pub const fn get(ch: char) -> Self {
+        Self(crate::generated::emoji_composite_get(ch as u32))
+    }
+
+    /// Creates a new [`EmojiProperties`] from the given properties
+    #[inline]
+    pub const fn new(
+        is_emoji: bool,
+        is_extended_pictographic: bool,
+        is_emoji_component: bool,
+        is_emoji_presentation: bool,
+        is_emoji_modifier: bool,
+        is_emoji_modifier_base: bool,
+        is_regional_indicator: bool,
+    ) -> Self {
+        Self(
+            (is_emoji as u32) << Self::EMOJI_SHIFT
+                | (is_extended_pictographic as u32) << Self::EXTENDED_PICTOGRAPHIC_SHIFT
+                | (is_emoji_component as u32) << Self::EMOJI_COMPONENT_SHIFT
+                | (is_emoji_presentation as u32) << Self::EMOJI_PRESENTATION_SHIFT
+                | (is_emoji_modifier as u32) << Self::EMOJI_MODIFIER_SHIFT
+                | (is_emoji_modifier_base as u32) << Self::EMOJI_MODIFIER_BASE_SHIFT
+                | (is_regional_indicator as u32) << Self::REGIONAL_INDICATOR_SHIFT,
+        )
+    }
+
+    /// Returns whether the character is an emoji.
+    #[inline]
+    pub const fn is_emoji(self) -> bool {
+        self.0 & Self::EMOJI_MASK != 0
+    }
+
+    /// Returns whether the character is an extended pictographic.
+    #[inline]
+    pub const fn is_extended_pictographic(self) -> bool {
+        self.0 & Self::EXTENDED_PICTOGRAPHIC_MASK != 0
+    }
+
+    /// Returns whether the character is an emoji component.
+    #[inline]
+    pub const fn is_emoji_component(self) -> bool {
+        self.0 & Self::EMOJI_COMPONENT_MASK != 0
+    }
+
+    /// Returns whether the character is an emoji presentation.
+    #[inline]
+    pub const fn is_emoji_presentation(self) -> bool {
+        self.0 & Self::EMOJI_PRESENTATION_MASK != 0
+    }
+
+    /// Returns whether the character is a modifier.
+    #[inline]
+    pub const fn is_emoji_modifier(self) -> bool {
+        self.0 & Self::EMOJI_MODIFIER_MASK != 0
+    }
+
+    /// Returns whether the character is a modifier base.
+    #[inline]
+    pub const fn is_emoji_modifier_base(self) -> bool {
+        self.0 & Self::EMOJI_MODIFIER_BASE_MASK != 0
+    }
+
+    /// Returns whether the character is a region indicator.
+    #[inline]
+    pub const fn is_regional_indicator(self) -> bool {
+        self.0 & Self::REGIONAL_INDICATOR_MASK != 0
+    }
+}
+
+impl From<EmojiProperties> for u32 {
+    fn from(value: EmojiProperties) -> Self {
+        value.0
+    }
+}
diff --git a/parley_data/src/generated/mod.rs b/parley_data/src/generated/mod.rs
index 0de3bf471..63b84e743 100644
--- a/parley_data/src/generated/mod.rs
+++ b/parley_data/src/generated/mod.rs
@@ -999,3 +999,311 @@ pub(crate) fn composite_packtab_get(u: usize) -> u32 {
 pub fn composite_get(cp: u32) -> u32 {
     composite_packtab_get(cp as usize)
 }
+
+static EMOJI_COMPOSITE_U8: [u8; 10] = [2, 3, 4, 5, 11, 15, 29, 35, 43, 77];
+
+#[allow(missing_docs, reason = "generated code")]
+#[inline]
+pub const fn emoji_composite_get(cp: u32) -> u32 {
+    let idx = match cp {
+        0x1F02C..=0x1F02F
+        | 0x1F094..=0x1F09F
+        | 0x1F0AF..=0x1F0B0
+        | 0x1F0C0
+        | 0x1F0D0
+        | 0x1F0F6..=0x1F0FF
+        | 0x1F1AE..=0x1F1E5
+        | 0x1F203..=0x1F20F
+        | 0x1F23C..=0x1F23F
+        | 0x1F249..=0x1F24F
+        | 0x1F252..=0x1F25F
+        | 0x1F266..=0x1F2FF
+        | 0x1F6D9..=0x1F6DB
+        | 0x1F6ED..=0x1F6EF
+        | 0x1F6FD..=0x1F6FF
+        | 0x1F7DA..=0x1F7DF
+        | 0x1F7EC..=0x1F7EF
+        | 0x1F7F1..=0x1F7FF
+        | 0x1F80C..=0x1F80F
+        | 0x1F848..=0x1F84F
+        | 0x1F85A..=0x1F85F
+        | 0x1F888..=0x1F88F
+        | 0x1F8AE..=0x1F8AF
+        | 0x1F8BC..=0x1F8BF
+        | 0x1F8C2..=0x1F8CF
+        | 0x1F8D9..=0x1F8FF
+        | 0x1FA58..=0x1FA5F
+        | 0x1FA6E..=0x1FA6F
+        | 0x1FA7D..=0x1FA7F
+        | 0x1FA8B..=0x1FA8D
+        | 0x1FAC7
+        | 0x1FAC9..=0x1FACC
+        | 0x1FADD..=0x1FADE
+        | 0x1FAEB..=0x1FAEE
+        | 0x1FAF9..=0x1FAFF
+        | 0x1FC00..=0x1FFFD => 0,
+        0xA9
+        | 0xAE
+        | 0x203C
+        | 0x2049
+        | 0x2122
+        | 0x2139
+        | 0x2194..=0x2199
+        | 0x21A9..=0x21AA
+        | 0x2328
+        | 0x23CF
+        | 0x23ED..=0x23EF
+        | 0x23F1..=0x23F2
+        | 0x23F8..=0x23FA
+        | 0x24C2
+        | 0x25AA..=0x25AB
+        | 0x25B6
+        | 0x25C0
+        | 0x25FB..=0x25FC
+        | 0x2600..=0x2604
+        | 0x260E
+        | 0x2611
+        | 0x2618
+        | 0x2620
+        | 0x2622..=0x2623
+        | 0x2626
+        | 0x262A
+        | 0x262E..=0x262F
+        | 0x2638..=0x263A
+        | 0x2640
+        | 0x2642
+        | 0x265F..=0x2660
+        | 0x2663
+        | 0x2665..=0x2666
+        | 0x2668
+        | 0x267B
+        | 0x267E
+        | 0x2692
+        | 0x2694..=0x2697
+        | 0x2699
+        | 0x269B..=0x269C
+        | 0x26A0
+        | 0x26A7
+        | 0x26B0..=0x26B1
+        | 0x26C8
+        | 0x26CF
+        | 0x26D1
+        | 0x26D3
+        | 0x26E9
+        | 0x26F0..=0x26F1
+        | 0x26F4
+        | 0x26F7..=0x26F8
+        | 0x2702
+        | 0x2708..=0x2709
+        | 0x270F
+        | 0x2712
+        | 0x2714
+        | 0x2716
+        | 0x271D
+        | 0x2721
+        | 0x2733..=0x2734
+        | 0x2744
+        | 0x2747
+        | 0x2763..=0x2764
+        | 0x27A1
+        | 0x2934..=0x2935
+        | 0x2B05..=0x2B07
+        | 0x3030
+        | 0x303D
+        | 0x3297
+        | 0x3299
+        | 0x1F170..=0x1F171
+        | 0x1F17E..=0x1F17F
+        | 0x1F202
+        | 0x1F237
+        | 0x1F321
+        | 0x1F324..=0x1F32C
+        | 0x1F336
+        | 0x1F37D
+        | 0x1F396..=0x1F397
+        | 0x1F399..=0x1F39B
+        | 0x1F39E..=0x1F39F
+        | 0x1F3CD..=0x1F3CE
+        | 0x1F3D4..=0x1F3DF
+        | 0x1F3F3
+        | 0x1F3F5
+        | 0x1F3F7
+        | 0x1F43F
+        | 0x1F441
+        | 0x1F4FD
+        | 0x1F549..=0x1F54A
+        | 0x1F56F..=0x1F570
+        | 0x1F573
+        | 0x1F576..=0x1F579
+        | 0x1F587
+        | 0x1F58A..=0x1F58D
+        | 0x1F5A5
+        | 0x1F5A8
+        | 0x1F5B1..=0x1F5B2
+        | 0x1F5BC
+        | 0x1F5C2..=0x1F5C4
+        | 0x1F5D1..=0x1F5D3
+        | 0x1F5DC..=0x1F5DE
+        | 0x1F5E1
+        | 0x1F5E3
+        | 0x1F5E8
+        | 0x1F5EF
+        | 0x1F5F3
+        | 0x1F5FA
+        | 0x1F6CB
+        | 0x1F6CD..=0x1F6CF
+        | 0x1F6E0..=0x1F6E5
+        | 0x1F6E9
+        | 0x1F6F0
+        | 0x1F6F3 => 1,
+        0x200D | 0x20E3 | 0xFE0F | 0xE0020..=0xE007F => 2,
+        0x23 | 0x2A | 0x30..=0x39 => 3,
+        0x231A..=0x231B
+        | 0x23E9..=0x23EC
+        | 0x23F0
+        | 0x23F3
+        | 0x25FD..=0x25FE
+        | 0x2614..=0x2615
+        | 0x2648..=0x2653
+        | 0x267F
+        | 0x2693
+        | 0x26A1
+        | 0x26AA..=0x26AB
+        | 0x26BD..=0x26BE
+        | 0x26C4..=0x26C5
+        | 0x26CE
+        | 0x26D4
+        | 0x26EA
+        | 0x26F2..=0x26F3
+        | 0x26F5
+        | 0x26FA
+        | 0x26FD
+        | 0x2705
+        | 0x2728
+        | 0x274C
+        | 0x274E
+        | 0x2753..=0x2755
+        | 0x2757
+        | 0x2795..=0x2797
+        | 0x27B0
+        | 0x27BF
+        | 0x2B1B..=0x2B1C
+        | 0x2B50
+        | 0x2B55
+        | 0x1F004
+        | 0x1F0CF
+        | 0x1F18E
+        | 0x1F191..=0x1F19A
+        | 0x1F201
+        | 0x1F21A
+        | 0x1F22F
+        | 0x1F232..=0x1F236
+        | 0x1F238..=0x1F23A
+        | 0x1F250..=0x1F251
+        | 0x1F300..=0x1F320
+        | 0x1F32D..=0x1F335
+        | 0x1F337..=0x1F37C
+        | 0x1F37E..=0x1F384
+        | 0x1F386..=0x1F393
+        | 0x1F3A0..=0x1F3C1
+        | 0x1F3C5..=0x1F3C6
+        | 0x1F3C8..=0x1F3C9
+        | 0x1F3CF..=0x1F3D3
+        | 0x1F3E0..=0x1F3F0
+        | 0x1F3F4
+        | 0x1F3F8..=0x1F3FA
+        | 0x1F400..=0x1F43E
+        | 0x1F440
+        | 0x1F444..=0x1F445
+        | 0x1F451..=0x1F465
+        | 0x1F479..=0x1F47B
+        | 0x1F47D..=0x1F480
+        | 0x1F484
+        | 0x1F488..=0x1F48E
+        | 0x1F490
+        | 0x1F492..=0x1F4A9
+        | 0x1F4AB..=0x1F4FC
+        | 0x1F4FF..=0x1F53D
+        | 0x1F54B..=0x1F54E
+        | 0x1F550..=0x1F567
+        | 0x1F5A4
+        | 0x1F5FB..=0x1F644
+        | 0x1F648..=0x1F64A
+        | 0x1F680..=0x1F6A2
+        | 0x1F6A4..=0x1F6B3
+        | 0x1F6B7..=0x1F6BF
+        | 0x1F6C1..=0x1F6C5
+        | 0x1F6D0..=0x1F6D2
+        | 0x1F6D5..=0x1F6D8
+        | 0x1F6DC..=0x1F6DF
+        | 0x1F6EB..=0x1F6EC
+        | 0x1F6F4..=0x1F6FC
+        | 0x1F7E0..=0x1F7EB
+        | 0x1F7F0
+        | 0x1F90D..=0x1F90E
+        | 0x1F910..=0x1F917
+        | 0x1F920..=0x1F925
+        | 0x1F927..=0x1F92F
+        | 0x1F93A
+        | 0x1F93F..=0x1F945
+        | 0x1F947..=0x1F976
+        | 0x1F978..=0x1F9AF
+        | 0x1F9B4
+        | 0x1F9B7
+        | 0x1F9BA
+        | 0x1F9BC..=0x1F9CC
+        | 0x1F9D0
+        | 0x1F9DE..=0x1F9FF
+        | 0x1FA70..=0x1FA7C
+        | 0x1FA80..=0x1FA8A
+        | 0x1FA8E..=0x1FAC2
+        | 0x1FAC6
+        | 0x1FAC8
+        | 0x1FACD..=0x1FADC
+        | 0x1FADF..=0x1FAEA
+        | 0x1FAEF => 4,
+        0x1F9B0..=0x1F9B3 => 5,
+        0x1F3FB..=0x1F3FF => 6,
+        0x261D | 0x26F9 | 0x270C..=0x270D | 0x1F3CB..=0x1F3CC | 0x1F574..=0x1F575 | 0x1F590 => 7,
+        0x270A..=0x270B
+        | 0x1F385
+        | 0x1F3C2..=0x1F3C4
+        | 0x1F3C7
+        | 0x1F3CA
+        | 0x1F442..=0x1F443
+        | 0x1F446..=0x1F450
+        | 0x1F466..=0x1F478
+        | 0x1F47C
+        | 0x1F481..=0x1F483
+        | 0x1F485..=0x1F487
+        | 0x1F48F
+        | 0x1F491
+        | 0x1F4AA
+        | 0x1F57A
+        | 0x1F595..=0x1F596
+        | 0x1F645..=0x1F647
+        | 0x1F64B..=0x1F64F
+        | 0x1F6A3
+        | 0x1F6B4..=0x1F6B6
+        | 0x1F6C0
+        | 0x1F6CC
+        | 0x1F90C
+        | 0x1F90F
+        | 0x1F918..=0x1F91F
+        | 0x1F926
+        | 0x1F930..=0x1F939
+        | 0x1F93C..=0x1F93E
+        | 0x1F977
+        | 0x1F9B5..=0x1F9B6
+        | 0x1F9B8..=0x1F9B9
+        | 0x1F9BB
+        | 0x1F9CD..=0x1F9CF
+        | 0x1F9D1..=0x1F9DD
+        | 0x1FAC3..=0x1FAC5
+        | 0x1FAF0..=0x1FAF8 => 8,
+        0x1F1E6..=0x1F1FF => 9,
+        _ => return 0,
+    };
+
+    EMOJI_COMPOSITE_U8[idx as usize] as u32
+}
diff --git a/parley_data/src/lib.rs b/parley_data/src/lib.rs
index b9dca64d6..ae48da4dc 100644
--- a/parley_data/src/lib.rs
+++ b/parley_data/src/lib.rs
@@ -12,6 +12,9 @@ use icu_properties::props::{BidiClass, GeneralCategory, GraphemeClusterBreak, Sc
 #[cfg(feature = "baked")]
 pub mod generated;
 
+/// Emoji character properties relevant for text analysis.
+pub mod emoji;
+
 /// Unicode character properties relevant for text analysis.
 #[derive(Copy, Clone, Debug)]
 pub struct Properties(u32);
diff --git a/parley_data_gen/Cargo.toml b/parley_data_gen/Cargo.toml
index dae6a49ce..ec979d6a2 100644
--- a/parley_data_gen/Cargo.toml
+++ b/parley_data_gen/Cargo.toml
@@ -11,7 +11,7 @@ publish = false
 [dependencies]
 icu_properties = { workspace = true, features = ["compiled_data"] }
 packtab = { workspace = true }
-parley_data = { workspace = true }
+parley_data = { workspace = true, default-features = false }
 
 [lints]
 workspace = true
diff --git a/parley_data_gen/src/lib.rs b/parley_data_gen/src/lib.rs
index 534dc983f..e56a4c6ba 100644
--- a/parley_data_gen/src/lib.rs
+++ b/parley_data_gen/src/lib.rs
@@ -3,16 +3,20 @@
 
 //! See `./main.rs`.
 
-use icu_properties::props::{GeneralCategory, GraphemeClusterBreak, Script};
 use icu_properties::{
     CodePointMapData, CodePointSetData,
     props::{
-        BidiClass, Emoji, ExtendedPictographic, LineBreak, RegionalIndicator, VariationSelector,
+        BidiClass, Emoji, EmojiComponent, EmojiModifier, EmojiModifierBase, EmojiPresentation,
+        ExtendedPictographic, GeneralCategory, GraphemeClusterBreak, LineBreak, RegionalIndicator,
+        Script, VariationSelector,
     },
 };
-use parley_data::Properties;
-use std::fmt::Write as _;
-use std::io::{BufWriter, Write};
+use parley_data::{Properties, emoji::EmojiProperties};
+use std::{collections::BTreeMap, fmt::Write as _};
+use std::{
+    io::{BufWriter, Write},
+    ops::Range,
+};
 
 const COPYRIGHT_HEADER: &str =
     "// Copyright 2025 the Parley Authors\n// SPDX-License-Identifier: Apache-2.0 OR MIT\n";
@@ -29,35 +33,52 @@ pub struct Config {
 /// Exports ICU data as `PackTab` lookup tables + generated Rust code into the `out` directory.
 pub fn generate(out: std::path::PathBuf, config: &Config) {
     // Generate the data required for `CompositeProps`.
-    let values = {
-        // Dense values table for 0..=0x10FFFF
-        let mut values = Vec::<u32>::with_capacity(0x110000);
-        for cp in 0_u32..=0x10FFFF {
-            let v = Properties::new(
-                CodePointMapData::<Script>::new().get32(cp),
-                CodePointMapData::<GeneralCategory>::new().get32(cp),
-                CodePointMapData::<GraphemeClusterBreak>::new().get32(cp),
-                CodePointMapData::<BidiClass>::new().get32(cp),
-                CodePointSetData::new::<Emoji>().contains32(cp)
-                    || CodePointSetData::new::<ExtendedPictographic>().contains32(cp),
-                CodePointSetData::new::<VariationSelector>().contains32(cp),
-                CodePointSetData::new::<RegionalIndicator>().contains32(cp),
-                // See: https://github.com/unicode-org/icu4x/blob/ee5399a77a6b94efb5d4b60678bb458c5eedb25d/components/segmenter/src/line.rs#L338-L351
-                matches!(
-                    CodePointMapData::<LineBreak>::new().get32(cp),
-                    LineBreak::MandatoryBreak
-                        | LineBreak::CarriageReturn
-                        | LineBreak::LineFeed
-                        | LineBreak::NextLine
-                ),
+    // Dense characters table for 0..=0x10FFFF
+    let mut characters = Vec::with_capacity(0x110000);
+    let mut emojis = Vec::new();
+
+    for cp in 0_u32..=0x10FFFF {
+        let is_emoji = CodePointSetData::new::<Emoji>().contains32(cp);
+        let is_extended_pictographic =
+            CodePointSetData::new::<ExtendedPictographic>().contains32(cp);
+        let is_emoji_component = CodePointSetData::new::<EmojiComponent>().contains32(cp);
+        let is_regional_indicator = CodePointSetData::new::<RegionalIndicator>().contains32(cp);
+
+        let v = Properties::new(
+            CodePointMapData::<Script>::new().get32(cp),
+            CodePointMapData::<GeneralCategory>::new().get32(cp),
+            CodePointMapData::<GraphemeClusterBreak>::new().get32(cp),
+            CodePointMapData::<BidiClass>::new().get32(cp),
+            is_emoji || is_extended_pictographic,
+            CodePointSetData::new::<VariationSelector>().contains32(cp),
+            is_regional_indicator,
+            // See: https://github.com/unicode-org/icu4x/blob/ee5399a77a6b94efb5d4b60678bb458c5eedb25d/components/segmenter/src/line.rs#L338-L351
+            matches!(
+                CodePointMapData::<LineBreak>::new().get32(cp),
+                LineBreak::MandatoryBreak
+                    | LineBreak::CarriageReturn
+                    | LineBreak::LineFeed
+                    | LineBreak::NextLine
+            ),
+        );
+        characters.push(u32::from(v) as i64);
+
+        // See: https://unicode.org/reports/tr51/#Emoji_Characters
+        if is_emoji || is_extended_pictographic || is_emoji_component {
+            let emoji_properties = EmojiProperties::new(
+                is_emoji,
+                is_extended_pictographic,
+                is_emoji_component,
+                CodePointSetData::new::<EmojiPresentation>().contains32(cp),
+                CodePointSetData::new::<EmojiModifier>().contains32(cp),
+                CodePointSetData::new::<EmojiModifierBase>().contains32(cp),
+                is_regional_indicator,
             );
-            values.push(v.into());
+            emojis.push((cp, u32::from(emoji_properties)));
         }
-        values
-    };
-    let scalar_data: Vec<i64> = values.iter().map(|&v| v as i64).collect();
+    }
 
-    let (info, best) = packtab::pack_table(&scalar_data, Some(0), config.compression);
+    let (info, best) = packtab::pack_table(&characters, Some(0), config.compression);
 
     let namespace = "composite_packtab";
     let mut code = packtab::generate(
@@ -89,4 +110,84 @@ pub fn generate(out: std::path::PathBuf, config: &Config) {
     .unwrap();
     writeln!(&mut file).unwrap();
     write!(&mut file, "{code}").unwrap();
+
+    let code_extra = generate_emojis(&emojis);
+
+    writeln!(&mut file).unwrap();
+    write!(&mut file, "{code_extra}").unwrap();
+}
+
+fn generate_emojis(emojis: &[(u32, u32)]) -> String {
+    let mut emoji_map = BTreeMap::<u32, Vec<u32>>::new();
+
+    for (c, b) in emojis.iter().copied() {
+        emoji_map
+            .entry(b)
+            .and_modify(|e| e.push(c))
+            .or_insert_with(|| vec![c]);
+    }
+
+    let emoji_count = emoji_map.len();
+    let mut emoji_bits = Vec::with_capacity(emoji_count);
+    let mut code_emoji_matches = String::new();
+
+    for (b, mut a) in emoji_map {
+        a.sort();
+
+        let mut v = Vec::<Range<u32>>::new();
+
+        for c in a {
+            if let Some(last) = v.last_mut() {
+                if c - last.end == 1 {
+                    last.end = c;
+                    continue;
+                }
+            }
+            v.push(c..c);
+        }
+
+        let i = emoji_bits.len();
+
+        let mut s = String::new();
+
+        for r in v {
+            let start = r.start;
+            let end = r.end;
+            let is_single = end == start;
+
+            if is_single {
+                s.push_str(&format!("{start:#X}"));
+            } else {
+                s.push_str(&format!("{start:#X}..={end:#X}"));
+            }
+            s.push('|');
+        }
+
+        s.pop();
+        s.push_str(&format!(" => {i},"));
+
+        emoji_bits.push(b);
+        code_emoji_matches.push_str(&s);
+    }
+
+    let mut code_extra = String::new();
+
+    code_extra.push_str(&format!(
+        "
+static EMOJI_COMPOSITE_U8: [u8; {emoji_count}] = {emoji_bits:#?};
+
+#[allow(missing_docs, reason = \"generated code\")]
+#[inline]
+pub const fn emoji_composite_get(cp: u32) -> u32 {{
+    let idx = match cp {{
+        {code_emoji_matches}
+        _ => return 0,
+    }};
+
+    EMOJI_COMPOSITE_U8[idx as usize] as u32
+}}
+"
+    ));
+
+    code_extra
 }
diff --git a/parley_engine/src/analysis.rs b/parley_engine/src/analysis.rs
index 24e4a93a9..8a92e3290 100644
--- a/parley_engine/src/analysis.rs
+++ b/parley_engine/src/analysis.rs
@@ -23,7 +23,7 @@ use icu_segmenter::{
     LineSegmenterBorrowed, WordSegmenter, WordSegmenterBorrowed,
 };
 use parlance::{BaseDirection, WordBreak};
-use parley_data::Properties;
+use parley_data::{Properties, emoji::EmojiProperties};
 
 use crate::bidi;
 use crate::break_overrides::LineBreakContext;
@@ -160,6 +160,11 @@ impl AnalysisDataSources {
     fn brackets(&self) -> CodePointMapDataBorrowed<'_, BidiMirroringGlyph> {
         const { CodePointMapData::new() }
     }
+
+    #[inline(always)]
+    pub const fn emoji_properties(&self, c: char) -> EmojiProperties {
+        EmojiProperties::get(c)
+    }
 }
 
 #[cfg(feature = "complex-scripts")]
@@ -187,6 +192,8 @@ pub struct CharInfo {
     pub bidi_class: icu_properties::props::BidiClass,
     /// Whether or not the character is a bracket, plus mirror data if so.
     pub bracket: BidiMirroringGlyph,
+    /// The emoji properties of this character.
+    pub emoji_properties: EmojiProperties,
 
     flags: u8,
 }
@@ -222,6 +229,7 @@ impl CharInfo {
         grapheme_cluster_break: GraphemeClusterBreak,
         bidi_class: icu_properties::props::BidiClass,
         bracket: BidiMirroringGlyph,
+        emoji_properties: EmojiProperties,
         is_variation_selector: bool,
         is_region_indicator: bool,
         is_control: bool,
@@ -236,6 +244,7 @@ impl CharInfo {
             grapheme_cluster_break,
             bidi_class,
             bracket,
+            emoji_properties,
             flags: (is_variation_selector as u8) << Self::VARIATION_SELECTOR_SHIFT
                 | (is_region_indicator as u8) << Self::REGION_INDICATOR_SHIFT
                 | (is_control as u8) << Self::CONTROL_SHIFT
@@ -611,6 +620,7 @@ pub(crate) fn analyze_text(
     });
 
     let properties = |c| data_sources.properties(c);
+    let emoji_properties = |c| data_sources.emoji_properties(c);
 
     let mut needs_bidi_resolution = false;
 
@@ -633,6 +643,12 @@ pub(crate) fn analyze_text(
                 let is_region_indicator = properties.is_region_indicator();
                 let next_mandatory_linebreak = properties.is_mandatory_linebreak();
 
+                let emoji_properties = if is_emoji_or_pictograph {
+                    emoji_properties(ch)
+                } else {
+                    EmojiProperties::ZERO
+                };
+
                 let boundary = if is_mandatory_linebreak {
                     Boundary::Mandatory
                 } else {
@@ -662,6 +678,7 @@ pub(crate) fn analyze_text(
                     grapheme_cluster_break,
                     bidi_class,
                     bracket,
+                    emoji_properties,
                     is_variation_selector,
                     is_region_indicator,
                     general_category == GeneralCategory::Control,
diff --git a/parley_engine/src/emoji/dfa.rs b/parley_engine/src/emoji/dfa.rs
new file mode 100644
index 000000000..94bc3ced1
--- /dev/null
+++ b/parley_engine/src/emoji/dfa.rs
@@ -0,0 +1,283 @@
+// Copyright 2026 Christian Hansen
+// SPDX-License-Identifier: MIT
+// <https://github.com/chansen/c-emoji>
+//
+// Copyright 2026 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use super::types::{EmojiPresentationStyle, EmojiSegmentationCategory, EmojiSequence, EmojiState};
+
+/// The transition table for Emoji DFA.
+///
+/// <https://unicode.org/reports/tr51/#Definitions>
+static DFA_TRANS: [[u8; 13]; 13] = {
+    use EmojiSegmentationCategory as Category;
+    use EmojiState as State;
+
+    let mut t = [[State::Reject as u8; 13]; 13];
+
+    /// Adds a state transition to the DFA transition table.
+    macro_rules! add {
+        ($state:expr, $category:expr, $next_state:expr) => {
+            t[$state as usize][$category as usize] = $next_state as u8
+        };
+    }
+
+    // Text and Emoji presentation sequences
+    {
+        add!(State::Start, Category::Emoji, State::Emoji);
+
+        add!(State::Start, Category::EmojiPresentation, State::Emoji);
+
+        // Text presentation sequence
+        //
+        // <https://unicode.org/reports/tr51/#def_text_presentation_sequence>
+        add!(State::Emoji, Category::Vs15, State::Terminal);
+
+        // Emoji presentation sequence
+        //
+        // <https://unicode.org/reports/tr51/#def_emoji_presentation_sequence>
+        add!(State::Emoji, Category::Vs16, State::OptionalZwj);
+
+        // ZWJ
+        add!(State::Emoji, Category::Zwj, State::Zwj);
+    }
+
+    // Emoji modifier sequence
+    //
+    // <https://unicode.org/reports/tr51/#def_emoji_modifier_sequence>
+    {
+        add!(
+            State::Start,
+            Category::EmojiModifierBase,
+            State::EmojiModifierBase
+        );
+
+        add!(State::EmojiModifierBase, Category::Vs16, State::OptionalZwj);
+        add!(State::EmojiModifierBase, Category::Zwj, State::Zwj);
+        add!(
+            State::EmojiModifierBase,
+            Category::EmojiModifier,
+            State::OptionalZwj
+        );
+
+        // other
+        add!(State::Start, Category::EmojiModifier, State::Terminal);
+    }
+
+    // Emoji flag sequence -- A sequence of two Regional Indicator characters.
+    //
+    // <https://unicode.org/reports/tr51/#def_emoji_flag_sequence>
+    {
+        add!(
+            State::Start,
+            Category::RegionalIndicator,
+            State::RegionalIndicator
+        );
+
+        add!(
+            State::RegionalIndicator,
+            Category::RegionalIndicator,
+            State::Terminal
+        );
+    }
+
+    // Emoji tag sequence (ETS).
+    //
+    // <https://unicode.org/reports/tr51/#def_emoji_tag_sequence>
+    {
+        add!(State::Start, Category::TagBase, State::TagBase);
+
+        add!(State::TagBase, Category::Vs15, State::Terminal);
+        add!(State::TagBase, Category::Vs16, State::OptionalZwj);
+        add!(State::TagBase, Category::TagSpec, State::TagSpec);
+        add!(State::TagBase, Category::TagEnd, State::TagEmpty); // without any `TagSpec`
+        add!(State::TagBase, Category::Zwj, State::Zwj);
+
+        // (seq)+
+        add!(State::TagSpec, Category::TagSpec, State::TagSpec);
+        add!(State::TagSpec, Category::TagEnd, State::Terminal);
+    }
+
+    // Emoji keycap sequence.
+    //
+    // <https://unicode.org/reports/tr51/#def_emoji_keycap_sequence>
+    {
+        add!(State::Start, Category::KeycapBase, State::KeycapBase);
+
+        add!(State::KeycapBase, Category::KeycapEnd, State::Terminal);
+        add!(State::KeycapBase, Category::Vs15, State::KeycapVs);
+        add!(State::KeycapBase, Category::Vs16, State::KeycapVs);
+
+        add!(State::KeycapVs, Category::KeycapEnd, State::Terminal);
+    }
+
+    // Emoji ZWJ sequence.
+    //
+    // <https://unicode.org/reports/tr51/#def_emoji_zwj_sequence>
+    {
+        add!(State::OptionalZwj, Category::Zwj, State::Zwj);
+
+        // (zwj emoji_zwj_element)+
+        add!(State::Zwj, Category::Emoji, State::Emoji);
+        add!(State::Zwj, Category::EmojiPresentation, State::Emoji);
+        add!(
+            State::Zwj,
+            Category::EmojiModifierBase,
+            State::EmojiModifierBase
+        );
+    }
+
+    t
+};
+
+/// Recognizes Unicode emoji sequence.
+#[derive(Clone, Copy, Debug)]
+pub struct EmojiDFA {
+    /// The current emoji state.
+    state: EmojiState,
+    /// Stores the visited state and category.
+    recorded: (u16, u16),
+}
+
+impl EmojiDFA {
+    /// A default value for [`EmojiDFA`].
+    const DEFAULT: Self = Self {
+        state: EmojiState::Start,
+        recorded: (0, 0),
+    };
+
+    /// Creates a new [`EmojiDFA`].
+    #[inline]
+    pub const fn new() -> Self {
+        Self::DEFAULT
+    }
+
+    /// Updates the emoji state with [`EmojiSegmentationCategory`].
+    #[inline]
+    const fn step(&mut self, category: EmojiSegmentationCategory) {
+        self.state = EmojiState::from_u8(DFA_TRANS[self.state as usize][category as usize]);
+    }
+
+    /// Records the emoji state and segmentation category with [`EmojiSegmentationCategory`].
+    #[inline]
+    pub const fn step_record(&mut self, category: EmojiSegmentationCategory) {
+        self.step(category);
+
+        if self.is_rejected() || self.is_started() {
+            return;
+        }
+
+        self.recorded.0 |= 1 << (self.state as u8);
+        self.recorded.1 |= 1 << (category as u8);
+    }
+
+    /// Returns true if the emoji state is rejected.
+    #[inline]
+    pub(crate) const fn is_rejected(self) -> bool {
+        self.state.eq(EmojiState::Reject)
+    }
+
+    /// Returns true if the emoji state is started.
+    #[inline]
+    pub(crate) const fn is_started(self) -> bool {
+        self.state.eq(EmojiState::Start)
+    }
+
+    /// Returns true if the emoji state is accepting.
+    #[allow(unused)]
+    #[inline]
+    pub(crate) const fn is_accepting(self) -> bool {
+        const START: u8 = EmojiState::Terminal as u8;
+        const END: u8 = EmojiState::RegionalIndicator as u8;
+
+        let cur = self.state as u8;
+
+        START <= cur && cur <= END
+    }
+
+    #[inline]
+    const fn contains_state(self, state: EmojiState) -> bool {
+        self.recorded.0 & (1 << (state as u8)) != 0
+    }
+
+    #[inline]
+    const fn contains_category(self, category: EmojiSegmentationCategory) -> bool {
+        self.recorded.1 & (1 << (category as u8)) != 0
+    }
+
+    /// Return the [`EmojiSequence`].
+    ///
+    /// <https://www.unicode.org/reports/tr51/#Emoji_Sequences>
+    #[inline]
+    const fn sequence(self) -> EmojiSequence {
+        if self.contains_category(EmojiSegmentationCategory::Zwj) {
+            return EmojiSequence::Zwj;
+        }
+
+        if self.contains_state(EmojiState::TagBase) && self.contains_state(EmojiState::Terminal) {
+            return EmojiSequence::Tag;
+        }
+
+        if self.contains_state(EmojiState::RegionalIndicator)
+            && self.contains_state(EmojiState::Terminal)
+        {
+            return EmojiSequence::Flag;
+        }
+
+        if self.contains_category(EmojiSegmentationCategory::EmojiModifierBase)
+            && self.contains_category(EmojiSegmentationCategory::EmojiModifier)
+        {
+            return EmojiSequence::Modifier;
+        }
+
+        if self.contains_category(EmojiSegmentationCategory::KeycapBase) {
+            return EmojiSequence::Keycap;
+        }
+
+        EmojiSequence::Basic
+    }
+
+    /// Returns the emoji presentation style.
+    #[inline]
+    pub const fn presentation_style(self) -> EmojiPresentationStyle {
+        // Emoji presentation with variation selectors
+        if self.contains_category(EmojiSegmentationCategory::Vs15) {
+            return EmojiPresentationStyle::Text;
+        }
+        if self.contains_category(EmojiSegmentationCategory::Vs16) {
+            return EmojiPresentationStyle::Emoji;
+        }
+
+        // `Emoji_Presentation=Yes`
+        if self.contains_category(EmojiSegmentationCategory::EmojiPresentation) {
+            return EmojiPresentationStyle::Emoji;
+        }
+
+        // Resolves presentation
+        match self.sequence() {
+            // unqualified keycap, e.g. #⃣
+            EmojiSequence::Keycap => EmojiPresentationStyle::Default,
+            EmojiSequence::Basic => {
+                // single emoji modifier, e.g. 🏻
+                if self.contains_category(EmojiSegmentationCategory::EmojiModifier) {
+                    EmojiPresentationStyle::Emoji
+                } else {
+                    // single emoji modifier base, e.g ☝
+                    if self.contains_category(EmojiSegmentationCategory::EmojiModifierBase) {
+                        EmojiPresentationStyle::Text
+                    } else {
+                        EmojiPresentationStyle::Default
+                    }
+                }
+            }
+            _ => EmojiPresentationStyle::Emoji,
+        }
+    }
+}
+
+impl Default for EmojiDFA {
+    fn default() -> Self {
+        Self::DEFAULT
+    }
+}
diff --git a/parley_engine/src/emoji/mod.rs b/parley_engine/src/emoji/mod.rs
new file mode 100644
index 000000000..a43cbfbee
--- /dev/null
+++ b/parley_engine/src/emoji/mod.rs
@@ -0,0 +1,17 @@
+// Copyright 2026 Christian Hansen
+// SPDX-License-Identifier: MIT
+// <https://github.com/chansen/c-emoji>
+//
+// Copyright 2026 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Port of [c-emoji] (MIT) and follow the [UTS51](Unicode Technical Standard #51).
+//!
+//! [c-emoji]: <https://github.com/chansen/c-emoji>
+//! [UTS51]: <https://www.unicode.org/reports/tr51/>
+
+mod dfa;
+mod types;
+
+pub use dfa::EmojiDFA;
+pub use types::{EmojiPresentationStyle, EmojiSegmentationCategory};
diff --git a/parley_engine/src/emoji/types.rs b/parley_engine/src/emoji/types.rs
new file mode 100644
index 000000000..fa5163f5e
--- /dev/null
+++ b/parley_engine/src/emoji/types.rs
@@ -0,0 +1,196 @@
+// Copyright 2026 Christian Hansen
+// SPDX-License-Identifier: MIT
+// <https://github.com/chansen/c-emoji>
+//
+// Copyright 2026 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use parley_data::emoji::EmojiProperties;
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum EmojiState {
+    /// No valid transition
+    Reject = 0,
+    /// Not inside any sequence
+    Start,
+
+    /// Accepting — a complete sequence ends here (may be extended)
+    Terminal,
+    Emoji,
+    EmojiModifierBase,
+    OptionalZwj,
+    KeycapVs,
+    TagBase,
+    RegionalIndicator,
+
+    /// Pending — inside a valid prefix, no complete sequence yet
+    TagSpec,
+    TagEmpty,
+    KeycapBase,
+    Zwj,
+}
+
+impl EmojiState {
+    #[inline]
+    pub(crate) const fn from_u8(value: u8) -> Self {
+        match value {
+            1 => Self::Start,
+            2 => Self::Terminal,
+            3 => Self::Emoji,
+            4 => Self::EmojiModifierBase,
+            5 => Self::OptionalZwj,
+            6 => Self::KeycapVs,
+            7 => Self::TagBase,
+            8 => Self::RegionalIndicator,
+            9 => Self::TagSpec,
+            10 => Self::TagEmpty,
+            11 => Self::KeycapBase,
+            12 => Self::Zwj,
+            _ => Self::Reject,
+        }
+    }
+
+    #[inline]
+    pub(crate) const fn eq(self, other: Self) -> bool {
+        (self as u8) == (other as u8)
+    }
+}
+
+/// Represents the category of an emoji segmentation.
+///
+/// <https://unicode.org/reports/tr51/#Definitions>
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EmojiSegmentationCategory {
+    /// Emoji property
+    Emoji = 0,
+    /// Emoji presentation property
+    EmojiPresentation,
+    /// Emoji modifier property
+    EmojiModifier,
+    /// Emoji modifier base property
+    EmojiModifierBase,
+    /// `[0-9]` `#` `*`
+    KeycapBase,
+    /// `0x20E3`
+    KeycapEnd,
+    /// `0x1F3F4`
+    TagBase,
+    /// `[0xE0030-0xE0039]` or `[0xE0061-0xE007A]`
+    TagSpec,
+    /// `0xE007F`
+    TagEnd,
+    /// Regional Indicator character
+    RegionalIndicator,
+    /// `0xFE0E`
+    Vs15,
+    /// `0xFE0F`
+    Vs16,
+    /// `0x200D`
+    Zwj,
+    /// No value
+    None,
+}
+
+impl EmojiSegmentationCategory {
+    /// Returns the category of the given codepoint and properties.
+    #[inline]
+    pub const fn from_codepoint(cp: u32, properties: EmojiProperties) -> Self {
+        match cp {
+            0x30..=0x39 | 0x23 | 0x2A => Self::KeycapBase,
+            0x200D => Self::Zwj,
+            0x20E3 => Self::KeycapEnd,
+            0xFE0E => Self::Vs15,
+            0xFE0F => Self::Vs16,
+            0x1F3F4 => Self::TagBase,
+            0xE0030..=0xE0039 | 0xE0061..=0xE007A => Self::TagSpec,
+            0xE007F => Self::TagEnd,
+            _ => {
+                if properties.is_regional_indicator() {
+                    return Self::RegionalIndicator;
+                }
+
+                if properties.is_emoji_modifier_base() {
+                    return Self::EmojiModifierBase;
+                }
+
+                if properties.is_emoji_modifier() {
+                    return Self::EmojiModifier;
+                }
+
+                if properties.is_emoji_presentation() {
+                    return Self::EmojiPresentation;
+                }
+
+                if properties.is_emoji() {
+                    return Self::Emoji;
+                }
+
+                Self::None
+            }
+        }
+    }
+
+    /// Returns true if it a presentation selector, VS15 or VS16.
+    ///
+    /// e.g.
+    ///  - `U+270C + U+FE0E`: `✌`, force text presentation
+    ///  - `U+270C + U+FE0F`: `✌️`, force emoji presentation
+    pub const fn is_presentation_selector(self) -> bool {
+        matches!(self, Self::Vs15 | Self::Vs16)
+    }
+}
+
+/// Represents the category of an emoji sequence.
+///
+/// <https://www.unicode.org/reports/tr51/#Emoji_Sequences>
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub(crate) enum EmojiSequence {
+    /// A single character
+    Basic,
+    /// Emoji modifier sequence
+    ///
+    /// <https://www.unicode.org/reports/tr51/#def_emoji_modifier_sequence>
+    Modifier,
+    /// Emoji flag sequence
+    ///
+    /// <https://www.unicode.org/reports/tr51/#def_emoji_flag_sequence>
+    Flag,
+    /// Emoji tag sequence
+    ///
+    /// <https://www.unicode.org/reports/tr51/#def_emoji_tag_sequence>
+    Tag,
+    /// Emoji keycap sequence
+    ///
+    /// <https://www.unicode.org/reports/tr51/#def_emoji_keycap_sequence>
+    Keycap,
+    /// Emoji ZWJ sequence
+    ///
+    /// <https://www.unicode.org/reports/tr51/#def_emoji_zwj_sequence>
+    Zwj,
+}
+
+/// Represents presentation style for displaying emojis.
+///
+/// <https://www.unicode.org/reports/tr51/tr51-30.html#Presentation_Style>
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Default, Debug)]
+pub enum EmojiPresentationStyle {
+    /// Represents default presentation.
+    #[default]
+    Default,
+    /// Represents a text presentation.
+    Text,
+    /// Represents an emoji presentation.
+    Emoji,
+}
+
+impl EmojiPresentationStyle {
+    /// Returns true if it is an emoji presentation.
+    #[inline]
+    pub const fn is_emoji(self) -> bool {
+        matches!(self, Self::Emoji)
+    }
+}
diff --git a/parley_engine/src/lib.rs b/parley_engine/src/lib.rs
index 29507036a..210df180d 100644
--- a/parley_engine/src/lib.rs
+++ b/parley_engine/src/lib.rs
@@ -27,6 +27,7 @@ mod analysis;
 mod analyzer;
 pub mod bidi;
 pub mod break_overrides;
+pub mod emoji;
 mod glyph;
 pub mod itemize;
 mod lru_cache;
diff --git a/parley_engine/src/shape/cluster.rs b/parley_engine/src/shape/cluster.rs
index 395318d94..bbb7f75e1 100644
--- a/parley_engine/src/shape/cluster.rs
+++ b/parley_engine/src/shape/cluster.rs
@@ -7,12 +7,15 @@
 use alloc::vec::Vec;
 use icu_normalizer::properties::Decomposed;
 
-use crate::{CharInfo, analysis::AnalysisDataSources};
+use crate::{
+    CharInfo,
+    analysis::AnalysisDataSources,
+    emoji::{EmojiDFA, EmojiPresentationStyle, EmojiSegmentationCategory},
+};
 
 #[derive(Debug, Default)]
 pub struct CharCluster {
     chars: Vec<Char>,
-    is_emoji: bool,
     map_len: u8,
     start: u32,
     end: u32,
@@ -20,6 +23,7 @@ pub struct CharCluster {
     comp: Form,
     decomp: Form,
     best_ratio: f32,
+    emoji_presentation_style: EmojiPresentationStyle,
 }
 
 impl CharCluster {
@@ -38,7 +42,7 @@ impl CharCluster {
 
     #[inline(always)]
     pub fn is_emoji(&self) -> bool {
-        self.is_emoji
+        self.emoji_presentation_style.is_emoji()
     }
 }
 
@@ -60,6 +64,8 @@ pub struct Char {
     /// Indexes into the list of styles for the containing text run, to find the style applicable
     /// to this character.
     pub style_index: u16,
+    /// True if the character is an emoji presentation selector (VS15 or VS16).
+    pub is_emoji_presentation_selector: bool,
 }
 
 /// Whitespace content of a cluster.
@@ -101,7 +107,6 @@ impl CharCluster {
     #[inline]
     pub(crate) fn clear(&mut self) {
         self.chars.clear();
-        self.is_emoji = false;
         self.map_len = 0;
         self.start = 0;
         self.end = 0;
@@ -109,6 +114,7 @@ impl CharCluster {
         self.comp.clear();
         self.decomp.clear();
         self.best_ratio = 0.;
+        self.emoji_presentation_style = EmojiPresentationStyle::Default;
     }
 
     #[inline(always)]
@@ -282,40 +288,31 @@ impl CharCluster {
         self.clear();
 
         let mut force_normalize = false;
-        let mut is_emoji_or_pictograph = false;
+        let mut is_emoji = false;
         let mut map_len: u8 = 0;
+        let mut emoji_dfa = EmojiDFA::new();
         let start = *code_unit_offset_in_string as u32;
 
         for ((_, ch), (info, style_index)) in
             segment_text.char_indices().zip(item_infos_iter.by_ref())
         {
-            force_normalize |= info.force_normalize();
-            // TODO - make emoji detection more complete, as per (except using composite Trie tables as
-            //  much as possible:
-            //  https://github.com/conor-93/parley/blob/4637d826732a1a82bbb3c904c7f47a16a21cceec/parley/src/shape/mod.rs#L221-L269
-            is_emoji_or_pictograph |= info.is_emoji_or_pictograph();
             *code_unit_offset_in_string += ch.len_utf8();
+            force_normalize |= info.force_normalize();
+
+            is_emoji |= info.is_emoji_or_pictograph();
+
+            let mut is_emoji_presentation_selector = false;
+
+            if is_emoji {
+                let category =
+                    EmojiSegmentationCategory::from_codepoint(ch as u32, info.emoji_properties);
+
+                is_emoji_presentation_selector = category.is_presentation_selector();
 
-            // TODO: Explore ignoring other modifiers in determining `contributes_to_shaping`:
-            //  regional indicators, subdivision flag tag sequences, skin tone modifiers
-            //  See also: https://github.com/google/emoji-segmenter
-
-            // If the color emoji has a non-printing variation selector, ignore the variation selector.
-            // Its presentation depends on the platform and font.
-            //
-            // e.g.
-            //  - `U+270C + U+FE0E`: `✌`, force text presentation
-            //  - `U+270C + U+FE0F`: `✌️`, force emoji presentation
-            //
-            // See <https://www.unicode.org/reports/tr51/#Emoji_Variation_Sequences> for emoji
-            // variation sequences and
-            // <https://www.unicode.org/versions/Unicode17.0.0/core-spec/chapter-23/#G19053> for
-            // variation selectors more generally.
-            let is_emoji_with_non_printing_variation_selector =
-                is_emoji_or_pictograph && info.is_variation_selector();
-
-            let contributes_to_shaping =
-                info.contributes_to_shaping() && !is_emoji_with_non_printing_variation_selector;
+                emoji_dfa.step_record(category);
+            }
+
+            let contributes_to_shaping = info.contributes_to_shaping();
             if contributes_to_shaping {
                 map_len += 1;
             }
@@ -325,16 +322,20 @@ impl CharCluster {
                 contributes_to_shaping,
                 style_index,
                 is_control_character: info.is_control(),
+                is_emoji_presentation_selector,
             });
         }
 
         // Finalize cluster metadata
         let end = *code_unit_offset_in_string as u32;
-        self.is_emoji = is_emoji_or_pictograph;
         self.map_len = map_len;
         self.start = start;
         self.end = end;
         self.force_normalize = force_normalize;
+
+        if is_emoji {
+            self.emoji_presentation_style = emoji_dfa.presentation_style();
+        }
     }
 }
 
@@ -421,6 +422,12 @@ impl<'a> Mapper<'a> {
         }
         let mut mapped = 0;
         for c in self.chars.iter() {
+            // If the color emoji has a presentation style, ignore the variation selector.
+            if c.is_emoji_presentation_selector {
+                mapped += 1;
+                continue;
+            }
+
             if !c.contributes_to_shaping {
                 if !self.has_contributing {
                     mapped += 1;
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_hint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_hint.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_hint.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_hint.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_hint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_hint_skew.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_hint_skew.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_hint_skew.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_nohint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_nohint.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_nohint.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_nohint.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_nohint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_nohint_skew.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-2x_nohint_skew.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-2x_nohint_skew.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-hint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-hint.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-hint.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-hint.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-hint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-hint_skew.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-hint_skew.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-hint_skew.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-nohint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-nohint.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-nohint.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-nohint.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-nohint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style-nohint_skew.png
similarity index 100%
rename from parley_tests/snapshots/draw_colr_emoji_with_non_printing_variation_selector_16-nohint_skew.png
rename to parley_tests/snapshots/draw_colr_emoji_with_presentation_style-nohint_skew.png
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_hint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_hint.png
new file mode 100644
index 000000000..89307d853
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_hint.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_hint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_hint_skew.png
new file mode 100644
index 000000000..f9f2da85b
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_hint_skew.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_nohint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_nohint.png
new file mode 100644
index 000000000..89307d853
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_nohint.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_nohint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_nohint_skew.png
new file mode 100644
index 000000000..f9f2da85b
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-2x_nohint_skew.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-hint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-hint.png
new file mode 100644
index 000000000..bdcdbb76f
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-hint.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-hint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-hint_skew.png
new file mode 100644
index 000000000..9ba1318ef
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-hint_skew.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-nohint.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-nohint.png
new file mode 100644
index 000000000..bdcdbb76f
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-nohint.png differ
diff --git a/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-nohint_skew.png b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-nohint_skew.png
new file mode 100644
index 000000000..9ba1318ef
Binary files /dev/null and b/parley_tests/snapshots/draw_colr_emoji_with_presentation_style_without_setting_default_font-nohint_skew.png differ
diff --git a/parley_tests/tests/draw.rs b/parley_tests/tests/draw.rs
index b32e9891c..da49dc45c 100644
--- a/parley_tests/tests/draw.rs
+++ b/parley_tests/tests/draw.rs
@@ -173,11 +173,50 @@ fn draw_colr_emoji() {
     });
 }
 
-/// Test COLR emoji with non printing variation selector 16 rendering across different hinting,
-/// per-glyph transform, and scale configurations.
+/// Test COLR emoji rendering across different hinting, per-glyph transform, and scale configurations.
+///
+/// The COLR emoji with presentation style(VS16).
+///
+/// The default color emoji is different for each system, so only macOS was added for testing.
 #[cfg(all(target_os = "macos", feature = "system"))]
 #[test]
-fn draw_colr_emoji_with_non_printing_variation_selector_16() {
+fn draw_colr_emoji_with_presentation_style() {
+    let mut env = TestEnv::new(test_name!(), None);
+    env.set_tolerance(5.0);
+
+    let collection = &mut env.font_context().collection;
+    collection.load_system_fonts();
+
+    let text = "\u{270c}\u{fe0f}\u{2705}\u{270c}\u{fe0f}";
+
+    test_with_configs(&mut env, |env| {
+        let mut builder = env.ranged_builder(text);
+        builder.push_default(StyleProperty::FontSize(24.0));
+        // Following <fontique/src/backend/coretext.rs#L33>
+        builder.push_default(StyleProperty::FontFamily(
+            parley::GenericFamily::Emoji.into(),
+        ));
+        builder.push(
+            StyleProperty::FontFamily(FontFamily::named("Noto Color Emoji")),
+            0..9,
+        );
+
+        let mut layout = builder.build(text);
+        layout.break_all_lines(None);
+        layout.align(Alignment::Start, AlignmentOptions::default());
+        layout
+    });
+}
+
+/// Test COLR emoji rendering across different hinting, per-glyph transform, and scale configurations.
+///
+/// The COLR emoji with presentation style without setting the default font,
+/// and should fallback to the system default color emoji font.
+///
+/// The default color emoji is different for each system, so only macOS was added for testing.
+#[cfg(all(target_os = "macos", feature = "system"))]
+#[test]
+fn draw_colr_emoji_with_presentation_style_without_setting_default_font() {
     let mut env = TestEnv::new(test_name!(), None);
     env.set_tolerance(5.0);
 
@@ -189,9 +228,6 @@ fn draw_colr_emoji_with_non_printing_variation_selector_16() {
     test_with_configs(&mut env, |env| {
         let mut builder = env.ranged_builder(text);
         builder.push_default(StyleProperty::FontSize(24.0));
-        builder.push_default(StyleProperty::FontFamily(FontFamily::named(
-            "Apple Color Emoji",
-        )));
         builder.push(
             StyleProperty::FontFamily(FontFamily::named("Noto Color Emoji")),
             0..9,